mail_address 1.2.14 → 1.2.15

Sign up to get free protection for your applications and to get access to all the features.
Files changed (9) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +10 -1
  3. data/lib/mail_address/mail_address.rb +4 -0
  4. data/lib/mail_address/simple_parser.rb +4 -0
  5. data/lib/mail_address/version.rb +1 -1
  6. data/spec/mail_address_spec.rb +385 -393
  7. data/spec/simple_parser_spec.rb +1 -1
  8. data/spec/spec_helper.rb +2 -3
  9. metadata +3 -3
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 421e1293f8cc6a196e5d2bbacad2b5d390cb8ad9
4
- data.tar.gz: 5a80cd717ed0e48c76f0f6d3c2e8eca478f2f85b
3
+ metadata.gz: 178331c0a94b43c78dae091e6072d33399aea7d6
4
+ data.tar.gz: 88a14c0c1c218dac32e973350e36f7fbf7b02c47
5
5
  SHA512:
6
- metadata.gz: d2ab6254e7914a045e3a41fa57450d8cffb4786d7d29ba4923fb10a7edead3994d11808f91a20e9003023f4cbc5bb3440cf7c0c10377d8f4c76a42b28256d0ae
7
- data.tar.gz: 72411a7bbba88e8617b36a90d0c811d2abc3336aaa57ae5bae1ce48814bc63473376baba4f21d48c4625b66d1debf37a34efeba75dc42e71d36ddeb5ff6a16f6
6
+ metadata.gz: 0641e7d194b1981985a8110e315d1caa19b19ae20ca21daac89b35ecb5a33cb1889bae67f27812d954c26fffada29bb166cab245e4e2257271f7032b91a758ad
7
+ data.tar.gz: 680b3f0c891f5e7a1ad3a5eb359938e05fd428ac6b76f5403a880242ae3f40b4a04b81a99032f432fafc49237e5732f9a1c276cbc50b2e1ce33be761e357bac7
data/README.md CHANGED
@@ -14,7 +14,7 @@ But Mail::Address(Perl) has some bad points (below). These are fixed in MailAddr
14
14
  - if no ending parenthesis in name part, cannot parse correctly.
15
15
  - Modifications of name part are too much.
16
16
 
