40

41 hyphenate: function(){

42 return this.replace(/[A-Z]/g, function(match){

43 return ('-' + match.charAt(0).toLowerCase());

44 });

23 strength += Math.min(3, value.length - value.replace(/\W/g,"").length) * 15;

24 // Factor in the number of Upper case letters

25 strength += Math.min(3, value.length - value.replace(/[A-Z]/g,"").length) * 10;

26

27 // Normalizxe between 0 and 100

17

18 // Replace all letters with their number equivalents

19 $checkString = preg_replace_callback('/[A-Z]/', array('self','alphaToNumberCallback'), $checkString);

20

21 // Perform mod 97 and subtract from 98

46 })

47 .filter(function(v) {

48 if (v.match(/[a-z]/)) return false;

49 var len = v.length;

50 return len >=6 && len <= 8;

8 * been stored. If separator is a regular expression then

9 * inside of SplitMatch helper the [[Match]] method of R is called giving it the arguments corresponding;

10 * @description: Argument is regexp /[a-z]/, and instance is String("abc");

11 */

12

13 var __string = new String("abc");

14

15 var __re = /[a-z]/;

16

17 __split = __string.split(__re);

32 },

33 hyphenate: function () {

34 return this.replace(/[A-Z]/g, function (match) {

35 return ('-' + match.charAt(0).toLowerCase());

36 });

438 context "a Regex," do

439 expected, same, different =

440 /[a-z]/,

441 "a",

442 "A"

444 it_behaves_like "a diff matcher", expected, same, different,

445 <<-EOF

446 - /[a-z]/+ "A"

447 Where, - 1 missing, + 1 additional

448 EOF

453 it_behaves_like "a diff matcher", expected, same, different,

454 <<-EOF

455 - /[a-z]/+ :a

456 Where, - 1 missing, + 1 additional

457 EOF

415

416 // Different regex, same modifiers

417 var r11 = /[a-z]/gi;

418 var r13 = /[0-9]/gi; // oops! different

419 equal(QUnit.equiv(r11, r13), false, "Regex pattern");

163 });

164

