searchcode | source code search engine

8 Pattern EMAIL_ADDRESS_REGEX = Pattern.compile("(?:(?:\\r\\n)?[ \\t])*(?:(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*)|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*:(?:(?:\\r\\n)?[ \\t])*(?:(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*)(?:,\\s*(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*))*)?;\\s*)");

9

10

64 if(StringUtils.isEmpty(username)) {

65 error = "You have to enter a username";

66 } else if(!EMAIL_ADDRESS_REGEX.matcher(email).matches()) {

67 error = "You have to enter a valid email address";

68 } else if(StringUtils.isEmpty(password)) {

ActivityUtility.java (https://gitlab.com/dvesinger/TheFault) Java · 114 lines

57 */

58 public static boolean validate(String emailStr) {

59 Matcher matcher = User.VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);

60 return matcher.find();

61 }

UserResource.java (https://gitlab.com/AERIUS/AERIUS) Java · 114 lines

46 public class UserResource implements UserApiDelegate {

47

48 private static final Pattern EMAIL_PATTERN = Pattern.compile(Constants.VALID_EMAIL_ADDRESS_REGEX, Pattern.CASE_INSENSITIVE);

49

50 private final ResponseService responseService;

text.js (https://github.com/google/end-to-end.git) JavaScript · 137 lines

106 }

107 var email = emailAddress.getAddress();

108 if (!constants.EMAIL_ADDRESS_REGEXP.exec(emailAddress.getAddress())) {

109 return null;

110 }

validation.js (https://github.com/catlee/browserid.git) JavaScript · 122 lines

39

40 bid.verifyEmail = function(address) {

41 // gotten from http://blog.gerv.net/2011/05/html5_email_address_regexp/

42 // changed the requirement that there must be a ldh-str because BrowserID

43 // is only used on internet based networks.

validation.js (https://github.com/ozten/browserid.git) JavaScript · 101 lines

9 if (typeof(address) !== "string")

10 return false;

11 // Original gotten from http://blog.gerv.net/2011/05/html5_email_address_regexp/

12 // changed the requirement that there must be a ldh-str because BrowserID

13 // is only used on internet based networks.

utils.py (http://app-inventor-for-android.googlecode.com/svn/trunk/) Python · 160 lines

22 from google.appengine.ext.db import Key

23

24 EMAIL_ADDRESS_REGEX = ("([0-9a-zA-Z]+[-._+&])*[0-9a-zA-Z]+@"

25 "([-0-9a-zA-Z]+[.])+[a-zA-Z]{2,6}")

26

77 if pid is None or pid == "":

78 raise ValueError('The player identifier is blank.')

79 stripped_email = re.search(EMAIL_ADDRESS_REGEX, pid)

80 if stripped_email is None:

81 raise ValueError('%s is not a valid email address.' % pid)

CredentialHelper.kt (https://github.com/fossasia/susi_android.git) Kotlin · 122 lines

18

19 private val PASSWORD_PATTERN = Pattern.compile("^((?=.*\\d)(?=.*[A-Z])(?=.*[@#\$%])(?=.*\\W).{8,64})$")

20 private val VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE)

21 private val VALID_URL_REGEX = Pattern.compile("^(https?|ftp|file)://[-a-zA-Z0-9+&@#/%?=~_|!:,.;]*[-a-zA-Z0-9+&@#/%=~_|]")

22

31 Timber.d("isEmailValid: %s", mail)

32 val email = mail.trim { it <= ' ' }

33 return !TextUtils.isEmpty(email) && VALID_EMAIL_ADDRESS_REGEX.matcher(email).matches()

34 }

35

EmailValidator.java (https://gitlab.com/alejandrogervasio/customerapplication) Java · 15 lines

6 public class EmailValidator {

7

8 private static final Pattern VALID_EMAIL_ADDRESS_REGEX =

9 Pattern.compile("(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])", Pattern.CASE_INSENSITIVE);

10

11 public static boolean validate(String email) {

12 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

13 return matcher.find();

14 }

Constants.java (https://gitlab.com/AERIUS/AERIUS) Java · 50 lines

42 * Regex used to a correct emailaddress.

43 */

44 public static final String VALID_EMAIL_ADDRESS_REGEX =

45 "^[\\w\\u00C0-\\u02AF-\\+]+(\\.[\\w\\u00C0-\\u02AF-]+)*@[\\w\\u00C0-\\u02AF-]+(\\.[\\w\\u00C0-\\u02AF]+)*(\\.[A-Za-z]{2,})$";

46

LoginUtils.java (https://gitlab.com/unique_steve/Ivo_app) Java · 59 lines

12 public class LoginUtils {

13

14 public static final Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$",

15 Pattern.CASE_INSENSITIVE);

16

35

36 public static boolean isEmailValid(String email) {

37 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

38 return matcher.find();

39 }

EmailValidator.java (https://gitlab.com/alejandrogervasio/userappplication) Java · 22 lines

8 public class EmailValidator implements ConstraintValidator<ValidEmail, String> {

9

10 private static final Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

11

12 @Override

17 @Override

18 public boolean isValid(String email, ConstraintValidatorContext constraintValidatorContext) {

19 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

20 return matcher.find();

21 }

email.js (https://github.com/audreyt/socialtext-open.git) JavaScript · 29 lines

13 + "([a-zA-Z0-9:]{2,4})+";

14

15 var EMAIL_ADDRESS_REGEX = new RegExp(

16 "^" + EMAIL_ADDRESS + "$", "i"

17 );

22

23 this.check_address = function(email_address) {

24 return EMAIL_ADDRESS_REGEX.test(email_address) ||

25 EMAIL_WITH_NAME_REGEX.test(email_address);

26 };

admin_form.rb (https://github.com/PopulateTools/gobierto.git) Ruby · 153 lines

22

23 validates :name, :email, :site, presence: true

24 validates :email, format: { with: Admin::EMAIL_ADDRESS_REGEXP }

25 validates :password, presence: { if: :new_record? }, confirmation: true

26

RegisterUser.cs (https://bitbucket.org/RobertoDiBi/spacewars-project.git) C# · 184 lines

34 public void Registration()

35 {

36 Regex VALID_EMAIL_ADDRESS_REGEX =new Regex("^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,6}$");

37 Regex passRegEx = new Regex("(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z]).{8,}");

38 //Connect to database

44 string password = passwordInput.text;

45 string confirmPass = confirmPassInput.text;

46 Match emailMatch = VALID_EMAIL_ADDRESS_REGEX.Match(email);

47 Match passMatch = passRegEx.Match(password);

48

DefaultEmailService.java (https://github.com/ctripcorp/x-pipe.git) Java · 67 lines

32 }

33

34 private static final Pattern VALID_EMAIL_ADDRESS_REGEX =

35 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9._%+-]+$", Pattern.CASE_INSENSITIVE);

36

37 @Override

38 public CheckEmailResponse checkEmailAddress(String address) {

39 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(address);

40 boolean result = matcher.find();

41 if(result) {

PatternUtil.java (https://github.com/ZHENFENG13/My-Blog.git) Java · 63 lines

17 * 匹配邮箱正则

18 */

19 private static final Pattern VALID_EMAIL_ADDRESS_REGEX =

20 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

21

41 */

42 public static boolean isEmail(String emailStr) {

43 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);

44 return matcher.find();

45 }

ValidateUtils.java (https://github.com/fossasia/open-event-orga-app.git) Java · 63 lines

13 public final class ValidateUtils {

14

15 private static final Pattern VALID_EMAIL_ADDRESS_REGEX =

16 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

17

23

24 public static boolean validateEmail(String emailStr) {

25 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);

26 return matcher.find();

27 }

EmailAddress.ts (https://github.com/Urigo/graphql-scalars.git) TypeScript · 36 lines

2

3 const validate = (value: any) => {

4 const EMAIL_ADDRESS_REGEX = /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;

5

6 if (typeof value !== 'string') {

8 }

9

10 if (!EMAIL_ADDRESS_REGEX.test(value)) {

11 throw new TypeError(`Value is not a valid email address: ${value}`);

12 }

admin_invitation_builder.rb (https://github.com/PopulateTools/gobierto.git) Ruby · 47 lines

36

37 def get_username_from_email(email_address)

38 if email_address =~ Admin::EMAIL_ADDRESS_REGEXP

39 $1

40 end

subscription_form.rb (https://github.com/PopulateTools/gobierto.git) Ruby · 72 lines

14

15 validates :user, :site, :subscribable, presence: true

16 validates :user_email, format: { with: User::EMAIL_ADDRESS_REGEXP }, allow_nil: true

17

18 def save

Utils.java (https://github.com/journaldev/journaldev.git) Java · 40 lines

16 email = email.trim();

17

18 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

19 return matcher.find();

20

27 }

28

29 private static final Pattern VALID_EMAIL_ADDRESS_REGEX =

30 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

31

user.rb (https://github.com/PopulateTools/gobierto.git) Ruby · 74 lines

6 include User::Subscriber

7

8 EMAIL_ADDRESS_REGEXP = /\A(.+)@(.+\..+)\z/

9

10 belongs_to :site

registration_form.rb (https://github.com/PopulateTools/gobierto.git) Ruby · 58 lines

12

13 validates :site, presence: true

14 validates :email, format: { with: User::EMAIL_ADDRESS_REGEXP }

15

16 def save

email.js (https://github.com/matrix-org/matrix-react-sdk.git) JavaScript · 21 lines

15 */

16

17 const EMAIL_ADDRESS_REGEX = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i;

18

19 export function looksValid(email) {

20 return EMAIL_ADDRESS_REGEX.test(email);

21 }

22

admin_invitation_form.rb (https://github.com/PopulateTools/gobierto.git) Ruby · 51 lines

35 emails

36 .split(EMAIL_LIST_DELIMITER)

37 .select { |email| Admin::EMAIL_ADDRESS_REGEXP =~ email }

38 .map(&:strip)

39 end

admin_settings_form.rb (https://github.com/PopulateTools/gobierto.git) Ruby · 58 lines

15

16 validates :name, :email, presence: true

17 validates :email, format: { with: Admin::EMAIL_ADDRESS_REGEXP }

18 validates :password, confirmation: true

19

RegisterActivity.java (https://bitbucket.org/BohyunBarry/boundservice.git) Java · 153 lines

30 FloatingActionButton fab;

31 CardView cvAdd;

32 private final Pattern VALID_EMAIL_ADDRESS_REGEX =

33 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

34 private EditText editTextUsername, editTextPassword, editTextRepeatPassword;

148

149 private boolean validate(String emailStr, String password, String repeatPassword) {

150 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(emailStr);

151 return password.length() > 0 && repeatPassword.equals(password) && matcher.find();

152 }

user_form.rb (https://github.com/PopulateTools/gobierto.git) Ruby · 74 lines

14

15 validates :user, :name, presence: true

16 validates :email, format: { with: User::EMAIL_ADDRESS_REGEXP }

17

18 def save

CustomUtil.java (https://gitlab.com/CreaTIKZ-groupe4/CreaTIKZ) Java · 131 lines

18 public class CustomUtil {

19

20 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

21 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

22 /**

66 */

67 public static Boolean isValidEmail(String email) {

68 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(email);

69 return matcher.find();

70

ValidationUtil.java (https://github.com/eyebluecn/blog.git) Java · 89 lines

50

51

52 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

53 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

54

55 public static boolean isEmail(String emailStr) {

56 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);

57 return matcher.find();

58 }

validate.js (https://gitlab.com/wamburu/fxa-content-server) JavaScript · 110 lines

30

31 // Original regexp from:

32 // http://blog.gerv.net/2011/05/html5_email_address_regexp/

33 // Modified to remove the length checks, which are done later.

34 // IETF spec: http://tools.ietf.org/html/rfc5321#section-4.5.3.1.1

EmailValidator.java (https://github.com/Godin/sonar.git) Java · 46 lines

29 class EmailValidator {

30

31 private static final Pattern VALID_EMAIL_ADDRESS_REGEX = compile("(?:(?:\\r\\n)?[ \\t])*(?:(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*)|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*:(?:(?:\\r\\n)?[ \\t])*(?:(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*)(?:,\\s*(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*))*)?;\\s*)");

32

33 private EmailValidator() {

40

41 private static boolean isValidEmail(String email) {

42 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

43 return matcher.find();

44 }

Validator.java (https://gitlab.com/arifhasnat/ajkerdeal) Java · 24 lines

8 */

9 public class Validator {

10 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

11 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

12 public static final Pattern VALID_MOBILE_NUMBER_REGEX =

14

15 public static boolean isValidEmail(String email) {

16 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

17 return matcher.find();

18 }

content.rb (https://github.com/intrigueio/intrigue-ident.git) Ruby · 63 lines

50 name:"Email Addresses Detected",

51 dynamic_result: lambda { |d|

52 email_address_regex = /\A([\w+\-].?)+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i

53 captures = _all_body_captures(d,email_address_regex) || []

UserService.java (https://bitbucket.org/denisabarar/spring_demo_local.git) Java · 120 lines

19 public class UserService {

20 private static final String SPLIT_CH = " ";

21 public static final Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$",

22 Pattern.CASE_INSENSITIVE);

23

104

105 public static boolean validateEmail(String email) {

106 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

107 return matcher.find();

108 }

Contact.java (https://bitbucket.org/sebinsteanu/dsir1862.git) Java · 142 lines

13

14

15 public static final Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

16 public static final Pattern VALID_PHONE_REGEX = Pattern.compile("^[\\+0][\\d]{5,10}$", Pattern.CASE_INSENSITIVE);

17 public static final Pattern VALID_NAME_REGEX = Pattern.compile("^([\\s]|[^0-9]|-){3,50}$", Pattern.CASE_INSENSITIVE);

90

91 public static boolean validEmail(String emailStr) {

92 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(emailStr);

93 return matcher.find();

94 }

Utilerias.java (https://github.com/castelarhub/CirculoCredito.git) Java · 101 lines

15 Pattern.compile("^\\d{2}/\\d{2}/\\d{4}$", Pattern.CASE_INSENSITIVE);

16

17 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

18 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

19

66

67 public static boolean isValidEmail(String email){

68 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(email);

69 return matcher.find();

70 }

how-to-search-effectively-in-searchcode-server.html (https://github.com/boyter/searchcode-server.git) HTML · 65 lines

48 If a search does not return the results you are expecting or no results at all consider rewriting the query.

49 For example searching for Arrays.asList("a1", "a2", "b1", "c2", "c1") could be turned into a

50 looser query by searching for Arrays.asList or Arrays asList. Another example would be EMAIL_ADDRESS_REGEX for

51 email address regex.

52

Utilerias.java (https://github.com/castelarhub/CirculoCredito.git) Java · 67 lines

12 public class Utilerias {

13

14 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

15 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

16

37

38 public static boolean isValidEmail(String email){

39 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(email);

40 return matcher.find();

41 }

Utility.java (https://bitbucket.org/syncmed/doc360-doctor-android.git) Java · 68 lines

15

16 public class Utility {

17 private static final Pattern VALID_EMAIL_ADDRESS_REGEX =

18 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

19 private static final Pattern LETTERS_ONLY =

24 return false;

25 } else {

26 Matcher emailMatcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

27 return emailMatcher.find();

28 }

filter-wrapper.php (https://github.com/wadd0032/mtm1531-homework-6.git) PHP · 153 lines

112 case FILTER_VALIDATE_EMAIL :

113 // From HTML5 spec: http://html5.org/tools/web-apps-tracker?from=6883&to=6884o

114 // And: http://blog.gerv.net/2011/05/html5_email_address_regexp/

115 return (bool)preg_match(">^[a-zA-Z0-9.!#$%&'*+/=?\^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$>", $variable);

116 break;

validates_email.rb (https://github.com/jamesarosen/ruby-tidbits.git) Ruby · 30 lines

9 def validates_email(*attr_names)

10 options = attr_names.extract_options!.symbolize_keys!

11 configuration = { :on => :save, :allow_blank => true, :message => ::ActiveRecord::Errors.default_error_messages[:invalid], :with => Tidbits::ActiveRecord::ValidatesEmail::SIMPLE_EMAIL_ADDRESS_REGEX }

12 configuration.update(options)

13 attr_names = [:email] if attr_names.nil? or attr_names.empty?

20 end

21

22 unless const_defined?(:SIMPLE_EMAIL_ADDRESS_REGEX)

23 SIMPLE_EMAIL_ADDRESS_REGEX = /\A[^@\s]+@(?:[[:alnum:]-]+\.)+[[:alpha:]]{2,}\Z/i

ScanInputValidation.java (https://bitbucket.org/swathi-cookie/wm-ticket-service.git) Java · 66 lines

24 }

25

26 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

27 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

28

29 public static boolean validate(String emailStr) {

30 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);

31 return matcher.find();

32 }

taskpane_render.js (https://github.com/OfficeDev/PnP-OfficeAddins.git) JavaScript · 193 lines

85 function is_not_valid_email_address(email_address)

86 {

87 let email_address_regex = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;

88 return is_not_valid_text(email_address) || !(email_address_regex.test(email_address));

extra_validations.rb (https://github.com/pixeltrix/extra_validations.git) Ruby · 26 lines

1 module ExtraValidations

2

3 EMAIL_ADDRESS_REGEX = /\A(([A-Za-z0-9]+_+)|([A-Za-z0-9]+\-+)|([A-Za-z0-9]+\.+)|([A-Za-z0-9]+\++))*[A-Za-z0-9]+@((\w+\-+)|(\w+\.))*\w{1,63}\.[a-zA-Z]{2,6}\Z/i

4 WEB_ADDRESS_REGEX = /\Ahttp(s)?:\/\/([-a-z0-9]+)(\.[-a-z0-9]+)*?\.([a-z]{2,5}){1}\/?([-a-zA-Z0-9?$%&+=\/]{0,255})\Z/

5 UK_POSTCODE_REGEX = /\A[A-PR-UWYZ][A-HK-Y0-9][A-HJKSTUW0-9]?[ABEHMNPRVWXY0-9]? {1,2}[0-9][ABD-HJLN-UW-Z]{2}\Z/

7

8 def validates_as_email_address(*args)

9 args << {:with => EMAIL_ADDRESS_REGEX}.update(args.extract_options!); validates_format_of(*args)

10 end

11

ValidatorContact.java (https://bitbucket.org/laura1825/blir1825.git) Java · 47 lines

8

9 public class ValidatorContact {

10 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

11 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

12

42

43 public static boolean validEmail(String email) {

44 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(email);

45 return matcher.find();

46 }

Validator.java (https://bitbucket.org/ikonstantine/somehiringproject.git) Java · 45 lines

5 public class Validator {

6

7 private static final Pattern VALID_EMAIL_ADDRESS_REGEX =

8 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

9

13 public static void validateEmail(String email) throws ValidatorException {

14 if (email == null) throw new ValidatorException(ValidatorErrorCode.NOT_VALIDATE_EMAIL);

15 if (email.equals("") || !VALID_EMAIL_ADDRESS_REGEX.matcher(email).find())

16 throw new ValidatorException(ValidatorErrorCode.NOT_VALIDATE_EMAIL);

17 }

Validations.java (https://bitbucket.org/fosdev/vouper.git) Java · 98 lines

67

68

69 private static final Pattern VALID_EMAIL_ADDRESS_REGEX =

70 Pattern.compile("^([_a-zA-Z0-9-]+(\\.[_a-zA-Z0-9-]+)*@[a-zA-Z0-9-]+(\\.[a-zA-Z0-9-]+)*(\\.[a-zA-Z]{1,6}))?$", Pattern.CASE_INSENSITIVE);

71

74 return false;

75 }

76 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(emailStr);

77 return matcher.find();

78 }

rfc822.rb (https://github.com/wireframe/email-validator.git) Ruby · 28 lines

10 # http://creativecommons.org/licenses/by-sa/2.5/

11 module RFC822

12 EMAIL_ADDRESS_REGEX = begin

13 qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'

14 dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]'

DefaultUserService.java (https://bitbucket.org/roycat/ris-yips-spring-ws.git) Java · 145 lines

25 public class DefaultUserService implements UserService {

26

27 private static final Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$",

28 Pattern.CASE_INSENSITIVE);

29 private static final Pattern VALID_PASSWORD_REGEX = Pattern.compile("^[a-zA-Z0-9]+$");

125 return false;

126 }

127 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

128 return matcher.find();

129 }

SignUpService.java (https://bitbucket.org/danhuycao/cs472_mum.git) Java · 40 lines

10 public class SignUpService {

11

12 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

13 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

14

26

27

28 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

29 if (email.isEmpty()|| !matcher.find()) {

30 result.add("E-mail required");

HelperTests.php (https://github.com/tine20/Tine-2.0-Open-Source-Groupware-and-CRM.git) PHP · 95 lines

88 $input = 'H.-H.einer@nopel.opel';

89 $punyCodedAddress = Tinebase_Helper::convertDomainToPunycode($input);

90 if (! preg_match(Tinebase_Mail::EMAIL_ADDRESS_REGEXP, $punyCodedAddress)) {

91 self::fail('address is not invalid: ' . $punyCodedAddress);

92 }

DataValidation.java (https://bitbucket.org/dccor/musicmasterweb.git) Java · 33 lines

16

17 /** the Pattern with Email Regular Expression */

18 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

19 Pattern.compile("^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?"

20 , Pattern.CASE_INSENSITIVE);

27 */

28 public static boolean validateEmail(String emailStr) {

29 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);

30 return matcher.find();

31 }

EmailValidator.java (https://github.com/dan31877/Programming-Projects.git) Java · 32 lines

12 */

13 public class EmailValidator implements ConstraintValidator<EmailConstraint, String> {

14 public static final Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$",

15 Pattern.CASE_INSENSITIVE);

16 public static boolean validate(String emailStr) {

17 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);

18 return matcher.find();

19 }

validators.js (https://github.com/deadlyicon/validation.js.git) JavaScript · 64 lines

29 };

30

31 var EMAIL_ADDRESS_REGEX = /^([A-Za-z0-9]{1,}([-_\.&'][A-Za-z0-9]{1,}){0,}){1,}@(([A-Za-z0-9]{1,}[-]{0,1})\.){1,}[A-Za-z]{2,6}$/;

32 function isAnEmailAddress(value, reportErrors){

33 if (!EMAIL_ADDRESS_REGEX.test(value))

email.rb (https://github.com/bountyhill/bountyhill.git) Ruby · 50 lines

18

19 # constant to use with email validation

20 EMAIL_ADDRESS_REGEX = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,6}$/i

21

22 validates :email, :presence => true, :format => { :with => EMAIL_ADDRESS_REGEX }, :uniqueness => { :case_sensitive => false }

q.patterns.js (https://bitbucket.org/marcuspope/q.node) JavaScript · 56 lines

23

24 var email_formats = {

25 //http://blog.gerv.net/2011/05/html5_email_address_regexp/

26 html5_spec : (/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/)

27 };

UserValidation.java (https://bitbucket.org/zenwherk/zenwherk-api.git) Java · 92 lines

10 public class UserValidation {

11

12 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

13 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

14

37 message += "El correo no debe estar vacío. ";

38 } else {

39 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(user.getEmail());

40 if(!matcher.find()) {

41 result.setErrorCode(400);

UserService.java (https://bitbucket.org/danhuycao/cs472_mum.git) Java · 50 lines

12 public class UserService {

13 private UserDao userdao = new UserDao() ;

14 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

15 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

16 public long insertUser(User u )

36

37

38 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(u.getEmail());

39 if (u.getEmail().isEmpty()|| !matcher.find()) {

40 result.add("email should have Email format");

CRUDManagement.java (https://github.com/christian-lang-2012/NubayAPI.git) Java · 174 lines

17

18 HashMap<Integer, Profile> tempServer = new HashMap<Integer, Profile>();

19 public static final Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

20

21 int currentID = 1;

167

168 private boolean validateEmailAddress(String s){

169 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(s);

170 return matcher.find();

171 }

UserAccount.java (https://github.com/KyleGrice/MusicPlayerProject.git) Java · 71 lines

16 private String password;

17 private String email;

18 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

19 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

20

49

50 // Validate Email

51 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(email);

52 if (matcher.find()) {

53 validEntries++;

email.js (https://github.com/edwindotcom/browserid-bigtent.git) JavaScript · 17 lines

5 module.exports = function (address) {

6 // Copied from mozilla/browserid which got it from...

7 // http://blog.gerv.net/2011/05/html5_email_address_regexp/

8 var parts = address.split("@");

9

SendEmailDelegate.java (https://github.com/camunda-consulting/code.git) Java · 51 lines

41 }

42

43 public static final Pattern VALID_EMAIL_ADDRESS_REGEX =

44 Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

45

46 public static boolean validate(String emailStr) {

47 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(emailStr);

48 return matcher.find();

49 }

EmailUtils.cpp (https://review.tizen.org/git/) C++ · 97 lines

29

30 namespace {

31 const char* EMAIL_ADDRESS_REGEX =

32 "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,6}";

33

34 const std::string EMAIL_ADDRESS_REGEX_GROUP =

35 StringBuilder()

36 .append("(")

37 .append(EMAIL_ADDRESS_REGEX)

38 .append(")")

39 .toString();

email_validator.rb (https://github.com/vjt/email_validator.git) Ruby · 105 lines

10 domain_part = '@(?:(?:(?:\w+\-+[^_])|(?:\w+\.[a-z0-9-]*))*(?:[a-z0-9-]{1,63})\.[a-z]{2,6}(?:\.[a-z]{2,6})?)'

11

12 email_address_regexp = '(?:' + local_part_unquoted + '+|' + local_part_quoted + '+)' + domain_part

13

14 Pattern = Regexp.new('\A' + email_address_regexp + '\Z', Regexp::EXTENDED | Regexp::IGNORECASE, 'n').freeze

15 Scanner = Regexp.new( email_address_regexp, Regexp::EXTENDED | Regexp::IGNORECASE, 'n').freeze

16 Separator = /[;,\s]\s*/.freeze # for multiple e-mail addresses

17

validation.js (https://github.com/tmd10470/browserid.git) JavaScript · 101 lines

8

9 bid.verifyEmail = function(address) {

10 // Original gotten from http://blog.gerv.net/2011/05/html5_email_address_regexp/

11 // changed the requirement that there must be a ldh-str because BrowserID

12 // is only used on internet based networks.

twitter.rb (https://github.com/bountyhill/bountyhill.git) Ruby · 126 lines

83 # check if email is given and if so if email is valid

84 if self.email

85 self.errors.add(:email, :invalid) unless self.email =~ Identity::Email::EMAIL_ADDRESS_REGEX

86 else

87 self.errors.add(:email, :blank)

EmailValidator.java (https://bitbucket.org/gabi88ibag/taxesmemo.git) Java · 67 lines

24 private UserService userService;

25

26 private static final Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern

27 .compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

28

29 public static boolean isValidEmail(String email) {

30 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

31 if (matcher.find()) {

32 return true;

Email.js (https://github.com/audreyt/socialtext-open.git) JavaScript · 26 lines

12 + "([a-zA-Z0-9:]{2,4})+";

13

14 var EMAIL_ADDRESS_REGEX = new RegExp(

15 "^" + EMAIL_ADDRESS + "$", "i"

16 );

21

22 return function(email_address) {

23 return EMAIL_ADDRESS_REGEX.test(email_address) ||

24 EMAIL_WITH_NAME_REGEX.test(email_address);

25 };

Address.java (https://github.com/amexboy/SAS.git) Java · 214 lines

88 * RFC822 compliant adapted for java

89 */

90 Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("(?:(?:\\r\\n)?[ \\t])*(?:(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*)|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*:(?:(?:\\r\\n)?[ \\t])*(?:(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*)(?:,\\s*(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*))*)?;\\s*)");

91 Pattern VALID_PHONE_NUMBER_REGEX = Pattern.compile("^(0\\d{9})|([+]\\d{12})$");

92

124

125 if (email != null && !email.isEmpty()) {

126 Matcher emailMatcher = VALID_EMAIL_ADDRESS_REGEX.matcher(this.email);

127

128 if (!emailMatcher.matches()) {

MMSOptionalData.java (https://github.com/snuffix/Android_LogdroidProject.git) Java · 106 lines

11

12 public static MMSAddressType fromString(String address) {

13 if (address.matches(EMAIL_ADDRESS_REGEXP)) {

14 return MMSAddressType.EMAIL_ADDRESS;

15 }

20 }

21

22 private static final String EMAIL_ADDRESS_REGEXP = "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@([A-Za-z0-9-])+(\\.[a-z,A-Z]{2,})$";

23

24 private String subject = "";

MMS.java (https://github.com/snuffix/Android_LogdroidProject.git) Java · 249 lines

101

102 public static MMSAddressType fromString(String address) {

103 if (address.matches(EMAIL_ADDRESS_REGEXP)) {

104 return MMSAddressType.EMAIL_ADDRESS;

105 }

109 }

110

111 private static final String EMAIL_ADDRESS_REGEXP =

112 "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@([A-Za-z0-9-])+(\\.[a-z,A-Z]{2,})$";

113 }

has_email.rb (https://github.com/alainravet/fail_fast.git) Ruby · 36 lines

21

22 module EmailValidator #:nodoc:

23 VALID_EMAIL_ADDRESS_REGEXP = /^[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$/

24

25 def self.valid_email_address?(email)

26 email.strip!

27 !!(email =~ VALID_EMAIL_ADDRESS_REGEXP)

28 end

29

person_message.rb (https://github.com/PopulateTools/gobierto.git) Ruby · 21 lines

8

9 validates :name, :email, :body, presence: true

10 validates :email, format: { with: User::EMAIL_ADDRESS_REGEXP }

11

12 def deliver!

17.validate_user_method.html (https://github.com/sparktutorials/sparktutorials.github.io.git) HTML · 15 lines

4 if(StringUtils.isEmpty(username)) {

5 error = "You have to enter a username";

6 } else if(!EMAIL_ADDRESS_REGEX.matcher(email).matches()) {

7 error = "You have to enter a valid email address";

8 } else if(StringUtils.isEmpty(password)) {

EmailValidator.java (https://github.com/Flutterwave/rave-android.git) Java · 23 lines

14 public boolean isEmailValid(String email) {

15 if (email != null) {

16 Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

17 Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);

email_page.js (https://github.com/dinda/socialtext.git) JavaScript · 155 lines

31 // http://fightingforalostcause.net/misc/2006/compare-email-regex.php

32 //

33 var EMAIL_ADDRESS_REGEX = new RegExp(

34 "^"

35 + "([a-zA-Z0-9_'+*$%\\^&!\\.\\-])+"

42

43 function email_page_check_address(email_address) {

44 return EMAIL_ADDRESS_REGEX.test(email_address);

45 }

46

EmailValidatorImpl.kt (https://bitbucket.org/wliberda/fotommvvmcleanarchitecture.git) Kotlin · 16 lines

10

11 override fun validate(emailStr: String): Boolean =

12 VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr).run {

13 this.find()

14 }

ValidationUtils.java (https://bitbucket.org/Zeee/testapp.git) Java · 26 lines

6 public class ValidationUtils {

7

8 private static final Pattern EMAIL_ADDRESS_REGEX

9 = Pattern.compile(

10 "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +

18

19 public static boolean isEmailValid(String email){

20 return EMAIL_ADDRESS_REGEX.matcher(email).matches();

21 }

22

mail_setting.rb (https://github.com/superricky/baobao.git) Ruby · 7 lines

3 validates :shop, presence: true

4 validates :address, :domain, :user_name, :password, :reply_to, presence:true, on: :update, unless: :use_system_setting

5 validates :reply_to, format: {with: VALID_EMAIL_ADDRESS_REGEX }, :allow_blank => true

6 end

7

EmailValidator.kt (https://bitbucket.org/wliberda/fotommvvmcleanarchitecture.git) Kotlin · 12 lines

7 */

8 interface EmailValidator {

9 val VALID_EMAIL_ADDRESS_REGEX: Pattern

10 get() = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE)!!

11 fun validate(emailStr: String): Boolean

constant.rb (https://github.com/superricky/baobao.git) Ruby · 7 lines

2 SHOP_ID_REGEX = /\A\d+\Z/

3 VALID_SHOP_SLUG_REGEX = /[a-zA-Z][a-zA-Z0-9]{2,}/i

4 VALID_EMAIL_ADDRESS_REGEX = /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i

5 VALID_PHONE_TEL_REGEX = /((\d{11})|^((\d{7,8})|(\d{4}|\d{3})-(\d{7,8})|(\d{4}|\d{3})-(\d{7,8})-(\d{4}|\d{3}|\d{2}|\d{1})|(\d{7,8})-(\d{4}|\d{3}|\d{2}|\d{1}))$)/i

6 VALID_PHONE_REGEX = /\A((0?(13[0-9]|15[012356789]|18[012356789]|14[57])[0-9]{8})|((0[1-9][0-9]{1,2}-)?\d{7,8})|(0\d{9}))\Z/i

email-validator.rb (https://github.com/wireframe/email-validator.git) Ruby · 23 lines

14

15 validates_each([attribute], options) do |record, attr, value|

16 valid_email = record.send(attr).to_s.match EMAIL_ADDRESS_REGEX

17 record.errors.add attr, options[:message] unless valid_email

18 end