PageRenderTime 256ms queryTime 51ms sortTime 1ms getByIdsTime 150ms findMatchingLines 13ms

71+ results for 'EMAIL_ADDRESS_REGEX' (256 ms)

Not the results you expected?
User.java https://gitlab.com/dvesinger/TheFault | Java | 265 lines
                    
18     */
                    
19    public static final Pattern VALID_EMAIL_ADDRESS_REGEX =
                    
20            Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
                    
                
Message.php https://github.com/pschuele/Tine-2.0-Open-Source-Groupware-and-CRM.git | PHP | 614 lines
                    
66     */
                    
67    const EMAIL_ADDRESS_REGEXP = '/([a-z0-9_\+-\.]+@[a-z0-9-\.]+\.[a-z]{2,5})/i'; 
                    
68    
                    
                
Message.php https://github.com/nysenate/Bluebird-CRM.git | PHP | 622 lines
                    
24  */
                    
25  private static $_email_address_regex =
                    
26    /* mailbox */
                    
253      $matches = array();
                    
254      if (preg_match_all(static::$_email_address_regex, $content, $matches)) {
                    
255        foreach ($matches[0] as $k => $v) {
                    
                
Mail.php https://gitlab.com/rsilveira1987/Expresso | PHP | 320 lines
                    
22    */
                    
23    const EMAIL_ADDRESS_REGEXP = '/([a-z0-9_\+-\.]+@[a-z0-9-\.]{1,})/i';
                    
24    
                    
                
Constants.java https://gitlab.com/ahmadrosid/TrackinsAndroid | Java | 98 lines
                    
10
                    
11    public static final Pattern VALID_EMAIL_ADDRESS_REGEX =
                    
12            Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
                    
14    public static boolean isMatchEmail(String emailStr) {
                    
15        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);
                    
16        return matcher.find();
                    
                
LocalDateTimeUtils.java https://gitlab.com/truongnv9xbn/spring-boot-project | Java | 150 lines
                    
30
                    
31	public static final Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$",
                    
32			Pattern.CASE_INSENSITIVE);
                    
35		emailStr = emailStr.trim();
                    
36		Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);
                    
37		return matcher.find();
                    
                
ActivityUtility.java https://gitlab.com/dvesinger/TheFault | Java | 114 lines
                    
58    public static boolean validate(String emailStr) {
                    
59        Matcher matcher = User.VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);
                    
60        return matcher.find();
                    
                
DlgRegister.java https://bitbucket.org/RobertoDiBi/java3-project.git | Java | 321 lines
                    
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);
                    
                
UserResource.java https://gitlab.com/AERIUS/AERIUS | Java | 114 lines
                    
47
                    
48  private static final Pattern EMAIL_PATTERN = Pattern.compile(Constants.VALID_EMAIL_ADDRESS_REGEX, Pattern.CASE_INSENSITIVE);
                    
49
                    
                
validation.js https://github.com/ozten/browserid.git | JavaScript | 101 lines
                    
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
                    
                
validation.js https://github.com/catlee/browserid.git | JavaScript | 122 lines
                    
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 
                    
                
LoginActivity.java https://bitbucket.org/WasimShahul/ksapp.git | Java | 368 lines
                    
41    FloatingActionButton fab;
                    
42    private final Pattern VALID_EMAIL_ADDRESS_REGEX =
                    
43            Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
                    
147    private boolean validate(String emailStr, String password) {
                    
148        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);
                    
149        return (password.length() > 0 || password.equals(";")) && matcher.find();
                    
                
Constants.java https://gitlab.com/AERIUS/AERIUS | Java | 50 lines
                    
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,})$";
                    
                
EmailValidator.java https://gitlab.com/alejandrogervasio/customerapplication | Java | 15 lines
                    
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);
                    
11    public static boolean validate(String email) {
                    
12        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);
                    