17
- Many people copy and paste email addresses from Excel or the other spreadsheets. In this case, addresses are separated by whitespace(tab or space). To enable to parse this, also ported from a parser part of [Google Closure Library](https://github.com/google/closure-library/blob/master/closure/goog/format/emailaddress.js).
17
+ Many people copy and paste email addresses from Excel or the other spreadsheets. In this case, addresses are separated by whitespace(tab or space). To enable to parse this, also ported from a parser part of [Google Closure Library](https://github.com/google/closure-library/blob/master/closure/goog/format/emailaddress.js).
18
18
 
19
19
  ## Installation
20
20
 
@@ -63,6 +63,15 @@ p addrs[1].original # "大阪 太郎 <osaka@example.jp>"
63
63
  `address.name` and `address.phrase` are almost same.
64
64
  `address.phrase` keeps outermost double quotes or parentheses.
65
65
 
66
+ if you specify single email address, you can use `parse_first`.
67
+
68
+ ```rb
69
+ line = "John Doe <john@example.com>"
70
+ addr = MailAddress.parse_first(line)
71
+
72
+ p addr.address # "john@example.com"
73
+ ```
74
+
66
75
  ### Parse addresses separated with whitespace
67
76
 
68
77
  ```rb
data/lib/mail_address/mail_address.rb CHANGED
@@ -1,6 +1,10 @@
1
1
 
2
2
  module MailAddress
3
3
 
4
+ def self.parse_first(*addresses)
5
+ self.parse(*addresses).first
6
+ end
7
+
4
8
  def self.parse(*addresses)
5
9
  lines = addresses.grep(String)
6
10
  line = lines.join('').strip
data/lib/mail_address/simple_parser.rb CHANGED
@@ -134,4 +134,8 @@ module MailAddress
134
134
  EMAIL_ADDRESS_ =~ address.address
135
135
  end
136
136
 
137
+ class << self
138
+ alias_method :g_parse, :parse_simple
139
+ end
140
+
137
141
  end
data/lib/mail_address/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  module MailAddress
2
- VERSION = "1.2.14"
2
+ VERSION = "1.2.15"
3
3
  end
data/spec/mail_address_spec.rb CHANGED
@@ -1,4 +1,3 @@
1
- # -*- coding: utf-8 -*-
2
1
  require 'spec_helper'
3
2
  require 'pp'
4
3
 
@@ -7,189 +6,181 @@ describe MailAddress do
7
6
  it "normal case (commonly used)" do
8
7
  # address only
9
8
  line = 'johndoe@example.com'
10
- results = MailAddress.parse(line)
11
- expect(results[0].format).to eq('johndoe@example.com')
12
- expect(results[0].format(true)).to eq('johndoe@example.com')
13
- expect(results[0].address).to eq('johndoe@example.com')
14
- expect(results[0].name).to be_nil
15
- expect(results[0].phrase).to eq('')
16
- expect(results[0].host).to eq('example.com')
17
- expect(results[0].user).to eq('johndoe')
18
- expect(results[0].original).to eq(line)
9
+ result = MailAddress.parse_first(line)
10
+ expect(result.format).to eq('johndoe@example.com')
11
+ expect(result.format(true)).to eq('johndoe@example.com')
12
+ expect(result.address).to eq('johndoe@example.com')
13
+ expect(result.name).to be_nil
14
+ expect(result.phrase).to eq('')
15
+ expect(result.host).to eq('example.com')
16
+ expect(result.user).to eq('johndoe')
17
+ expect(result.original).to eq(line)
19
18
 
20
19
  # <address> only
21
20
  line = '<johndoe@example.com>'
22
- results = MailAddress.parse(line)
23
- expect(results[0].format).to eq('johndoe@example.com')
24
- expect(results[0].format(true)).to eq('johndoe@example.com')
25
- expect(results[0].address).to eq('johndoe@example.com')
26
- expect(results[0].name).to be_nil
27
- expect(results[0].phrase).to eq('')
28
- expect(results[0].host).to eq('example.com')
29
- expect(results[0].user).to eq('johndoe')
30
- expect(results[0].original).to eq(line)
21
+ result = MailAddress.parse_first(line)
22
+ expect(result.format).to eq('johndoe@example.com')
23
+ expect(result.format(true)).to eq('johndoe@example.com')
24
+ expect(result.address).to eq('johndoe@example.com')
25
+ expect(result.name).to be_nil
26
+ expect(result.phrase).to eq('')
27
+ expect(result.host).to eq('example.com')
28
+ expect(result.user).to eq('johndoe')
29
+ expect(result.original).to eq(line)
31
30
 
32
31
  # name + <address> (single byte only)
33
32
  line = 'John Doe <johndoe@example.com>'
34
- results = MailAddress.parse(line)
35
- expect(results[0].format).to eq('John Doe <johndoe@example.com>')
36
- expect(results[0].format(true)).to eq('John Doe <johndoe@example.com>')
37
- expect(results[0].address).to eq('johndoe@example.com')
38
- expect(results[0].name).to eq('John Doe')
39
- expect(results[0].phrase).to eq('John Doe')
40
- expect(results[0].host).to eq('example.com')
41
- expect(results[0].user).to eq('johndoe')
42
- expect(results[0].original).to eq(line)
33
+ result = MailAddress.parse_first(line)
34
+ expect(result.format).to eq('John Doe <johndoe@example.com>')
35
+ expect(result.format(true)).to eq('John Doe <johndoe@example.com>')
36
+ expect(result.address).to eq('johndoe@example.com')
37
+ expect(result.name).to eq('John Doe')
38
+ expect(result.phrase).to eq('John Doe')
39
+ expect(result.host).to eq('example.com')
40
+ expect(result.user).to eq('johndoe')
41
+ expect(result.original).to eq(line)
43
42
 
44
43
  # name + <address> (multi byte)
45
44
  line = 'ジョン ドゥ <johndoe@example.com>'
46
- results = MailAddress.parse(line)
47
- expect(results[0].format).to eq('"ジョン ドゥ" <johndoe@example.com>')
48
- expect(results[0].format(true)).to eq('"ジョン ドゥ" <johndoe@example.com>')
49
- expect(results[0].address).to eq('johndoe@example.com')
50
- expect(results[0].name).to eq('ジョン ドゥ')
51
- expect(results[0].phrase).to eq('ジョン ドゥ')
52
- expect(results[0].host).to eq('example.com')
53
- expect(results[0].user).to eq('johndoe')
54
- expect(results[0].original).to eq(line)
45
+ result = MailAddress.parse_first(line)
46
+ expect(result.format).to eq('"ジョン ドゥ" <johndoe@example.com>')
47
+ expect(result.format(true)).to eq('"ジョン ドゥ" <johndoe@example.com>')
48
+ expect(result.address).to eq('johndoe@example.com')
49
+ expect(result.name).to eq('ジョン ドゥ')
50
+ expect(result.phrase).to eq('ジョン ドゥ')
51
+ expect(result.host).to eq('example.com')
52
+ expect(result.user).to eq('johndoe')
53
+ expect(result.original).to eq(line)
55
54
 
56
55
  line = 'Amazon.co.jp アソシエイト・プログラム <associates@amazon.co.jp>'
57
- results = MailAddress.parse(line)
58
- expect(results[0].format).to eq('"Amazon.co.jp アソシエイト・プログラム" <associates@amazon.co.jp>')
59
- expect(results[0].format(true)).to eq('"Amazon.co.jp アソシエイト・プログラム" <associates@amazon.co.jp>')
60
- expect(results[0].address).to eq('associates@amazon.co.jp')
61
- expect(results[0].name).to eq('Amazon.co.jp アソシエイト・プログラム')
62
- expect(results[0].phrase).to eq('Amazon.co.jp アソシエイト・プログラム')
63
- expect(results[0].host).to eq('amazon.co.jp')
64
- expect(results[0].user).to eq('associates')
65
- expect(results[0].original).to eq(line)
56
+ result = MailAddress.parse_first(line)
57
+ expect(result.format).to eq('"Amazon.co.jp アソシエイト・プログラム" <associates@amazon.co.jp>')
58
+ expect(result.format(true)).to eq('"Amazon.co.jp アソシエイト・プログラム" <associates@amazon.co.jp>')
59
+ expect(result.address).to eq('associates@amazon.co.jp')
60
+ expect(result.name).to eq('Amazon.co.jp アソシエイト・プログラム')
61
+ expect(result.phrase).to eq('Amazon.co.jp アソシエイト・プログラム')
62
+ expect(result.host).to eq('amazon.co.jp')
63
+ expect(result.user).to eq('associates')
64
+ expect(result.original).to eq(line)
66
65
 
67
66
  # name (includes parens) + <address>
68
67
  line = 'Example (Twitterより) <notify@twitter.com>'
69
- results = MailAddress.parse(line)
70
- expect(results[0].format).to eq('"Example (Twitterより)" <notify@twitter.com>')
71
- expect(results[0].format(true)).to eq('"Example (Twitterより)" <notify@twitter.com>')
72
- expect(results[0].address).to eq('notify@twitter.com')
73
- expect(results[0].name).to eq('Example (Twitterより)')
74
- expect(results[0].phrase).to eq('Example (Twitterより)')
75
- expect(results[0].host).to eq('twitter.com')
76
- expect(results[0].user).to eq('notify')
77
- expect(results[0].original).to eq(line)
68
+ result = MailAddress.parse_first(line)
69
+ expect(result.format).to eq('"Example (Twitterより)" <notify@twitter.com>')
70
+ expect(result.format(true)).to eq('"Example (Twitterより)" <notify@twitter.com>')
71
+ expect(result.address).to eq('notify@twitter.com')
72
+ expect(result.name).to eq('Example (Twitterより)')
73
+ expect(result.phrase).to eq('Example (Twitterより)')
74
+ expect(result.host).to eq('twitter.com')
75
+ expect(result.user).to eq('notify')
76
+ expect(result.original).to eq(line)
78
77
 
79
78
  # name + <address> (multi byte) name is quoted
80
79
  line = '"ジョン ドゥ" <johndoe@example.com>'
81
- results = MailAddress.parse(line)
82
- expect(results[0].format).to eq('"ジョン ドゥ" <johndoe@example.com>')
83
- expect(results[0].format(true)).to eq('"ジョン ドゥ" <johndoe@example.com>')
84
- expect(results[0].address).to eq('johndoe@example.com')
85
- expect(results[0].name).to eq('ジョン ドゥ')
86
- expect(results[0].phrase).to eq('ジョン ドゥ')
87
- expect(results[0].host).to eq('example.com')
88
- expect(results[0].user).to eq('johndoe')
89
- expect(results[0].original).to eq(line)
80
+ result = MailAddress.parse_first(line)
81
+ expect(result.format).to eq('"ジョン ドゥ" <johndoe@example.com>')
82
+ expect(result.format(true)).to eq('"ジョン ドゥ" <johndoe@example.com>')
83
+ expect(result.address).to eq('johndoe@example.com')
84
+ expect(result.name).to eq('ジョン ドゥ')
85
+ expect(result.phrase).to eq('ジョン ドゥ')
86
+ expect(result.host).to eq('example.com')
87
+ expect(result.user).to eq('johndoe')
88
+ expect(result.original).to eq(line)
90
89
 
91
90
  # address + (note)
92
91
  line = 'johndoe@example.com (John Doe)'
93
- results = MailAddress.parse(line)
94
- # expect(results[0].format).to eq('johndoe@example.com (John Doe)')
95
- # expect(results[0].format(true)).to eq('johndoe@example.com (John Doe)')
96
- expect(results[0].format).to eq('"(John Doe)" <johndoe@example.com>')
97
- expect(results[0].format(true)).to eq('"(John Doe)" <johndoe@example.com>')
98
- expect(results[0].address).to eq('johndoe@example.com')
99
- expect(results[0].name).to eq('John Doe')
100
- expect(results[0].phrase).to eq('(John Doe)')
101
- expect(results[0].host).to eq('example.com')
102
- expect(results[0].user).to eq('johndoe')
103
- expect(results[0].original).to eq(line)
92
+ result = MailAddress.parse_first(line)
93
+ expect(result.format).to eq('"(John Doe)" <johndoe@example.com>')
94
+ expect(result.format(true)).to eq('"(John Doe)" <johndoe@example.com>')
95
+ expect(result.address).to eq('johndoe@example.com')
96
+ expect(result.name).to eq('John Doe')
97
+ expect(result.phrase).to eq('(John Doe)')
98
+ expect(result.host).to eq('example.com')
99
+ expect(result.user).to eq('johndoe')
100
+ expect(result.original).to eq(line)
104
101
 
105
102
  # address + (note) # nested paren
106
103
  line = 'johndoe@example.com (John (Mid) Doe)'
107
- results = MailAddress.parse(line)
108
- # expect(results[0].format).to eq('johndoe@example.com (John (Mid) Doe)')
109
- # expect(results[0].format(true)).to eq('johndoe@example.com (John (Mid) Doe)')
110
- expect(results[0].format).to eq('"(John (Mid) Doe)" <johndoe@example.com>')
111
- expect(results[0].format(true)).to eq('"(John (Mid) Doe)" <johndoe@example.com>')
112
- expect(results[0].address).to eq('johndoe@example.com')
113
- expect(results[0].name).to eq('John (Mid) Doe')
114
- expect(results[0].phrase).to eq('(John (Mid) Doe)')
115
- expect(results[0].host).to eq('example.com')
116
- expect(results[0].user).to eq('johndoe')
117
- expect(results[0].original).to eq(line)
104
+ result = MailAddress.parse_first(line)
105
+ expect(result.format).to eq('"(John (Mid) Doe)" <johndoe@example.com>')
106
+ expect(result.format(true)).to eq('"(John (Mid) Doe)" <johndoe@example.com>')
107
+ expect(result.address).to eq('johndoe@example.com')
108
+ expect(result.name).to eq('John (Mid) Doe')
109
+ expect(result.phrase).to eq('(John (Mid) Doe)')
110
+ expect(result.host).to eq('example.com')
111
+ expect(result.user).to eq('johndoe')
112
+ expect(result.original).to eq(line)
118
113
 
119
114
  # address + (note) # note has special char
120
115
  line = 'johndoe@example.com (John@Doe)'
121
- results = MailAddress.parse(line)
122
- # expect(results[0].format).to eq('johndoe@example.com (John@Doe)')
123
- # expect(results[0].format(true)).to eq('johndoe@example.com (John@Doe)')
124
- expect(results[0].format).to eq('"(John@Doe)" <johndoe@example.com>')
125
- expect(results[0].format(true)).to eq('"(John@Doe)" <johndoe@example.com>')
126
- expect(results[0].address).to eq('johndoe@example.com')
127
- expect(results[0].name).to eq('John@Doe')
128
- expect(results[0].phrase).to eq('(John@Doe)')
129
- expect(results[0].host).to eq('example.com')
130
- expect(results[0].user).to eq('johndoe')
131
- expect(results[0].original).to eq(line)
116
+ result = MailAddress.parse_first(line)
117
+ expect(result.format).to eq('"(John@Doe)" <johndoe@example.com>')
118
+ expect(result.format(true)).to eq('"(John@Doe)" <johndoe@example.com>')
119
+ expect(result.address).to eq('johndoe@example.com')
120
+ expect(result.name).to eq('John@Doe')
121
+ expect(result.phrase).to eq('(John@Doe)')
122
+ expect(result.host).to eq('example.com')
123
+ expect(result.user).to eq('johndoe')
124
+ expect(result.original).to eq(line)
132
125
 
133
126
  line = 'johndoe@example.com (John, Doe)'
134
- results = MailAddress.parse(line)
135
- # expect(results[0].format).to eq('johndoe@example.com (John, Doe)')
136
- # expect(results[0].format(true)).to eq('johndoe@example.com (John, Doe)')
137
- expect(results[0].format).to eq('"(John, Doe)" <johndoe@example.com>')
138
- expect(results[0].format(true)).to eq('"(John, Doe)" <johndoe@example.com>')
139
- expect(results[0].address).to eq('johndoe@example.com')
140
- expect(results[0].name).to eq('John, Doe')
141
- expect(results[0].phrase).to eq('(John, Doe)')
142
- expect(results[0].host).to eq('example.com')
143
- expect(results[0].user).to eq('johndoe')
144
- expect(results[0].original).to eq(line)
127
+ result = MailAddress.parse_first(line)
128
+ expect(result.format).to eq('"(John, Doe)" <johndoe@example.com>')
129
+ expect(result.format(true)).to eq('"(John, Doe)" <johndoe@example.com>')
130
+ expect(result.address).to eq('johndoe@example.com')
131
+ expect(result.name).to eq('John, Doe')
132
+ expect(result.phrase).to eq('(John, Doe)')
133
+ expect(result.host).to eq('example.com')
134
+ expect(result.user).to eq('johndoe')
135
+ expect(result.original).to eq(line)
145
136
 
146
137
  # name + <address> + (note)
147
138
  line = 'John Doe <johndoe@example.com> (Extra)'
148
- results = MailAddress.parse(line)
149
- expect(results[0].format).to eq('"John Doe (Extra)" <johndoe@example.com>')
150
- expect(results[0].format(true)).to eq('"John Doe (Extra)" <johndoe@example.com>')
151
- expect(results[0].address).to eq('johndoe@example.com')
152
- expect(results[0].name).to eq('John Doe (Extra)')
153
- expect(results[0].phrase).to eq('John Doe (Extra)')
154
- expect(results[0].host).to eq('example.com')
155
- expect(results[0].user).to eq('johndoe')
156
- expect(results[0].original).to eq(line)
139
+ result = MailAddress.parse_first(line)
140
+ expect(result.format).to eq('"John Doe (Extra)" <johndoe@example.com>')
141
+ expect(result.format(true)).to eq('"John Doe (Extra)" <johndoe@example.com>')
142
+ expect(result.address).to eq('johndoe@example.com')
143
+ expect(result.name).to eq('John Doe (Extra)')
144
+ expect(result.phrase).to eq('John Doe (Extra)')
145
+ expect(result.host).to eq('example.com')
146
+ expect(result.user).to eq('johndoe')
147
+ expect(result.original).to eq(line)
157
148
 
158
149
  # name + <address> (name has starting paren but doesn't have ending paren)
159
150
  line = 'John(Doe <johndoe@example.com>'
160
- results = MailAddress.parse(line)
161
- expect(results[0].format).to eq('"John(Doe" <johndoe@example.com>')
162
- expect(results[0].format(true)).to eq('"John(Doe" <johndoe@example.com>')
163
- expect(results[0].address).to eq('johndoe@example.com')
164
- expect(results[0].name).to eq('John(Doe')
165
- expect(results[0].phrase).to eq('John(Doe')
166
- expect(results[0].host).to eq('example.com')
167
- expect(results[0].user).to eq('johndoe')
168
- expect(results[0].original).to eq(line)
151
+ result = MailAddress.parse_first(line)
152
+ expect(result.format).to eq('"John(Doe" <johndoe@example.com>')
153
+ expect(result.format(true)).to eq('"John(Doe" <johndoe@example.com>')
154
+ expect(result.address).to eq('johndoe@example.com')
155
+ expect(result.name).to eq('John(Doe')
156
+ expect(result.phrase).to eq('John(Doe')
157
+ expect(result.host).to eq('example.com')
158
+ expect(result.user).to eq('johndoe')
159
+ expect(result.original).to eq(line)
169
160
 
170
161
  # ditto
171
162
  line = 'John ( Doe <johndoe@example.com>'
172
- results = MailAddress.parse(line)
173
- expect(results[0].format).to eq('"John ( Doe" <johndoe@example.com>')
174
- expect(results[0].format(true)).to eq('"John ( Doe" <johndoe@example.com>')
175
- expect(results[0].address).to eq('johndoe@example.com')
176
- expect(results[0].name).to eq('John ( Doe')
177
- expect(results[0].phrase).to eq('John ( Doe')
178
- expect(results[0].host).to eq('example.com')
179
- expect(results[0].user).to eq('johndoe')
180
- expect(results[0].original).to eq(line)
163
+ result = MailAddress.parse_first(line)
164
+ expect(result.format).to eq('"John ( Doe" <johndoe@example.com>')
165
+ expect(result.format(true)).to eq('"John ( Doe" <johndoe@example.com>')
166
+ expect(result.address).to eq('johndoe@example.com')
167
+ expect(result.name).to eq('John ( Doe')
168
+ expect(result.phrase).to eq('John ( Doe')
169
+ expect(result.host).to eq('example.com')
170
+ expect(result.user).to eq('johndoe')
171
+ expect(result.original).to eq(line)
181
172
 
182
173
  # "address1" <address2>
183
174
  line = '"michael@example.jp" <johndoe@example.com>'
184
- results = MailAddress.parse(line)
185
- expect(results[0].format).to eq('"michael@example.jp" <johndoe@example.com>')
186
- expect(results[0].format(true)).to eq('"michael@example.jp" <johndoe@example.com>')
187
- expect(results[0].address).to eq('johndoe@example.com')
188
- expect(results[0].name).to eq('michael@example.jp')
189
- expect(results[0].phrase).to eq('michael@example.jp')
190
- expect(results[0].host).to eq('example.com')
191
- expect(results[0].user).to eq('johndoe')
192
- expect(results[0].original).to eq(line)
175
+ result = MailAddress.parse_first(line)
176
+ expect(result.format).to eq('"michael@example.jp" <johndoe@example.com>')
177
+ expect(result.format(true)).to eq('"michael@example.jp" <johndoe@example.com>')
178
+ expect(result.address).to eq('johndoe@example.com')
179
+ expect(result.name).to eq('michael@example.jp')
180
+ expect(result.phrase).to eq('michael@example.jp')
181
+ expect(result.host).to eq('example.com')
182
+ expect(result.user).to eq('johndoe')
183
+ expect(result.original).to eq(line)
193
184
  end
194
185
 
195
186
  it "normal case (multiple address)" do
@@ -226,186 +217,187 @@ describe MailAddress do
226
217
  it "normal case (rfc-violated(RFC822) but commonly used in AU/DoCoMo)" do
227
218
  # dot before @
228
219
  line = 'johndoe.@example.com' # no double quotes
229
- results = MailAddress.parse(line)
220
+ result = MailAddress.parse_first(line)
230
221
 
231
- expect(results[0].format).to eq('johndoe.@example.com')
232
- expect(results[0].format(true)).to eq('"johndoe."@example.com')
233
- expect(results[0].address).to eq('johndoe.@example.com')
234
- expect(results[0].name).to be_nil
235
- expect(results[0].phrase).to eq('')
236
- expect(results[0].host).to eq('example.com')
237
- expect(results[0].user).to eq('johndoe.')
238
- expect(results[0].original).to eq(line)
222
+ expect(result.format).to eq('johndoe.@example.com')
223
+ expect(result.format(true)).to eq('"johndoe."@example.com')
224
+ expect(result.address).to eq('johndoe.@example.com')
225
+ expect(result.name).to be_nil
226
+ expect(result.phrase).to eq('')
227
+ expect(result.host).to eq('example.com')
228
+ expect(result.user).to eq('johndoe.')
229
+ expect(result.original).to eq(line)
239
230
 
240
231
  line = '"johndoe."@example.com' # enclosed with double quotes
241
- results = MailAddress.parse(line)
232
+ result = MailAddress.parse_first(line)
242
233
 
243
- expect(results[0].format).to eq('"johndoe."@example.com')
244
- expect(results[0].format(true)).to eq('"johndoe."@example.com')
245
- expect(results[0].address).to eq('"johndoe."@example.com')
246
- expect(results[0].name).to be_nil
247
- expect(results[0].phrase).to eq('')
248
- expect(results[0].host).to eq('example.com')
249
- expect(results[0].user).to eq('"johndoe."')
250
- expect(results[0].original).to eq(line)
234
+ expect(result.format).to eq('"johndoe."@example.com')
235
+ expect(result.format(true)).to eq('"johndoe."@example.com')
236
+ expect(result.address).to eq('"johndoe."@example.com')
237
+ expect(result.name).to be_nil
238
+ expect(result.phrase).to eq('')
239
+ expect(result.host).to eq('example.com')
240
+ expect(result.user).to eq('"johndoe."')
241
+ expect(result.original).to eq(line)
251
242
 
252
243
  line = 'John Doe <johndoe.@example.com>' # no double quotes
253
- results = MailAddress.parse(line)
244
+ result = MailAddress.parse_first(line)
254
245
 
255
- expect(results[0].format).to eq('John Doe <johndoe.@example.com>')
256
- expect(results[0].format(true)).to eq('John Doe <"johndoe."@example.com>')
257
- expect(results[0].address).to eq('johndoe.@example.com')
258
- expect(results[0].name).to eq('John Doe')
259
- expect(results[0].phrase).to eq('John Doe')
260
- expect(results[0].host).to eq('example.com')
261
- expect(results[0].user).to eq('johndoe.')
262
- expect(results[0].original).to eq(line)
246
+ expect(result.format).to eq('John Doe <johndoe.@example.com>')
247
+ expect(result.format(true)).to eq('John Doe <"johndoe."@example.com>')
248
+ expect(result.address).to eq('johndoe.@example.com')
249
+ expect(result.name).to eq('John Doe')
250
+ expect(result.phrase).to eq('John Doe')
251
+ expect(result.host).to eq('example.com')
252
+ expect(result.user).to eq('johndoe.')
253
+ expect(result.original).to eq(line)
263
254
 
264
255
  line = 'John Doe <"johndoe."@example.com>' # enclosed with double quotes
265
- results = MailAddress.parse(line)
256
+ result = MailAddress.parse_first(line)
266
257
 
267
- expect(results[0].format).to eq('John Doe <"johndoe."@example.com>')
268
- expect(results[0].format(true)).to eq('John Doe <"johndoe."@example.com>')
269
- expect(results[0].address).to eq('"johndoe."@example.com')
270
- expect(results[0].name).to eq('John Doe')
271
- expect(results[0].phrase).to eq('John Doe')
272
- expect(results[0].host).to eq('example.com')
273
- expect(results[0].user).to eq('"johndoe."')
274
- expect(results[0].original).to eq(line)
258
+ expect(result.format).to eq('John Doe <"johndoe."@example.com>')
259
+ expect(result.format(true)).to eq('John Doe <"johndoe."@example.com>')
260
+ expect(result.address).to eq('"johndoe."@example.com')
261
+ expect(result.name).to eq('John Doe')
262
+ expect(result.phrase).to eq('John Doe')
263
+ expect(result.host).to eq('example.com')
264
+ expect(result.user).to eq('"johndoe."')
265
+ expect(result.original).to eq(line)
275
266
 
276
267
  # contains '..'
277
268
  line = 'john..doe@example.com' # enclosed with double quotes
278
- results = MailAddress.parse(line)
269
+ result = MailAddress.parse_first(line)
279
270
 
280
- expect(results[0].format).to eq('john..doe@example.com')
281
- expect(results[0].format(true)).to eq('"john..doe"@example.com')
282
- expect(results[0].address).to eq('john..doe@example.com')
283
- expect(results[0].name).to be_nil
284
- expect(results[0].phrase).to eq('')
285
- expect(results[0].host).to eq('example.com')
286
- expect(results[0].user).to eq('john..doe')
287
- expect(results[0].original).to eq(line)
271
+ expect(result.format).to eq('john..doe@example.com')
272
+ expect(result.format(true)).to eq('"john..doe"@example.com')
273
+ expect(result.address).to eq('john..doe@example.com')
274
+ expect(result.name).to be_nil
275
+ expect(result.phrase).to eq('')
276
+ expect(result.host).to eq('example.com')
277
+ expect(result.user).to eq('john..doe')
278
+ expect(result.original).to eq(line)
288
279
 
289
280
  line = '"john..doe"@example.com' # enclosed with double quotes
290
- results = MailAddress.parse(line)
281
+ result = MailAddress.parse_first(line)
291
282
 
292
- expect(results[0].format).to eq('"john..doe"@example.com')
293
- expect(results[0].format(true)).to eq('"john..doe"@example.com')
294
- expect(results[0].address).to eq('"john..doe"@example.com')
295
- expect(results[0].name).to be_nil
296
- expect(results[0].phrase).to eq('')
297
- expect(results[0].host).to eq('example.com')
298
- expect(results[0].user).to eq('"john..doe"')
299
- expect(results[0].original).to eq(line)
283
+ expect(result.format).to eq('"john..doe"@example.com')
284
+ expect(result.format(true)).to eq('"john..doe"@example.com')
285
+ expect(result.address).to eq('"john..doe"@example.com')
286
+ expect(result.name).to be_nil
287
+ expect(result.phrase).to eq('')
288
+ expect(result.host).to eq('example.com')
289
+ expect(result.user).to eq('"john..doe"')
290
+ expect(result.original).to eq(line)
300
291
 
301
292
  line = 'John Doe <john..doe@example.com>' # no double quotes
302
- results = MailAddress.parse(line)
293
+ result = MailAddress.parse_first(line)
303
294
 
304
- expect(results[0].format).to eq('John Doe <john..doe@example.com>')
305
- expect(results[0].format(true)).to eq('John Doe <"john..doe"@example.com>')
306
- expect(results[0].address).to eq('john..doe@example.com')
307
- expect(results[0].name).to eq('John Doe')
308
- expect(results[0].phrase).to eq('John Doe')
309
- expect(results[0].host).to eq('example.com')
310
- expect(results[0].user).to eq('john..doe')
311
- expect(results[0].original).to eq(line)
295
+ expect(result.format).to eq('John Doe <john..doe@example.com>')
296
+ expect(result.format(true)).to eq('John Doe <"john..doe"@example.com>')
297
+ expect(result.address).to eq('john..doe@example.com')
298
+ expect(result.name).to eq('John Doe')
299
+ expect(result.phrase).to eq('John Doe')
300
+ expect(result.host).to eq('example.com')
301
+ expect(result.user).to eq('john..doe')
302
+ expect(result.original).to eq(line)
312
303
 
313
304
  line = 'John Doe <"john..doe"@example.com>' # enclosed with double quotes
314
- results = MailAddress.parse(line)
315
-
316
- expect(results[0].format).to eq('John Doe <"john..doe"@example.com>')
317
- expect(results[0].format(true)).to eq('John Doe <"john..doe"@example.com>')
318
- expect(results[0].address).to eq('"john..doe"@example.com')
319
- expect(results[0].name).to eq('John Doe')
320
- expect(results[0].phrase).to eq('John Doe')
321
- expect(results[0].host).to eq('example.com')
322
- expect(results[0].user).to eq('"john..doe"')
323
- expect(results[0].original).to eq(line)
305
+ result = MailAddress.parse_first(line)
306
+
307
+ expect(result.format).to eq('John Doe <"john..doe"@example.com>')
308
+ expect(result.format(true)).to eq('John Doe <"john..doe"@example.com>')
309
+ expect(result.address).to eq('"john..doe"@example.com')
310
+ expect(result.name).to eq('John Doe')
311
+ expect(result.phrase).to eq('John Doe')
312
+ expect(result.host).to eq('example.com')
313
+ expect(result.user).to eq('"john..doe"')
314
+ expect(result.original).to eq(line)
324
315
  end
325
316
 
326
317
  it "Unclosed double quotes" do
327
318
  line = '"john..doe@example.com'
328
- results = MailAddress.parse(line)
329
- expect(results[0].format).to eq('"john..doe@example.com')
330
- expect(results[0].format(true)).to eq('"john..doe@example.com')
331
- expect(results[0].address).to be_nil
332
- expect(results[0].name).to eq('john..doe@example.com') ## IRREGULAR PATTERN
333
- expect(results[0].phrase).to eq('"john..doe@example.com') ## IRREGULAR PATTERN
334
- expect(results[0].host).to be_nil
335
- expect(results[0].user).to eq("")
336
- expect(results[0].original).to eq(line)
319
+ result = MailAddress.parse_first(line)
320
+
321
+ expect(result.format).to eq('"john..doe@example.com')
322
+ expect(result.format(true)).to eq('"john..doe@example.com')
323
+ expect(result.address).to be_nil
324
+ expect(result.name).to eq('john..doe@example.com') ## IRREGULAR PATTERN
325
+ expect(result.phrase).to eq('"john..doe@example.com') ## IRREGULAR PATTERN
326
+ expect(result.host).to be_nil
327
+ expect(result.user).to eq("")
328
+ expect(result.original).to eq(line)
337
329
 
338
330
  line = 'john..doe"@example.com'
339
- results = MailAddress.parse(line)
340
- expect(results[0].format).to eq('john..doe"@example.com')
341
- expect(results[0].format(true)).to eq('john..doe"@example.com')
342
- expect(results[0].address).to be_nil
343
- expect(results[0].name).to eq('john..doe"@example.com') ## IRREGULAR PATTERN
344
- expect(results[0].phrase).to eq('john..doe"@example.com') ## IRREGULAR PATTERN
345
- expect(results[0].host).to be_nil
346
- expect(results[0].user).to eq("")
347
- expect(results[0].original).to eq(line)
331
+ result = MailAddress.parse_first(line)
332
+ expect(result.format).to eq('john..doe"@example.com')
333
+ expect(result.format(true)).to eq('john..doe"@example.com')
334
+ expect(result.address).to be_nil
335
+ expect(result.name).to eq('john..doe"@example.com') ## IRREGULAR PATTERN
336
+ expect(result.phrase).to eq('john..doe"@example.com') ## IRREGULAR PATTERN
337
+ expect(result.host).to be_nil
338
+ expect(result.user).to eq("")
339
+ expect(result.original).to eq(line)
348
340
 
349
341
  #
350
342
  # it takes about 1 minutes in v1.4.5
351
343
  #
352
344
  line = '"ooooooooooooooooo@docomo.ne.jp'
353
- results = MailAddress.parse(line)
354
- expect(results[0].format).to eq('"ooooooooooooooooo@docomo.ne.jp')
355
- expect(results[0].address).to be_nil
356
- expect(results[0].name).to eq('ooooooooooooooooo@docomo.ne.jp') ## IRREGULAR PATTERN
357
- expect(results[0].phrase).to eq('"ooooooooooooooooo@docomo.ne.jp') ## IRREGULAR PATTERN
358
- expect(results[0].host).to be_nil
359
- expect(results[0].user).to eq("")
360
- expect(results[0].original).to eq(line)
345
+ result = MailAddress.parse_first(line)
346
+ expect(result.format).to eq('"ooooooooooooooooo@docomo.ne.jp')
347
+ expect(result.address).to be_nil
348
+ expect(result.name).to eq('ooooooooooooooooo@docomo.ne.jp') ## IRREGULAR PATTERN
349
+ expect(result.phrase).to eq('"ooooooooooooooooo@docomo.ne.jp') ## IRREGULAR PATTERN
350
+ expect(result.host).to be_nil
351
+ expect(result.user).to eq("")
352
+ expect(result.original).to eq(line)
361
353
 
362
354
  end
363
355
 
364
356
  it "unparsable with mail gem (includes non-permitted char'[')" do
365
357
  line = "Ello [Do Not Reply] <do-not-reply@ello.co>"
366
- results = MailAddress.parse(line)
367
- expect(results[0].format).to eq('"Ello [Do Not Reply]" <do-not-reply@ello.co>')
368
- expect(results[0].address).to eq('do-not-reply@ello.co')
369
- expect(results[0].name).to eq('Ello')
370
- expect(results[0].phrase).to eq('Ello [Do Not Reply]')
371
- expect(results[0].host).to eq('ello.co')
372
- expect(results[0].user).to eq('do-not-reply')
373
- expect(results[0].original).to eq(line)
358
+ result = MailAddress.parse_first(line)
359
+ expect(result.format).to eq('"Ello [Do Not Reply]" <do-not-reply@ello.co>')
360
+ expect(result.address).to eq('do-not-reply@ello.co')
361
+ expect(result.name).to eq('Ello')
362
+ expect(result.phrase).to eq('Ello [Do Not Reply]')
363
+ expect(result.host).to eq('ello.co')
364
+ expect(result.user).to eq('do-not-reply')
365
+ expect(result.original).to eq(line)
374
366
 
375
367
  line = 'MM[天文雑学」編集部 mag2 0000290852 <mailmag@mag2.com>'
376
- results = MailAddress.parse(line)
377
- expect(results[0].format).to eq('"MM[天文雑学」編集部 mag2 0000290852" <mailmag@mag2.com>')
378
- expect(results[0].address).to eq('mailmag@mag2.com')
379
- expect(results[0].name).to eq('MM[天文雑学」編集部 mag2 0000290852')
380
- expect(results[0].phrase).to eq('MM[天文雑学」編集部 mag2 0000290852')
381
- expect(results[0].host).to eq('mag2.com')
382
- expect(results[0].user).to eq('mailmag')
383
- expect(results[0].original).to eq(line)
368
+ result = MailAddress.parse_first(line)
369
+ expect(result.format).to eq('"MM[天文雑学」編集部 mag2 0000290852" <mailmag@mag2.com>')
370
+ expect(result.address).to eq('mailmag@mag2.com')
371
+ expect(result.name).to eq('MM[天文雑学」編集部 mag2 0000290852')
372
+ expect(result.phrase).to eq('MM[天文雑学」編集部 mag2 0000290852')
373
+ expect(result.host).to eq('mag2.com')
374
+ expect(result.user).to eq('mailmag')
375
+ expect(result.original).to eq(line)
384
376
  end
385
377
 
386
378
  it "unparsable with mail gem (no whitespace before <)" do
387
379
  line = "大阪 太郎<osaka@example.jp>"
388
- results = MailAddress.parse(line)
389
- expect(results[0].format).to eq('"大阪 太郎" <osaka@example.jp>')
390
- expect(results[0].address).to eq('osaka@example.jp')
391
- expect(results[0].name).to eq('大阪 太郎')
392
- expect(results[0].phrase).to eq('大阪 太郎')
393
- expect(results[0].host).to eq('example.jp')
394
- expect(results[0].user).to eq('osaka')
395
- expect(results[0].original).to eq(line)
380
+ result = MailAddress.parse_first(line)
381
+ expect(result.format).to eq('"大阪 太郎" <osaka@example.jp>')
382
+ expect(result.address).to eq('osaka@example.jp')
383
+ expect(result.name).to eq('大阪 太郎')
384
+ expect(result.phrase).to eq('大阪 太郎')
385
+ expect(result.host).to eq('example.jp')
386
+ expect(result.user).to eq('osaka')
387
+ expect(result.original).to eq(line)
396
388
  end
397
389
 
398
390
  it "local part only(treated as invalid)" do
399
391
  # if local part only, do not treat as an email address
400
392
  line = "localpartonly"
401
- results = MailAddress.parse(line)
402
- expect(results[0].format).to eq('localpartonly')
403
- expect(results[0].address).to be_nil
404
- expect(results[0].name).to eq('localpartonly')
405
- expect(results[0].phrase).to eq('localpartonly')
406
- expect(results[0].host).to be_nil
407
- expect(results[0].user).to eq('')
408
- expect(results[0].original).to eq(line)
393
+ result = MailAddress.parse_first(line)
394
+ expect(result.format).to eq('localpartonly')
395
+ expect(result.address).to be_nil
396
+ expect(result.name).to eq('localpartonly')
397
+ expect(result.phrase).to eq('localpartonly')
398
+ expect(result.host).to be_nil
399
+ expect(result.user).to eq('')
400
+ expect(result.original).to eq(line)
409
401
  end
410
402
 
411
403
  it "includes invalid addresses only among valid addresses " do
@@ -446,14 +438,14 @@ describe MailAddress do
446
438
  ]
447
439
 
448
440
  array.each do |line|
449
- results = MailAddress.parse(line)
450
- expect(results[0].format).to eq(line.gsub(/[;,]/, ''))
451
- expect(results[0].address).to be_nil
452
- expect(results[0].name).to eq(line)
453
- expect(results[0].phrase).to eq(line)
454
- expect(results[0].host).to be_nil
455
- expect(results[0].user).to eq('')
456
- expect(results[0].original).to eq(line)
441
+ result = MailAddress.parse_first(line)
442
+ expect(result.format).to eq(line.gsub(/[;,]/, ''))
443
+ expect(result.address).to be_nil
444
+ expect(result.name).to eq(line)
445
+ expect(result.phrase).to eq(line)
446
+ expect(result.host).to be_nil
447
+ expect(result.user).to eq('')
448
+ expect(result.original).to eq(line)
457
449
  end
458
450
 
459
451
  array = [
@@ -462,14 +454,14 @@ describe MailAddress do
462
454
  ]
463
455
 
464
456
  array.each do |line|
465
- results = MailAddress.parse(line)
466
- expect(results[0].format).to eq(line.gsub(/[;,]/, ''))
467
- expect(results[0].address).to be_nil
468
- expect(results[0].name).to eq(line)
469
- expect(results[0].phrase).to eq(line)
470
- expect(results[0].host).to be_nil
471
- expect(results[0].user).to eq('')
472
- expect(results[0].original).to eq(line)
457
+ result = MailAddress.parse_first(line)
458
+ expect(result.format).to eq(line.gsub(/[;,]/, ''))
459
+ expect(result.address).to be_nil
460
+ expect(result.name).to eq(line)
461
+ expect(result.phrase).to eq(line)
462
+ expect(result.host).to be_nil
463
+ expect(result.user).to eq('')
464
+ expect(result.original).to eq(line)
473
465
  end
474
466
 
475
467
  # a seemingly valid address
@@ -486,14 +478,14 @@ describe MailAddress do
486
478
 
487
479
  it "specify mime-encoded address" do
488
480
  line = "=?ISO-2022-JP?B?GyRCQmc6ZRsoQiAbJEJCQE86GyhC?= <osaka@example.jp>"
489
- results = MailAddress.parse(line)
490
- expect(results[0].format).to eq('=?ISO-2022-JP?B?GyRCQmc6ZRsoQiAbJEJCQE86GyhC?= <osaka@example.jp>')
491
- expect(results[0].address).to eq('osaka@example.jp')
492
- expect(results[0].name).to be_nil
493
- expect(results[0].phrase).to eq('=?ISO-2022-JP?B?GyRCQmc6ZRsoQiAbJEJCQE86GyhC?=')
494
- expect(results[0].host).to eq('example.jp')
495
- expect(results[0].user).to eq('osaka')
496
- expect(results[0].original).to eq(line)
481
+ result = MailAddress.parse_first(line)
482
+ expect(result.format).to eq('=?ISO-2022-JP?B?GyRCQmc6ZRsoQiAbJEJCQE86GyhC?= <osaka@example.jp>')
483
+ expect(result.address).to eq('osaka@example.jp')
484
+ expect(result.name).to be_nil
485
+ expect(result.phrase).to eq('=?ISO-2022-JP?B?GyRCQmc6ZRsoQiAbJEJCQE86GyhC?=')
486
+ expect(result.host).to eq('example.jp')
487
+ expect(result.user).to eq('osaka')
488
+ expect(result.original).to eq(line)
497
489
  end
498
490
 
499
491
  it "obviously invalid address (has no '@')" do
@@ -506,15 +498,15 @@ describe MailAddress do
506
498
  ]
507
499
 
508
500
  array.each do |line|
509
- results = MailAddress.parse(line)
501
+ result = MailAddress.parse_first(line)
510
502
  line.gsub!(';', '')
511
- expect(results[0].format).to eq(line)
512
- expect(results[0].address).to be_nil
513
- expect(results[0].name).to eq(line.strip)
514
- expect(results[0].phrase).to eq(line)
515
- expect(results[0].host).to be_nil
516
- expect(results[0].user).to eq('')
517
- expect(results[0].original).to eq(line)
503
+ expect(result.format).to eq(line)
504
+ expect(result.address).to be_nil
505
+ expect(result.name).to eq(line.strip)
506
+ expect(result.phrase).to eq(line)
507
+ expect(result.host).to be_nil
508
+ expect(result.user).to eq('')
509
+ expect(result.original).to eq(line)
518
510
  end
519
511
  end
520
512
 
@@ -522,14 +514,14 @@ describe MailAddress do
522
514
  array = [',', ';', ',;', ',,', ';;;', '<;,>, <>']
523
515
 
524
516
  array.each do |line|
525
- results = MailAddress.parse(line)
526
- expect(results[0].format).to eq(line.gsub(/[;,]/, ''))
527
- expect(results[0].address).to be_nil
528
- expect(results[0].name).to eq(line.strip)
529
- expect(results[0].phrase).to eq(line)
530
- expect(results[0].host).to be_nil
531
- expect(results[0].user).to eq('')
532
- expect(results[0].original).to eq(line)
517
+ result = MailAddress.parse_first(line)
518
+ expect(result.format).to eq(line.gsub(/[;,]/, ''))
519
+ expect(result.address).to be_nil
520
+ expect(result.name).to eq(line.strip)
521
+ expect(result.phrase).to eq(line)
522
+ expect(result.host).to be_nil
523
+ expect(result.user).to eq('')
524
+ expect(result.original).to eq(line)
533
525
  end
534
526
  end
535
527
 
@@ -562,98 +554,98 @@ describe MailAddress do
562
554
  it "empty string or nil" do
563
555
  # empty string
564
556
  line = ''
565
- results = MailAddress.parse(line)
566
- expect(results[0].format).to eq('')
567
- expect(results[0].address).to be_nil
568
- expect(results[0].name).to be_nil
569
- expect(results[0].phrase).to eq('')
570
- expect(results[0].host).to be_nil
571
- expect(results[0].user).to eq('')
572
- expect(results[0].original).to eq(line)
557
+ result = MailAddress.parse_first(line)
558
+ expect(result.format).to eq('')
559
+ expect(result.address).to be_nil
560
+ expect(result.name).to be_nil
561
+ expect(result.phrase).to eq('')
562
+ expect(result.host).to be_nil
563
+ expect(result.user).to eq('')
564
+ expect(result.original).to eq(line)
573
565
  # nil
574
566
  line = nil
575
- results = MailAddress.parse(line)
576
- expect(results[0].format).to eq('')
577
- expect(results[0].address).to be_nil
578
- expect(results[0].name).to be_nil
579
- expect(results[0].phrase).to eq('')
580
- expect(results[0].host).to be_nil
581
- expect(results[0].user).to eq('')
582
- expect(results[0].original).to eq('') # Note that it returns empty string NOT nil
567
+ result = MailAddress.parse_first(line)
568
+ expect(result.format).to eq('')
569
+ expect(result.address).to be_nil
570
+ expect(result.name).to be_nil
571
+ expect(result.phrase).to eq('')
572
+ expect(result.host).to be_nil
573
+ expect(result.user).to eq('')
574
+ expect(result.original).to eq('') # Note that it returns empty string NOT nil
583
575
  end
584
576
 
585
577
  it "includes backslash" do
586
578
  line = '\"jjjjjjjjjjjj\" <john_doe@example.com>'
587
- results = MailAddress.parse(line)
588
- expect(results[0].format).to eq('jjjjjjjjjjjj <john_doe@example.com>')
589
- expect(results[0].address).to eq('john_doe@example.com')
590
- expect(results[0].name).to eq("jjjjjjjjjjjj")
591
- expect(results[0].phrase).to eq('jjjjjjjjjjjj')
592
- expect(results[0].host).to eq('example.com')
593
- expect(results[0].user).to eq('john_doe')
594
- expect(results[0].original).to eq('"jjjjjjjjjjjj" <john_doe@example.com>') # TO BE EXACT, NOT ORIGINAL.
579
+ result = MailAddress.parse_first(line)
580
+ expect(result.format).to eq('jjjjjjjjjjjj <john_doe@example.com>')
581
+ expect(result.address).to eq('john_doe@example.com')
582
+ expect(result.name).to eq("jjjjjjjjjjjj")
583
+ expect(result.phrase).to eq('jjjjjjjjjjjj')
584
+ expect(result.host).to eq('example.com')
585
+ expect(result.user).to eq('john_doe')
586
+ expect(result.original).to eq('"jjjjjjjjjjjj" <john_doe@example.com>') # TO BE EXACT, NOT ORIGINAL.
595
587
 
596
588
  line = '\"jjjjjjjjjjjj" <john_doe@example.com>'
597
- results = MailAddress.parse(line)
598
- expect(results[0].format).to eq('jjjjjjjjjjjj <john_doe@example.com>')
599
- expect(results[0].address).to eq('john_doe@example.com')
600
- expect(results[0].name).to eq("jjjjjjjjjjjj")
601
- expect(results[0].phrase).to eq('jjjjjjjjjjjj')
602
- expect(results[0].host).to eq('example.com')
603
- expect(results[0].user).to eq('john_doe')
604
- expect(results[0].original).to eq('"jjjjjjjjjjjj" <john_doe@example.com>') # TO BE EXACT, NOT ORIGINAL.
589
+ result = MailAddress.parse_first(line)
590
+ expect(result.format).to eq('jjjjjjjjjjjj <john_doe@example.com>')
591
+ expect(result.address).to eq('john_doe@example.com')
592
+ expect(result.name).to eq("jjjjjjjjjjjj")
593
+ expect(result.phrase).to eq('jjjjjjjjjjjj')
594
+ expect(result.host).to eq('example.com')
595
+ expect(result.user).to eq('john_doe')
596
+ expect(result.original).to eq('"jjjjjjjjjjjj" <john_doe@example.com>') # TO BE EXACT, NOT ORIGINAL.
605
597
 
606
598
  line = '"jjjjjjjjjjjj\" <john_doe@example.com>'
607
- results = MailAddress.parse(line)
608
- expect(results[0].format).to eq('jjjjjjjjjjjj <john_doe@example.com>')
609
- expect(results[0].address).to eq('john_doe@example.com')
610
- expect(results[0].name).to eq("jjjjjjjjjjjj")
611
- expect(results[0].phrase).to eq('jjjjjjjjjjjj')
612
- expect(results[0].host).to eq('example.com')
613
- expect(results[0].user).to eq('john_doe')
614
- expect(results[0].original).to eq('"jjjjjjjjjjjj" <john_doe@example.com>') # TO BE EXACT, NOT ORIGINAL.
599
+ result = MailAddress.parse_first(line)
600
+ expect(result.format).to eq('jjjjjjjjjjjj <john_doe@example.com>')
601
+ expect(result.address).to eq('john_doe@example.com')
602
+ expect(result.name).to eq("jjjjjjjjjjjj")
603
+ expect(result.phrase).to eq('jjjjjjjjjjjj')
604
+ expect(result.host).to eq('example.com')
605
+ expect(result.user).to eq('john_doe')
606
+ expect(result.original).to eq('"jjjjjjjjjjjj" <john_doe@example.com>') # TO BE EXACT, NOT ORIGINAL.
615
607
  end
616
608
 
617
609
  it "suppress too much extraction" do
618
610
  line = 'john_doe@example.com'
619
- results = MailAddress.parse(line)
620
- expect(results[0].format).to eq('john_doe@example.com')
621
- expect(results[0].address).to eq('john_doe@example.com')
622
- expect(results[0].name).to be_nil
623
- expect(results[0].phrase).to eq('')
624
- expect(results[0].host).to eq('example.com')
625
- expect(results[0].user).to eq('john_doe')
626
- expect(results[0].original).to eq(line)
611
+ result = MailAddress.parse_first(line)
612
+ expect(result.format).to eq('john_doe@example.com')
613
+ expect(result.address).to eq('john_doe@example.com')
614
+ expect(result.name).to be_nil
615
+ expect(result.phrase).to eq('')
616
+ expect(result.host).to eq('example.com')
617
+ expect(result.user).to eq('john_doe')
618
+ expect(result.original).to eq(line)
627
619
 
628
620
  line = 'john.doe@example.com'
629
- results = MailAddress.parse(line)
630
- expect(results[0].format).to eq('john.doe@example.com')
631
- expect(results[0].address).to eq('john.doe@example.com')
632
- expect(results[0].name).to be_nil
633
- expect(results[0].phrase).to eq('')
634
- expect(results[0].host).to eq('example.com')
635
- expect(results[0].user).to eq('john.doe')
636
- expect(results[0].original).to eq(line)
621
+ result = MailAddress.parse_first(line)
622
+ expect(result.format).to eq('john.doe@example.com')
623
+ expect(result.address).to eq('john.doe@example.com')
624
+ expect(result.name).to be_nil
625
+ expect(result.phrase).to eq('')
626
+ expect(result.host).to eq('example.com')
627
+ expect(result.user).to eq('john.doe')
628
+ expect(result.original).to eq(line)
637
629
  end
638
630
 
639
631
  it "corrupted address" do
640
632
  line = 'john <john@example.com' # lack of right angle bracket
641
- results = MailAddress.parse(line)
642
- expect(results[0].format).to eq('john <john@example.com')
643
- expect(results[0].address).to be_nil
644
- expect(results[0].name).to eq('john <john@example.com')
645
- expect(results[0].phrase).to eq('john <john@example.com')
646
- expect(results[0].host).to be_nil
647
- expect(results[0].user).to eq('')
648
- expect(results[0].original).to eq(line)
633
+ result = MailAddress.parse_first(line)
634
+ expect(result.format).to eq('john <john@example.com')
635
+ expect(result.address).to be_nil
636
+ expect(result.name).to eq('john <john@example.com')
637
+ expect(result.phrase).to eq('john <john@example.com')
638
+ expect(result.host).to be_nil
639
+ expect(result.user).to eq('')
640
+ expect(result.original).to eq(line)
649
641
 
650
642
  line = 'john <john@example.com> (last' # lack of right parenthesis
651
- results = MailAddress.parse(line)
652
- expect(results[0].original).to eq(line)
643
+ result = MailAddress.parse_first(line)
644
+ expect(result.original).to eq(line)
653
645
 
654
646
  line = 'john <john@example.com> (ああ いい）' # right paren is a full-width char
655
- results = MailAddress.parse(line)
656
- expect(results[0].original).to eq(line)
647
+ result = MailAddress.parse_first(line)
648
+ expect(result.original).to eq(line)
657
649
 
658
650
  line = 'john <john@example.com> (last, Mary <mary@example.com>' # lack of right parenthesis
659
651
  results = MailAddress.parse(line)
@@ -663,15 +655,15 @@ describe MailAddress do
663
655
 
664
656
  it "unbelievable but existed address" do
665
657
  line = 'Sf 山田 太郎@example.com, valid@example.com'
666
- results = MailAddress.parse(line)
667
- expect(results[0].format).to eq('Sf 山田 太郎@example.com')
668
- expect(results[0].address).not_to eq("Sf@example.com") ## important!
669
- expect(results[0].address).to be_nil ## important!
670
- expect(results[0].name).to eq('Sf 山田 太郎@example.com') ## I don't care whatever returns
671
- expect(results[0].phrase).to eq('Sf 山田 太郎@example.com') ## I don't care whatever returns
672
- expect(results[0].host).to be_nil
673
- expect(results[0].user).to eq('')
674
- expect(results[0].original).to eq('Sf 山田 太郎@example.com')
658
+ result = MailAddress.parse_first(line)
659
+ expect(result.format).to eq('Sf 山田 太郎@example.com')
660
+ expect(result.address).not_to eq("Sf@example.com") ## important!
661
+ expect(result.address).to be_nil ## important!
662
+ expect(result.name).to eq('Sf 山田 太郎@example.com') ## I don't care whatever returns
663
+ expect(result.phrase).to eq('Sf 山田 太郎@example.com') ## I don't care whatever returns
664
+ expect(result.host).to be_nil
665
+ expect(result.user).to eq('')
666
+ expect(result.original).to eq('Sf 山田 太郎@example.com')
675
667
  end
676
668
 
677
669
  it 'Perl Module TAP test data' do
@@ -817,7 +809,7 @@ describe MailAddress do
817
809
  exp_format = d[1]
818
810
  exp_name = d[2]
819
811
  # p "#{i} #{test_src}"
820
- result = MailAddress.parse(test_src)[0]
812
+ result = MailAddress.parse_first(test_src)
821
813
 
822
814
  result_format = result.format || ''
823
815
  result_name = result.name || ''
data/spec/simple_parser_spec.rb CHANGED
@@ -11,7 +11,7 @@ require 'pp'
11
11
  describe MailAddress do
12
12
 
13
13
  def assert_parsed_list(input, expected_list, opt_message = nil)
14
- result = MailAddress.parse_simple input
14
+ result = MailAddress.g_parse input
15
15
  expect(result.size).to eq(expected_list.size)
16
16
  expected_list.each_with_index do |expected, index|
17
17
  expect(result[index].address).to eq(expected)
data/spec/spec_helper.rb CHANGED
@@ -2,14 +2,13 @@ require 'simplecov'
2
2
  require 'coveralls'
3
3
  Coveralls.wear!
4
4
 
5
- SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
5
+ SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
6
6
  SimpleCov::Formatter::HTMLFormatter,
7
7
  Coveralls::SimpleCov::Formatter
8
- ]
8
+ ])
9
9
  SimpleCov.start do
10
10
  add_filter '.bundle/'
11
11
  end
12
12
 
13
13
  require 'rubygems'
14
14
  require 'mail_address'
15
-
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: mail_address
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.2.14
4
+ version: 1.2.15
5
5
  platform: ruby
6
6
  authors:
7
7
  - Kizashi Nagata
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2017-04-24 00:00:00.000000000 Z
11
+ date: 2019-09-17 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: bundler
@@ -117,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
117
117
  version: '0'
118
118
  requirements: []
119
119
  rubyforge_project:
120
- rubygems_version: 2.5.1
120
+ rubygems_version: 2.5.2
121
121
  signing_key:
122
122
  specification_version: 4
123
123
  summary: Simple Mail Address Parser