165 test("/[a-z]/g", {

166 type: "Program",

167 body: [

170 expression: {

171 type: "Literal",

172 value: /[a-z]/,

173 regex: {

174 pattern: "[a-z]",

123 self.purchased = true

124 self.selling_price = amount

125 self.confirmation_number = Time.now.strftime("%Y%m%d") + "-" + Digest::MD5.hexdigest(authorization).gsub(/[a-z]/, '')[0..8]

126 save!

127

135 def self.encode_str(keys)

136 keys.to_s.split("").map do |key|

137 key =~ /[a-z]/ || MAPPED_KEYS[key] ? MAPPED_KEYS[key] || key.upcase.unpack("c")[0] :

138 key =~ /[A-Z]/ || SPECIAL_KEYS[key] ? [Keys[:shift], SPECIAL_KEYS[key] || key.unpack("c")[0], Keys[:null]] :

18 class PasswordValidator extends Object {

19 static $character_strength_tests = array(

20 'lowercase' => '/[a-z]/',

21 'uppercase' => '/[A-Z]/',

61 <span class='line'> 54</span> </span><span class="WHIT"> </span><span class="NAME">message</span><span class="WHIT"> </span><span class="PUNC">=</span><span class="WHIT"> </span><span class="NAME">this.message.apply</span><span class="PUNC">(</span><span class="KEYW">this</span><span class="PUNC">,</span><span class="WHIT"> </span><span class="NAME">arguments</span><span class="PUNC">)</span><span class="PUNC">;</span><span class="WHIT">

62 <span class='line'> 55</span> </span><span class="WHIT"> </span><span class="PUNC">}</span><span class="WHIT"> </span><span class="KEYW">else</span><span class="WHIT"> </span><span class="PUNC">{</span><span class="WHIT">

63 <span class='line'> 56</span> </span><span class="WHIT"> </span><span class="KEYW">var</span><span class="WHIT"> </span><span class="NAME">englishyPredicate</span><span class="WHIT"> </span><span class="PUNC">=</span><span class="WHIT"> </span><span class="NAME">matcherName.replace</span><span class="PUNC">(</span><span class="REGX">/[A-Z]/g</span><span class="PUNC">,</span><span class="WHIT"> </span><span class="KEYW">function</span><span class="PUNC">(</span><span class="NAME">s</span><span class="PUNC">)</span><span class="WHIT"> </span><span class="PUNC">{</span><span class="WHIT"> </span><span class="KEYW">return</span><span class="WHIT"> </span><span class="STRN">' '</span><span class="WHIT"> </span><span class="PUNC">+</span><span class="WHIT"> </span><span class="NAME">s.toLowerCase</span><span class="PUNC">(</span><span class="PUNC">)</span><span class="PUNC">;</span><span class="WHIT"> </span><span class="PUNC">}</span><span class="PUNC">)</span><span class="PUNC">;</span><span class="WHIT">

64 <span class='line'> 57</span> </span><span class="WHIT"> </span><span class="NAME">message</span><span class="WHIT"> </span><span class="PUNC">=</span><span class="WHIT"> </span><span class="STRN">"Expected "</span><span class="WHIT"> </span><span class="PUNC">+</span><span class="WHIT"> </span><span class="NAME">jasmine.pp</span><span class="PUNC">(</span><span class="NAME">this.actual</span><span class="PUNC">)</span><span class="WHIT"> </span><span class="PUNC">+</span><span class="WHIT"> </span><span class="STRN">" "</span><span class="WHIT"> </span><span class="PUNC">+</span><span class="WHIT"> </span><span class="NAME">englishyPredicate</span><span class="PUNC">;</span><span class="WHIT">

65 <span class='line'> 58</span> </span><span class="WHIT"> </span><span class="KEYW">if</span><span class="WHIT"> </span><span class="PUNC">(</span><span class="NAME">matcherArgs.length</span><span class="WHIT"> </span><span class="PUNC">></span><span class="WHIT"> </span><span class="NUMB">0</span><span class="PUNC">)</span><span class="WHIT"> </span><span class="PUNC">{</span><span class="WHIT">

386

387 function regexp_shouldEqual() {

388 /[a-z]/.should.equal(/[a-z]/);

389 },

390

391 function regexp_shouldNotEqual() {

392 /[a-z]/.should.not.equal(/[1-9]/);

393 }

394

778

779 function regexp_shouldNotEqual() {

780 /[a-z]/.should.not.equal(/[a-z]/);

781 }

782

141

142 unless c =~ /[\w.]/

143 if last_c =~ /[A-Z]/

144 before = la[0..i].join()

145 return false if before =~ /new\s+$/

29

30 def munge(str)

31 res = str.gsub(/[a-z]/, '\1\1')

32 run_string_munged str, res

33 res

152 */

153 function atobLookup(chr) {

154 if (/[A-Z]/.test(chr)) {

155 return chr.charCodeAt(0) - "A".charCodeAt(0);

156 }

157 if (/[a-z]/.test(chr)) {

158 return chr.charCodeAt(0) - "a".charCodeAt(0) + 26;

159 }

64 {

65 my ($cmd, @args) = split ' ', $buf;

66 $cmd =~ tr/[a-z]/[A-Z]/;

67 $cmd =~ tr/_/-/;

68 if ($cmd eq 'USER-EXISTS') {

142 s1 << r3

143 if r3

144 if input.index(/[A-Z]/, index) == index

145 r4 = (SyntaxNode).new(input, index...(index + 1))

146 @index += 1

325

326 i0, s0 = index, []

327 if input.index(/[A-Z]/, index) == index

328 r1 = (SyntaxNode).new(input, index...(index + 1))

329 @index += 1

524 s0 << r2

525 if r2

526 if input.index(/[A-Z]/, index) == index

527 r3 = (SyntaxNode).new(input, index...(index + 1))

528 @index += 1

20 else if(!(strlen($np)>6)&&(strlen($np)<21))

21 $err = "Password must contain 7-20 characters!!";

22 else if(!preg_match('/[a-z]/',$np))

23 $err = "Password must contain at least one lower case character";

24 else if(!preg_match('/[0-9]/',$np))

28 end

29 op = Lexer::OPERATORS_REVERSE[@operator]

30 op + (op =~ /[a-z]/ ? " " : "") + operand

31 end

32

90 my $nid = $self->_nid;

91 my $new = $self->SUPER::canonical;

92 return $new if $nid !~ /[A-Z]/ || $nid =~ /%/;

93 $new = $new->clone if $new == $self;

94 $new->nid(lc($nid));

21

22 export function getPassLevel(password: string): number[] {

23 const level1 = new RegExp(/[a-z]/);

24 const level2 = new RegExp(/[A-Z]/);

26 len=6;

27

28 var source = this.source.replace(/[a-z]/i, function(alias){

29 alias = alias.toLowerCase();

30

8 * been stored. If separator is a regular expression then

9 * inside of SplitMatch helper the [[Match]] method of R is called giving it the arguments corresponding;

10 * @description: Argument is regexp /[a-z]/, and instance is String("abc");

11 */

12

13 var __string = new String("abc");

14

15 var __re = /[a-z]/;

16

17 var __split = __string.split(__re);

31 function pad(str, exp) {

32 str = "" + str;

33 exp = exp.replace(/[a-z]/ig, '0');

34 return str.length !== exp.length ? exp.slice(str.length) + str : str;

35 }

97 it('string regexp', function(done) {

98 var Test = new Schema({

99 simple: {type: String, match: /[a-z]/}

100 });

101

779 it('string regexp', function(done) {

780 var Test = new Schema({

781 simple: {type: String, match: /[a-z]/}

782 });

783

5

6 constants.each do |name|

7 next unless name =~ /[a-z]/

8 attr = name.to_s.gsub(/([a-z])([A-Z])/, '\1_\2').downcase

9

28 REJECT_KEY = 'reject'

29

30 DEFAULT_REJECT_SET = [/^[a-z]$/, /[0-9]$/, /[A-Z]/]

31

32 # The name of the config field that lists the specific names that are

27

28 function normalizeDataKey(key) {

29 return key.replace(/[A-Z]/g, chr => chr.toLowerCase())

30 }

31

19

20 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,

21 rmultiDash = /[A-Z]/g;

22

23 function getData( data ) {

35 validates_format :url, :as => :url, :allow_nil => false

36

37 validates_format :username, :with => /[a-z]/, :message => 'Username must have at least one letter', :allow_nil => true

38 validates_format :code, :with => /\d{5,6}/, :message => 'Code format is invalid'

39 end

53

54 var schema = new Schema({

55 name: { type: String, validate: /[a-z]/ }

56 });

57

16

17 const { components, variables } = params.reduce((prev, e) => {

18 if (e.search(/^[A-Z]/) === 0 && e.search(/[a-z]/) !== -1) {

19 return { ...prev, components: [...prev.components, e] };

20 }

163 });

164

165 test("/[a-z]/g", {

166 type: "Program",

167 body: [

170 expression: {

171 type: "Literal",

172 value: /[a-z]/g,

173 regex: {

174 pattern: "[a-z]",

37 */

38 link($scope: IAccountUpdateScope) {

39 const reTests = [/[a-z]/, /[A-Z]/, /\d/, /[^a-zA-Z\d]/];

40

41 const checkPassStrength = (pass: string): void => {

41 </I>&gt;<i> accented characters.

42 </I>

43 I got rid of those already. hence y/[a-z]//cd (which is why the capitals

44 don't work...)

45

14

15 jQuery.validator.addMethod("password", function( value, element ) {

16 var result = this.optional(element) || value.length >= 6 && /\d/.test(value) && /[a-z]/i.test(value);

17 if (!result) {

18 element.value = "";

152 push @struct, $tmp[$i] if ( $seq_flag == 0 and $struct_flag == 1 );

153 if ( $seq_flag == 1 and $struct_flag == 1 ) {

154 my $count = ( $tmp[$i] =~ tr/[A-Z]// );

155 if ( $count / length( $tmp[$i] ) > 0.5 ) {

156 push @seq, $tmp[$i];

31 $v = 0;

32 $v |= $NUMBER if $c =~ /[0-9]/;

33 $v |= $UPPER if $c =~ /[A-Z]/;

34 $v |= $LOWER if $c =~ /[a-z]/;

44 $v = 0;

45 $v |= $NUMBER if $c =~ /[0-9]/;

46 $v |= $UPPER if $c =~ /[A-Z]/;

47 $v |= $LOWER if $c =~ /[a-z]/;

19 }

20

21 if (/[A-Z]/.test(name)) {

22 return 'Custom element names must not contain uppercase ASCII characters.';

23 }

64 do { }while('')

65

66 if (/[a-z]/) { }

67 while (/[a-z]/) { }

68 do { }while(/[a-z]/)

69

70 if ([]) { }

127 do { }while(f)

128

129 var g = /[a-z]/

130 if (g) { }

131 while (g) { }

26 $('#length').removeClass('invalid').addClass('valid');

27 }

28 if (pswd.match(/[a-z]/)) {

29 $('#letter').removeClass('invalid').addClass('valid');

30 } else {

33

34 //validate capital letter

35 if (pswd.match(/[A-Z]/)) {

36 $('#capital').removeClass('invalid').addClass('valid');

37 } else {

84 * https://code.google.com/p/esprima/issues/detail?id=604

85 {

86 content: 'var x = /[a-z]/\\ux',

87 explanation: "10.8.5.1 disallows unicode escape flags",

88 expected_differences: {

100 },

101 {

102 content: 'var x = /[a-z]/\\\\ux',

103 explanation: "10.8.5.1 disallows unicode escape flags",

104 expected_differences: {

13 #

14 # def munge(str)

15 # res = str.gsub(/[a-z]/, '\1\1')

16 # run_string_munged str, res

17 # res

292 if (self.local_vars_configuration.client_side_validation and

293 string is not None and not re.search(r'[a-z]', string, flags=re.IGNORECASE)): # noqa: E501

294 raise ValueError(r"Invalid value for `string`, must be a follow pattern or equal to `/[a-z]/i`") # noqa: E501

295

296 self._string = string

106 assert(isMatch('a\\c', 'a/[a-z]'));

107 assert(!isMatch('a\\x\\y', 'a/[a-z]'));

108 assert(isMatch('a\\x\\y', 'a/[a-z]/y'));

109 assert(isMatch('a\\x', 'a/[a-z]'));

110

19 assert.equal(

20 error.message,

21 "[assert.isDate] Expected /[a-z]/ to be a Date"

22 );

23 assert.equal(error.name, "AssertionError");

22 # Convert a constant to a short name.

23 def const2name(const)

24 const.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_" + i.downcase }.intern

25 end

26

51

52 # Convert everything to a lower-case symbol, converting camelcase to underscore word separation.

53 name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_" + i.downcase }.intern

54

55 subclass.name = name

68 # Our subclass is specifically associated with an indirection.

69 raise("Invalid name %s" % longname) unless names.length > 0

70 indirection_name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_" + i.downcase }.intern

71

72 if indirection_name == "" or indirection_name.nil?

102 const beforeText: string = textArea.value.substr(splitText[0].length - 1, 1);

103 const afterText: string = splitText[1].substr(0, 1);

104 if ((beforeText !== '' && afterText !== '' && beforeText.match(/[a-z]/i)) &&

105 beforeText === beforeText.toLocaleUpperCase() && afterText === afterText.toLocaleUpperCase() && cmd === 'UpperCase') {

106 return true;

117 ],

118 },

119 { name: "name$ebnf$1", symbols: [/[a-z]/] },

120 {

121 name: "name$ebnf$1",

122 symbols: ["name$ebnf$1", /[a-z]/],

123 postprocess: (d) => d[0].concat([d[1]]),

124 },

160 postprocess: (d) => d.join(""),

161 },

162 { name: "create_index$ebnf$1", symbols: [/[A-z]/] },

163 {

164 name: "create_index$ebnf$1",

29 const minLength = a => b => length(b) > a

30 const hasPresetColors = x => indexOf(x, colors) !== -1

31 const hasCapitalLetter = a => /[A-Z]/.test(a)

32 const isGreaterThan = curry((len, a) => (a > len))

33 const isLengthGreaterThan = len => compose(isGreaterThan(len), prop('length'))

50

51 //if password has both lower and uppercase characters give 1 point

52 if ( ( password.match(/[a-z]/) ) && ( password.match(/[A-Z]/) ) ) score++;

53

54 //if password has at least one number give 1 point

23 # Convert a constant to a short name.

24 def const2name(const)

25 const.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern

26 end

27

52

53 # Convert everything to a lower-case symbol, converting camelcase to underscore word separation.

54 name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern

55

56 subclass.name = name

69 # This subclass is specifically associated with an indirection.

70 raise("Invalid name #{longname}") unless names.length > 0

71 processed_name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }

72

73 if processed_name.empty?

18

19 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,

20 rmultiDash = /[A-Z]/g;

21

22 function dataAttr( elem, key, data ) {

21 $('#search input').keyup(function() {

22 searchString = this.value;

23 caseSensitiveMatch = searchString.match(/[A-Z]/) != null;

24 regexSearchString = RegExp.escape(searchString);

25 if (caseSensitiveMatch) {

114 {

115 // Via: http://es5.github.com/#x15.5.4.11

116 return this.replace(/[A-Z]/g,'-$&').toLowerCase();

117 },

118

60 */

61 $valuesExpected = array(

62 array('/[a-z]/', true, array('abc123', 'foo', 'a', 'z')),

63 array('/[a-z]/', false, array('123', 'A'))

10 if (moduleName.includes('icon')) {

11 res += '/icons/';

12 res += specifier.imported.name.replace(/[A-Z]/g, match => `-${match.toLowerCase()}`).replace(/^-/, '');

13 } else {

14 res += `/${specifier.imported.name}`;

42 // check for a capital letter and lowercase letter

43 if (

44 /[A-Z]/.test(password) === true &&

45 /[a-z]/.test(password) === true

156 return /\d/.test(str);

157 } else if(character === $.passy.character.LOWERCASE) {

158 return /[a-z]/.test(str);

159 } else if(character === $.passy.character.UPPERCASE) {

160 return /[A-Z]/.test(str);

48 assert(path[0] !== '/', 'remove leading slash')

49 assert(path[path.length - 1] !== '/', 'remove ending slash')

50 assert(!/[A-Z]/.test(path), 'path should not have uppercase letters')

51

52 assert(path !== 'owner/active', 'owner is implied, juse use active')

29

30 str = "a"

31 /[#{str}-z]/.should == /[a-z]/

32 end

33

129

130 // if the current char is in the alphabet

131 if ((/[a-z]/gi).test(strChar)) {

132 // move the needle forward until we run into a non alphabet character

133 while (intNeedle < scriptLen) {

134 strChar = strScript[intNeedle];

135 bolAlpha = (/[a-z]/gi).test(strChar);

136

137 if (!bolAlpha) {

267

268 strChar = strScript[intNeedle];

269 bolAlpha = (/[a-z]/gi).test(strChar);

270 bolEnder = (/[\s\(\)\'\"\.]/gi).test(strChar);

271

34 */

35 $valuesExpected = [

36 ['/[a-z]/', true, ['abc123', 'foo', 'a', 'z']],

37 ['/[a-z]/', false, ['123', 'A']]

133

134 /*

135 is equivalent to Parsimmon.regex(/[a-z]/i)

136 */

137 export var letter: Parser<string>;

8

9

10 jQuery.fn.nakedPassword=function(options){return this.each(function(){var defaults={path:"images/",width:30,height:28,sex:'f'},settings=$.extend(defaults,options);function trigger(){var password_level=getPasswordStrength($(this).val());toggleImg($(this).attr("id"),password_level)}function toggleImg(field,level){for(i=0;i<=5;i++){if(i==level){$("#"+field+"pic"+i).fadeIn()}else{$("#"+field+"pic"+i).fadeOut()}}}function getPasswordStrength(password){return 0+ +(password.length>5)+ +(/[a-z]/.test(password)&&/[A-Z]/.test(password))+ +(/\d/.test(password)&&/\D/.test(password))+ +(/[!,@,#,$,%,^,&,*,?,_,~,-,(,)]/.test(password)&&/\w/.test(password))+ +(password.length>12)}var position=$(this).position(),input_height=$(this).outerHeight(),input_width=$(this).outerWidth(),pic_width=((input_height-6)/settings.height)*settings.width,pic_height=input_height-6,properties={position:'absolute',display:'none',opacity:1,left:(position.left+input_width-(pic_width+3))+"px",top:(position.top+3)+"px",margin:"0px",marginTop:($.browser.safari?3:1)+"px"};for(var i=0;i<=5;i++){$(this).after("<div style='display:none;' id='"+$(this).attr("id")+"pic"+i+"'><img src='"+settings.path+settings.sex+i+".png' width='"+pic_width+"' height='"+pic_height+"px' /></div>");$("#"+$(this).attr("id")+"pic"+i).css(properties)}$(this).bind('keyup',trigger).bind('blur',trigger)})};

11

116 sub class_expander{

117 my $class = shift;

118 $class =~ tr/[A-Z]/[a-z]/;

119 my $gender = shift;

120 if($class =~ m/^arc/){

98

99 def ruby_constant?

100 @name[0].match(/[A-Z]/)

101 end

102

23 # Convert a constant to a short name.

24 def const2name(const)

25 const.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern

26 end

27

52

53 # Convert everything to a lower-case symbol, converting camelcase to underscore word separation.

54 name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern

55

56 subclass.name = name

69 # Our subclass is specifically associated with an indirection.

70 raise("Invalid name #{longname}") unless names.length > 0

71 indirection_name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern

72

73 if indirection_name == "" or indirection_name.nil?

14 my %T = map { $_=>0 } foreach 'a'..'z';

15 while(<>) {

16 $T{$_}++ foreach grep { /[a-z]/ } split m{}, lc $_;

17 }

18

113 my $prev = "NULL";

114 for my $c2 (split //, $string) {

115 if ($c2 =~ /[a-z]/

116 && (!(is_compound($prev)) || ($prev eq "NULL"))) {

117 return -1;

169 }

170 }

171 elsif ($c =~ /[a-z]/) {

172 # join lowercase letters to the last character before it

173 # will not fail as long as input is sanitized.

169 if (lowercase) {

170 Test.equal(

171 /[A-Z]/.test(targetString),

172 false,

173 namespace,

176 } else if (uppercase) {

177 Test.equal(

178 /[a-z]/.test(targetString),

179 false,

180 namespace,

159 else

160 flags = 0

161 flags += 1 if entry[:plaintext].to_s =~ /[a-z]/

162 flags += 1 if entry[:plaintext].to_s =~ /[A-Z]/

173 @hashes_for_mask.each do |entry|

174 entry = entry[:plaintext]

175 entry = entry.gsub(/[A-Z]/, 'U') # Find all upper case chars

176 entry = entry.gsub(/[a-z]/, 'L') # Find all lower case chars

280 else

281 flags = 0

282 flags += 1 if entry[:plaintext].to_s =~ /[a-z]/

283 flags += 1 if entry[:plaintext].to_s =~ /[A-Z]/

336 @complexity_hashes.each do |entry|

337 entry = entry[:plaintext]

338 entry = entry.gsub(/[A-Z]/, 'U') # Find all upper case chars

339 entry = entry.gsub(/[a-z]/, 'L') # Find all lower case chars

49 str = str.dup

50 str.sub!(/^#{namespace}(\:\:)?/, '') if namespace

51 str.gsub!(/[A-Z]/) {|s| "_" + s}

52 str.downcase!

53 str.sub!(/^\_/, "")

48 # obfuscate the eval call to circumvent generic detection

49 eval = 'eval'.split(//).join(Rex::Text.rand_text_alpha(rand(5)).upcase)

50 eval_call = 'window["' + eval + '".replace(/[A-Z]/g,"")]'

51

52 js_loader = Rex::Exploitation::ObfuscateJS.new <<-ENDJS

22 let variations = {

23 digits: /\d/.test(pass),

24 lower: /[a-z]/.test(pass),

25 upper: /[A-Z]/.test(pass),

25 $.each( this.options, function( option ) {

26

27 var value = elem.jqmData( option.replace( /[A-Z]/g, function( c ) {

28 return "-" + c.toLowerCase();

29 })

56 raise RuntimeError.new("Unexpected byte '#{bad_match[0].bytes.first}' in IBAN code '#{prettify}'")

57 end

58 (@code[4..-1] + @code[0..3]).gsub(/[A-Z]/) { |let| (let.ord - 55).to_s }

59 end

60

48 if classname == "self"

49 parse_block(:namespace => namespace, :scope => :class)

50 elsif classname[0, 1] =~ /[A-Z]/

51 register ClassObject.new(namespace, classname) if Proxy === proxy

52 parse_block(:namespace => proxy, :scope => :class)

11

12 it('all classes are lower case', function() {

13 expect(document.documentElement.className).to.not.match(/[A-Z]/);

14 });

15

54 const checkPassword = (password) => {

55 return (

56 (password.length > 0 && password.match(/[A-Z]/)) ||

57 password.match(/\d/) ||

58 password.match(/[!$&]/) ||

168 @ApiModelProperty(value = "")

169 @JsonProperty("string")

170 @Pattern(regexp="/[a-z]/i") public String getString() {

171 return string;

172 }

26

27 exports.camelToSnake = function (camelCase) {

28 return camelCase.replace(/[A-Z]/g, function (match, pos) {

29 return (pos > 0 ? '_' : '') + match.toLowerCase()

30 })

34

35 str = "a"

36 /[#{str}-z]/.should == /[a-z]/

37 end

38

8 },

9 a: {

10 regExp: /[a-z]/,

11 transform: char => char.toUpperCase(),

12 },

34 $fronting = false;

35

36 if (preg_match('/[A-Z]/', $name[0]))

37 {

38 $fronting = true;

32 rmultiDash = /([A-Z])/g;

33 =======

34 rmultiDash = /[A-Z]/g;

35 >>>>>>> 533092147c410637b99bf57166ee237aec486555

36

254

255 # Try creating as a version object and cloning.

256 if ($spec->[0] !~ /[a-z]/i) {

257 isa_ok my $v = version->parse($spec->[0]), 'version', "base version $spec->[0]";

258 isa_ok my $sv = SemVer->new($v), 'SemVer', "SemVer from base version $spec->[0]";

72 if (defaultView) {

73 // Remove camelcase

74 name = name.replace(/[A-Z]/g, function(a) {

75 return '-' + a;

76 });

84

85 /**

86 * Tests 'abc'.split(/[a-z]/).

87 * @throws Exception if the test fails

88 */

91 @NotYetImplemented(Browser.IE)

92 public void test6() throws Exception {

93 test("'abc'.split(/[a-z]/)");

94 }

95

96 /**

97 * Tests 'abc'.split(/[a-z]/).

98 * @throws Exception if the test fails

99 */

10 *

11 * XRegExp('[a-z]', 'ig').xexec('abc');

12 * XRegExp(/[a-z]/ig).xexec('abc');

13 * XRegExp.globalize(/[a-z]/i).xexec('abc');

136 */

137 get computedRegExpLiteral() {

138 return /[a-z]/;

139 }

140

87 while (defined($_ = $in->getline)) {

88 last if /^end/;

89 next if /[a-z]/;

90 next unless int((((ord() - 32) & 077) + 2) / 3) == int(length() / 4);

91 $out->print(unpack('u', $_));

65 initials += parts[i].charAt(0);

66 }

67 if (initials.length > 2 && initials.search(/[A-Z]/) !== -1) {

68 initials = initials.replace(/[a-z]+/g, '');

69 }

70 next if found("$base/$i.*", $filename);

71 # and harder...

72 $i =~ tr/[A-Z]/[a-z]/;

73 next if found("$base/$i.*", $filename);

74 push(@notfound, $func);

22 | Option | Value | Effect |

23 | ---------------|-------------|---------|

24 | `reject` | array of regular expressions or strings | The set of patterns / names that Reek uses to check for bad names. Defaults to `[/^[a-z]$/, /[0-9]$/, /[A-Z]/]`. |

25 | `accept` | array of regular expressions or strings | The set of patterns / names that Reek will accept (and not report) even if they match one of the `reject` expressions. |

26

25 def oracle_downcase(column_name)

26 return nil if column_name.nil?

27 column_name =~ /[a-z]/ ? column_name : column_name.downcase

28 end

29

65

66 # must use MARC::ControlField for tags < 010

67 if @tag.to_i < 10 and not @tag =~ /[A-z]/

68 raise MARC::Exception.new(),

69 "MARC::DataField objects can't have tags < 010"

21 const {cssVariables} = this.$store.getters

22 const content = Object.keys(cssVariables).reduce((res, key) => {

23 res += `--${key.replace(/[A-Z]/g, m => `-${m.toLowerCase()}`)}:${

24 cssVariables[key]

25 };`

92 public function filter($value)

93 {

94 return preg_replace('/[A-Z]/', '', $value);

95 }

96 }

143 return /\d/.test(str);

144 } else if(char === $.passy.character.LOWERCASE) {

145 return /[a-z]/.test(str);

146 } else if(char === $.passy.character.UPPERCASE) {

147 return /[A-Z]/.test(str);

63 }

64 if (parametersToEvaluate.needLowercaseCharacter) {

65 const myRe = /[a-z]/g

66 if (!myRe.test(value)) { errorMessages.push(I18n.t('validation.lowercase_character')) }

67 }

68 if (parametersToEvaluate.needUppercaseCharacter) {

69 const myRe = /[A-Z]/g

70 if (!myRe.test(value)) { errorMessages.push(I18n.t('validation.uppercase_character')) }

71 }