13        return matcher.find();
                    
                
utils.py http://app-inventor-for-android.googlecode.com/svn/trunk/ | Python | 160 lines
                    
23
                    
24EMAIL_ADDRESS_REGEX = ("([0-9a-zA-Z]+[-._+&])*[0-9a-zA-Z]+@"
                    
25                       "([-0-9a-zA-Z]+[.])+[a-zA-Z]{2,6}")
                    
78    raise ValueError('The player identifier is blank.')
                    
79  stripped_email = re.search(EMAIL_ADDRESS_REGEX, pid)
                    
80  if stripped_email is None:
                    
                
LoginUtils.java https://gitlab.com/unique_steve/Ivo_app | Java | 59 lines
                    
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);
                    
36	public static boolean isEmailValid(String email) {
                    
37		Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);
                    
38		return matcher.find();
                    
                
DlgLogin.java https://bitbucket.org/RobertoDiBi/java3-project.git | Java | 258 lines
                    
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);
                    
189	{
                    
190		Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);
                    
191		return matcher.find();
                    
                
EmailValidator.java https://gitlab.com/alejandrogervasio/userappplication | Java | 22 lines
                    
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
                    
18    public boolean isValid(String email, ConstraintValidatorContext constraintValidatorContext) {
                    
19        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);
                    
20        return matcher.find();
                    
                
email.js https://github.com/audreyt/socialtext-open.git | JavaScript | 29 lines
                    
14
                    
15var EMAIL_ADDRESS_REGEX = new RegExp(
                    
16    "^" + EMAIL_ADDRESS + "$", "i"
                    
23this.check_address = function(email_address) {
                    
24    return EMAIL_ADDRESS_REGEX.test(email_address) ||
                    
25           EMAIL_WITH_NAME_REGEX.test(email_address);
                    
                
documentation.ftl https://github.com/boyter/searchcode-server.git | Freemarker Template | 1239 lines
                    
112                looser query by searching for <strong>Arrays.asList</strong> or <strong>Arrays asList</strong>. Another
                    
113                example would be <strong>EMAIL_ADDRESS_REGEX</strong> for
                    
114                <strong>email address regex</strong>.
                    
                
RegisterUser.cs https://bitbucket.org/RobertoDiBi/spacewars-project.git | C# | 184 lines
                    
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,}");
                    
45        string confirmPass = confirmPassInput.text;
                    
46        Match emailMatch = VALID_EMAIL_ADDRESS_REGEX.Match(email);
                    
47        Match passMatch = passRegEx.Match(password);
                    
                
UsersDataSource.java https://github.com/galderz/rhq.git | Java | 349 lines
                    
56
                    
57    private static final String EMAIL_ADDRESS_REGEXP = "^([a-zA-Z0-9_.\\-+])+@([a-zA-Z0-9\\-])+(\\.([a-zA-Z0-9\\-])+)*$";
                    
58    private static final String MASKED_PASSWORD_VALUE = "XXXXXXXX";
                    
144        fields.add(emailAddressField);
                    
145        RegExpValidator emailAddressValidator = new RegExpValidator(EMAIL_ADDRESS_REGEXP);
                    
146        emailAddressValidator.setErrorMessage(MSG.dataSource_users_invalidEmailAddress());
                    
                
FormValidator_CSC.java https://bitbucket.org/shivam_dayalkar/mercer_api_fork.git | Java | 865 lines
                    
43	List<String> uuidList = new ArrayList<>();
                    
44	static Pattern VALID_EMAIL_ADDRESS_REGEX = 
                    
45		    Pattern.compile("^(.+)@(.+)$", Pattern.CASE_INSENSITIVE);
                    
                
FormValidator.java https://bitbucket.org/BigArchCode/mercer_api_prod.git | Java | 2591 lines
                    
64	ArrayList<String> paramValueList=null;
                    
65	static Pattern VALID_EMAIL_ADDRESS_REGEX = 
                    
66		    Pattern.compile("^(.+)@(.+)$", Pattern.CASE_INSENSITIVE);
                    
                
ContactFormTemplate.java https://bitbucket.org/darkokostic/eyapp.git | Java | 368 lines
                    
80
                    
81    private static final Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
                    
82
                    
333    private boolean isEmailValid(String email) {
                    
334        return VALID_EMAIL_ADDRESS_REGEX.matcher(email).find();
                    
335    }
                    
                
Mail.php https://github.com/tine20/Tine-2.0-Open-Source-Groupware-and-CRM.git | PHP | 736 lines
                    
25    */
                    
26    const EMAIL_ADDRESS_REGEXP = '/^([a-z0-9_\+-\.&]+@[a-z0-9-\.]+\.[a-z]{2,63})$/i';
                    
27
                    
                
ForgotPasswordActivity.kt https://bitbucket.org/aakarshrestha007/nepaligeet.git | Kotlin | 128 lines
                    
24    lateinit var binding: ActivityForgotPasswordBinding
                    
25    val VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE)
                    
26
                    
96    fun validate(emailStr: String): Boolean {
                    
97        val matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr)
                    
98        return matcher.find()
                    
                
text.js https://gitlab.com/reyjmc03/end-to-end | JavaScript | 143 lines
                    
113  var email = emailAddress.getAddress();
                    
114  if (!constants.EMAIL_ADDRESS_REGEXP.exec(emailAddress.getAddress())) {
                    
115    return null;
                    
                
CustomUtil.java https://gitlab.com/CreaTIKZ-groupe4/CreaTIKZ | Java | 131 lines
                    
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);
                    
67	public static Boolean isValidEmail(String email) {
                    
68        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(email);
                    
69        return matcher.find();
                    
                
ResetPassword.java https://bitbucket.org/itwgoandroid/itw-go-android.git | Java | 261 lines
                    
42    String currEmail = "";
                    
43    private final Pattern VALID_EMAIL_ADDRESS_REGEX =
                    
44            Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
                    
                
Utils.java https://bitbucket.org/KusovVV/postcrossinghelper.git | Java | 159 lines
                    
29
                    
30    private static final Pattern EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
                    
31    private static final Pattern TRACK_CODE_REGEX = Pattern.compile("^\\w{2}+\\d{9}+\\w{2}$");
                    
76        }
                    
77        Matcher matcher = EMAIL_ADDRESS_REGEX.matcher(email);
                    
78        return matcher.find();
                    
                
validate.js https://gitlab.com/wamburu/fxa-content-server | JavaScript | 110 lines
                    
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.
                    
                
RegisterActivity.java https://bitbucket.org/WasimShahul/ksapp.git | Java | 159 lines
                    
28    CardView cvAdd;
                    
29    private final Pattern VALID_EMAIL_ADDRESS_REGEX =
                    
30            Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
                    
155    private boolean validate(String emailStr, String password, String repeatPassword) {
                    
156        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(emailStr);
                    
157        return password.length() > 0 && repeatPassword.equals(password) && matcher.find();
                    
                
RegisterActivity.java https://bitbucket.org/itwgoandroid/itw-go-android.git | Java | 291 lines
                    
43    CardView cvAdd;
                    
44    private final Pattern VALID_EMAIL_ADDRESS_REGEX =
                    
45            Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
                    
                
Validator.java https://gitlab.com/arifhasnat/ajkerdeal | Java | 24 lines
                    
9public 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);
                    
15    public static boolean isValidEmail(String email) {
                    
16        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);
                    
17        return matcher.find();
                    
                
Contact.java https://bitbucket.org/sebinsteanu/dsir1862.git | Java | 142 lines
                    
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);
                    
91	public static boolean validEmail(String emailStr) {
                    
92		Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(emailStr);
                    
93		return matcher.find();
                    
                
UserService.java https://bitbucket.org/denisabarar/spring_demo_local.git | Java | 120 lines
                    
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);
                    
105	public static boolean validateEmail(String email) {
                    
106		Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);
                    
107		return matcher.find();
                    
                
EmailValidator.java https://github.com/Godin/sonar.git | Java | 46 lines
                    
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
                    
41  private static boolean isValidEmail(String email) {
                    
42    Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);
                    
43    return matcher.find();
                    
                
how-to-search-effectively-in-searchcode-server.html https://github.com/boyter/searchcode-server.git | HTML | 65 lines
                    
49        For example searching for <strong>Arrays.asList("a1", "a2", "b1", "c2", "c1")</strong> could be turned into a
                    
50        looser query by searching for <strong>Arrays.asList</strong> or <strong>Arrays asList</strong>. Another example would be <strong>EMAIL_ADDRESS_REGEX</strong> for
                    
51        <strong>email address regex</strong>.
                    
                
Utility.java https://bitbucket.org/syncmed/doc360-doctor-android.git | Java | 68 lines
                    
16public 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);
                    
25        } else {
                    
26            Matcher emailMatcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);
                    
27            return emailMatcher.find();
                    
                
filter-wrapper.php https://github.com/wadd0032/mtm1531-homework-6.git | PHP | 153 lines
                    
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);
                    
                
validates_email.rb https://github.com/jamesarosen/ruby-tidbits.git | Ruby | 30 lines
                    
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)
                    
21    
                    
22      unless const_defined?(:SIMPLE_EMAIL_ADDRESS_REGEX)
                    
23        SIMPLE_EMAIL_ADDRESS_REGEX = /\A[^@\s]+@(?:[[:alnum:]-]+\.)+[[:alpha:]]{2,}\Z/i
                    
                
Registration.java https://bitbucket.org/vnrjpmc/onlinescheduler.git | Java | 252 lines
                    
37    ProgressDialog progressDialog;
                    
38    public static final Pattern VALID_EMAIL_ADDRESS_REGEX =
                    
39            Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
                    
99            c_password = (EditText) findViewById(R.id.cpassword);
                    
100            Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email.getText().toString());
                    
101            final FirebaseAuth mAuth;
                    
                
MailAddressResolver.java https://github.com/fujibee/hudson.git | Java | 195 lines
                    
109    private static String extractAddressFromId(String id) {
                    
110        Matcher m = EMAIL_ADDRESS_REGEXP.matcher(id);
                    
111        if(m.matches())
                    
119     */
                    
120    private static final Pattern EMAIL_ADDRESS_REGEXP = Pattern.compile("^.*<([^>]+)>.*$");
                    
121
                    
                
extra_validations.rb https://github.com/pixeltrix/extra_validations.git | Ruby | 26 lines
                    
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/
                    
8  def validates_as_email_address(*args)
                    
9    args << {:with => EMAIL_ADDRESS_REGEX}.update(args.extract_options!); validates_format_of(*args)
                    
10  end
                    
                
Validator.java https://bitbucket.org/ikonstantine/somehiringproject.git | Java | 45 lines
                    
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);
                    
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);
                    
                
ScanInputValidation.java https://bitbucket.org/swathi-cookie/wm-ticket-service.git | Java | 66 lines
                    
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);
                    
29    public static boolean validate(String emailStr) {
                    
30        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);
                    
31        return matcher.find();
                    
                
ValidatorContact.java https://bitbucket.org/laura1825/blir1825.git | Java | 47 lines
                    
9public 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);
                    
43    public static boolean validEmail(String email) {
                    
44        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(email);
                    
45        return matcher.find();
                    
                
Validations.java https://bitbucket.org/fosdev/vouper.git | Java | 98 lines
                    
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);
                    
75        }
                    
76        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(emailStr);
                    
77        return matcher.find();
                    
                
rfc822.rb https://github.com/wireframe/email-validator.git | Ruby | 28 lines
                    
11module RFC822
                    
12  EMAIL_ADDRESS_REGEX = begin
                    
13    qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
                    
                
DefaultUserService.java https://bitbucket.org/roycat/ris-yips-spring-ws.git | Java | 145 lines
                    
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);
                    
126        }
                    
127        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);
                    
128        return matcher.find();
                    
                
SignUpService.java https://bitbucket.org/danhuycao/cs472_mum.git | Java | 40 lines
                    
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);
                    
27
                    
28		Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);
                    
29		if (email.isEmpty()|| !matcher.find()) {
                    
                
Bio.java https://bitbucket.org/vnrjpmc/onlinescheduler.git | Java | 235 lines
                    
41public class Bio extends Fragment{
                    
42    public static final Pattern VALID_EMAIL_ADDRESS_REGEX =
                    
43            Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
                    
112        mail=email.getText().toString();
                    
113        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email.getText().toString());
                    
114        if (matcher.find()) {
                    
                
Mail.php https://github.com/corneliusweiss/Tine-2.0-Open-Source-Groupware-and-CRM.git | PHP | 647 lines
                    
22    */
                    
23    const EMAIL_ADDRESS_REGEXP = '/^([a-z0-9_\+-\.]+@[a-z0-9-\.]+\.[a-z]{2,63})$/i';
                    
24
                    
                
HelperTests.php https://github.com/tine20/Tine-2.0-Open-Source-Groupware-and-CRM.git | PHP | 95 lines
                    
89        $punyCodedAddress = Tinebase_Helper::convertDomainToPunycode($input);
                    
90        if (! preg_match(Tinebase_Mail::EMAIL_ADDRESS_REGEXP, $punyCodedAddress)) {
                    
91            self::fail('address is not invalid: ' . $punyCodedAddress);
                    
                
DataValidation.java https://bitbucket.org/dccor/musicmasterweb.git | Java | 33 lines
                    
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])?"
                    
28	public static boolean validateEmail(String emailStr) {
                    
29		Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);
                    
30		return matcher.find();
                    
                
validators.js https://github.com/deadlyicon/validation.js.git | JavaScript | 64 lines
                    
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){
                    
32  function isAnEmailAddress(value, reportErrors){
                    
33    if (!EMAIL_ADDRESS_REGEX.test(value))
                    
34        reportErrors(['must be a valid email address']);
                    
                
q.patterns.js https://bitbucket.org/marcuspope/q.node | JavaScript | 56 lines
                    
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-]+)*$/)
                    
                
UserValidation.java https://bitbucket.org/zenwherk/zenwherk-api.git | Java | 92 lines
                    
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);
                    
38            } else {
                    
39                Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(user.getEmail());
                    
40                if(!matcher.find()) {
                    
                
UserService.java https://bitbucket.org/danhuycao/cs472_mum.git | Java | 50 lines
                    
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);
                    
37
                    
38        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(u.getEmail());
                    
39        if (u.getEmail().isEmpty()|| !matcher.find()) {
                    
                
EmailUtils.cpp https://review.tizen.org/git/ | C++ | 97 lines
                    
30namespace {
                    
31const char* EMAIL_ADDRESS_REGEX =
                    
32    "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,6}";
                    
33
                    
34const std::string EMAIL_ADDRESS_REGEX_GROUP =
                    
35    StringBuilder()
                    
36        .append("(")
                    
37        .append(EMAIL_ADDRESS_REGEX)
                    
38        .append(")")
                    
72    std::string result;
                    
73    pcrecpp::RE re(EMAIL_ADDRESS_REGEX_GROUP);
                    
74    if (!re.PartialMatch(address, &result)) {
                    
                
email_validator.rb https://github.com/vjt/email_validator.git | Ruby | 105 lines
                    
11
                    
12  email_address_regexp     = '(?:' + local_part_unquoted + '+|' + local_part_quoted + '+)' + domain_part
                    
13
                    
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
                    
                
validation.js https://github.com/tmd10470/browserid.git | JavaScript | 101 lines
                    
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
                    
                
EmailValidator.java https://bitbucket.org/gabi88ibag/taxesmemo.git | Java | 67 lines
                    
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);
                    
29	public static boolean isValidEmail(String email) {
                    
30		Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(email);
                    
31		if (matcher.find()) {
                    
                
Email.js https://github.com/audreyt/socialtext-open.git | JavaScript | 26 lines
                    
13
                    
14    var EMAIL_ADDRESS_REGEX = new RegExp(
                    
15        "^" + EMAIL_ADDRESS + "$", "i"
                    
22    return function(email_address) {
                    
23        return EMAIL_ADDRESS_REGEX.test(email_address) ||
                    
24               EMAIL_WITH_NAME_REGEX.test(email_address);
                    
                
EmailAddressAutoLinker.java https://github.com/michael-simons/java-autolinker.git | Java | 139 lines
                    
43	 */
                    
44	private static final String VALID_EMAIL_ADDRESS_REGEX = "(?:[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+|\\x22(?:[^\\x0d\\x22\\x5c\\x80-\\xff]|\\x5c[\\x00-\\x7f])*\\x22)(?:\\x2e(?:[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+|\\x22(?:[^\\x0d\\x22\\x5c\\x80-\\xff]|\\x5c[\\x00-\\x7f])*\\x22))*\\x40(?:[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+|\\x5b(?:[^\\x0d\\x5b-\\x5d\\x80-\\xff]|\\x5c[\\x00-\\x7f])*\\x5d)(?:\\x2e(?:[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+|\\x5b(?:[^\\x0d\\x5b-\\x5d\\x80-\\xff]|\\x5c[\\x00-\\x7f])*\\x5d))*";
                    
45	public static final Pattern VALID_EMAIL_ADDRESS = Pattern.compile(String.format("\\A%s\\z", VALID_EMAIL_ADDRESS_REGEX));
                    
45	public static final Pattern VALID_EMAIL_ADDRESS = Pattern.compile(String.format("\\A%s\\z", VALID_EMAIL_ADDRESS_REGEX));
                    
46	public static final Pattern VALID_EMAIL_ADRESS_ML = Pattern.compile(String.format("(?m)(?<![^\\s])%s", VALID_EMAIL_ADDRESS_REGEX));
                    
47	public static final Pattern AT_SIGNS = Pattern.compile("[@\uFF20\\x40]");
                    
                
SmtpClientProcessor.cs https://bitbucket.org/kzoabi/lovon | C# | 357 lines
                    
20        private static Logger logger = LogManager.GetCurrentClassLogger();
                    
21        private static readonly Regex EMAIL_ADDRESS_REGEX = new Regex("<.+@.+>", RegexOptions.IgnoreCase);
                    
22
                    
290        {
                    
291            var match = EMAIL_ADDRESS_REGEX.Match(input);
                    
292
                    
                
EmailValidatorImpl.kt https://bitbucket.org/wliberda/fotommvvmcleanarchitecture.git | Kotlin | 16 lines
                    
11    override fun validate(emailStr: String): Boolean =
                    
12        VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr).run {
                    
13            this.find()
                    
                
ValidationUtils.java https://bitbucket.org/Zeee/testapp.git | Java | 26 lines
                    
7
                    
8    private static final Pattern EMAIL_ADDRESS_REGEX
                    
9            = Pattern.compile(
                    
19    public static boolean isEmailValid(String email){
                    
20        return EMAIL_ADDRESS_REGEX.matcher(email).matches();
                    
21    }
                    
                
EmailValidator.kt https://bitbucket.org/wliberda/fotommvvmcleanarchitecture.git | Kotlin | 12 lines
                    
8interface 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)!!
                    
                
email-validator.rb https://github.com/wireframe/email-validator.git | Ruby | 23 lines
                    
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
                    
                
 

Source

Language