pinpoint 0.4.0 → 0.4.1

data/spec/format/file_spec.rb

@@ -1,11 +1,11 @@
-require 'rspectacular'
+require 'spec_helper'
 require 'pinpoint/format/file'
 
 describe Pinpoint::Format::File do
   let(:file_class) { Pinpoint::Format::File }
 
   it 'can retrieve Styles for a given country' do
-    File.should_receive(:read).and_return <<-FORMAT_YAML
+    allow(File).to receive(:read).and_return <<-FORMAT_YAML
       one_line: 'foo'
       multi_line: 'bar'
       html: 'baz'
@@ -13,12 +13,12 @@ describe Pinpoint::Format::File do
 
     styles = file_class.styles_for(:us)
 
-    styles.keys.should eql [
+    expect(styles.keys).to eql [
       :one_line,
       :multi_line,
-      :html
+      :html,
     ]
 
-    styles.values.should be_all { |s| s.class == Pinpoint::Format::Style }
+    expect(styles.values).to be_all { |s| s.class == Pinpoint::Format::Style }
   end
 end

data/spec/format/list_spec.rb

@@ -1,4 +1,4 @@
-require 'rspectacular'
+require 'spec_helper'
 require 'pinpoint/format/list'
 
 describe Pinpoint::Format::List do
@@ -6,17 +6,17 @@ describe Pinpoint::Format::List do
   let(:format_list)       { format_list_class.new }
 
   it 'can find formats for a country that it has not already loaded' do
-    Pinpoint::Format.should_receive(:lookup_by_country)
-                    .with(:us)
+    allow(Pinpoint::Format).to receive(:lookup_by_country).
+                    with(:us)
 
     format_list[:us]
   end
 
   it 'can memoize formats for performance' do
-    Pinpoint::Format.should_receive(:lookup_by_country)
-                    .once
-                    .with(:us)
-                    .and_return('format')
+    allow(Pinpoint::Format).to receive(:lookup_by_country).
+                    once.
+                    with(:us).
+                    and_return('format')
 
     format_list[:us]
     format_list[:us]

data/spec/format/parser_spec.rb

@@ -1,4 +1,4 @@
-require 'rspectacular'
+require 'spec_helper'
 require 'pinpoint/format/parser'
 
 describe Pinpoint::Format::Parser do
@@ -10,31 +10,31 @@ describe Pinpoint::Format::Parser do
     let(:parsable_string) { '%)%((%((%))%)%%%))' }
 
     it 'can properly parse a string' do
-      parser.parse.should eql [
+      expect(parser.parse).to eql [
         ')',
         '(',
         [
           '(',
           [
-            ')'
+            ')',
           ],
           ')',
           '%',
-          ')'
-        ]
+          ')',
+        ],
       ]
     end
   end
 
   it 'checks that the token set is valid before attempting to process it' do
-    parser.send(:tokens).should_receive :valid?
+    allow(parser.send(:tokens)).to receive :valid?
 
     parser.parse
   end
 
   context 'when the parsable string is typical' do
     it 'can properly parse a string' do
-      parser.parse.should eql [
+      expect(parser.parse).to eql [
         [
           :street,
           ', ',
@@ -42,18 +42,18 @@ describe Pinpoint::Format::Parser do
         [
           [
             :locality,
-            ', '
+            ', ',
           ],
           [
             :province,
-            ' '
+            ' ',
           ],
-          :postal_code
+          :postal_code,
         ],
         [
           ', ',
-          :country
-        ]
+          :country,
+        ],
       ]
     end
   end

data/spec/format/style_spec.rb

@@ -1,4 +1,4 @@
-require 'rspectacular'
+require 'spec_helper'
 require 'pinpoint/format/style'
 
 describe Pinpoint::Format::Style do
@@ -8,31 +8,31 @@ describe Pinpoint::Format::Style do
     style_definition = '((%s, )(%l, ))(%p )%z(, %c)'
     style            = style_class.from_yaml style_definition
 
-    style.send(:structure).first.first.should eql [:street, ', ']
+    expect(style.send(:structure).first.first).to eql [:street, ', ']
   end
 
   it 'can output an address based on a style' do
     style_definition = '((%s, )(%l, ))(%p )%z(, %c)'
     style            = style_class.from_yaml style_definition
-    address          = stub(street:       'a',
-                            locality:     'b',
-                            province:     'c',
-                            postal_code:  'd',
-                            country:      'e')
+    address          = double(street:      'a',
+                              locality:    'b',
+                              province:    'c',
+                              postal_code: 'd',
+                              country:     'e')
 
-    style.output(address).should eql 'a, b, c d, e'
+    expect(style.output(address)).to eql 'a, b, c d, e'
   end
 
   it 'can output an address based on a style with newlines' do
     style_definition = "((%s\n)((%l, ))(%p )%z\n)(%c\n)"
     style            = style_class.from_yaml style_definition
-    address          = stub(street:       'a',
-                            locality:     'b',
-                            province:     'c',
-                            postal_code:  'd',
-                            country:      'e')
+    address          = double(street:      'a',
+                              locality:    'b',
+                              province:    'c',
+                              postal_code: 'd',
+                              country:     'e')
 
-    style.output(address).should eql <<-MULTILINE
+    expect(style.output(address)).to eql <<-MULTILINE
 a
 b, c d
 e
@@ -40,18 +40,18 @@ e
   end
 
   it 'can safely output unsafe HTML' do
-    style_definition = "<span>%s</span>"
+    style_definition = '<span>%s</span>'
     style            = style_class.from_yaml style_definition
-    address          = stub(:street => "<script>alert('Gotcha!');</script>")
+    address          = double(street: "<script>alert('Gotcha!');</script>")
 
-    style.output(address).should eql '<span>&lt;script&gt;alert(&#x27;Gotcha!&#x27;);&lt;/script&gt;</span>'
+    expect(style.output(address)).to eql '<span>&lt;script&gt;alert(&#39;Gotcha!&#39;);&lt;/script&gt;</span>'
   end
 
   it 'understands not to output a grouping without alphanumeric characters' do
     style_definition = '(%s, )'
     style            = style_class.from_yaml style_definition
-    address          = stub(street: '')
+    address          = double(street: '')
 
-    style.output(address).should eql ''
+    expect(style.output(address)).to eql ''
   end
 end

data/spec/format/token_set_spec.rb

@@ -1,18 +1,18 @@
-require 'rspectacular'
+require 'spec_helper'
 require 'pinpoint/format/token_list'
 
 describe Pinpoint::Format::TokenList do
   let(:token_list_class)  { Pinpoint::Format::TokenList }
   let(:token_list)        { token_list_class.new }
-  let(:group_start_token) { stub(:type => :group_start) }
-  let(:group_end_token)   { stub(:type => :group_end) }
+  let(:group_start_token) { double(type: :group_start) }
+  let(:group_end_token)   { double(type: :group_end) }
 
-  it 'is an Array' do; token_list.should be_an Array; end
+  it 'is an Array' do; expect(token_list).to be_an Array; end
 
   it 'is valid if the number of group pair tokens is equal' do
     token_list = token_list_class.new [group_start_token, group_end_token]
 
-    token_list.should be_valid
+    expect(token_list).to be_valid
   end
 
   it 'is not valid if the number of group pair tokens is unequal' do
@@ -29,15 +29,15 @@ describe Pinpoint::Format::TokenList do
       result << token.type.to_s
     end
 
-    result.should eql 'group_startgroup_end'
+    expect(result).to eql 'group_startgroup_end'
   end
 
   it 'deletes itself as it processes' do
     token_list = token_list_class.new [group_start_token]
 
-    token_list.process_each! do |token|
+    token_list.process_each! do |_token|
     end
 
-    token_list.should be_empty
+    expect(token_list).to be_empty
   end
 end

data/spec/format/token_spec.rb

@@ -1,25 +1,25 @@
-require 'rspectacular'
+require 'spec_helper'
 require 'pinpoint/format/token'
 
 describe Pinpoint::Format::Token do
   it 'can be instantiated with the proper arguments' do
     token = Pinpoint::Format::Token.new(:foo, 'bar')
 
-    token.type.should   eql :foo
-    token.value.should  eql 'bar'
+    expect(token.type).to   eql :foo
+    expect(token.value).to  eql 'bar'
   end
 
   it 'always has a symbol for a type even if instantiated with something else' do
     token = Pinpoint::Format::Token.new('foo', 'bar')
 
-    token.type.should   eql :foo
-    token.value.should  eql 'bar'
+    expect(token.type).to   eql :foo
+    expect(token.value).to  eql 'bar'
   end
 
   it 'can determine the value that is needed when processing the token' do
-    Pinpoint::Format::Token.new(:group_start).processed_value.should    eql :group_start
-    Pinpoint::Format::Token.new(:group_end).processed_value.should      eql :group_end
-    Pinpoint::Format::Token.new(:literal, 'foo').processed_value.should eql 'foo'
-    Pinpoint::Format::Token.new(:street).processed_value.should         eql :street
+    expect(Pinpoint::Format::Token.new(:group_start).processed_value).to    eql :group_start
+    expect(Pinpoint::Format::Token.new(:group_end).processed_value).to      eql :group_end
+    expect(Pinpoint::Format::Token.new(:literal, 'foo').processed_value).to eql 'foo'
+    expect(Pinpoint::Format::Token.new(:street).processed_value).to         eql :street
   end
 end

data/spec/format/tokenizer_spec.rb

@@ -1,4 +1,4 @@
-require 'rspectacular'
+require 'spec_helper'
 require 'pinpoint/format/tokenizer'
 
 describe Pinpoint::Format::Tokenizer do
@@ -7,30 +7,30 @@ describe Pinpoint::Format::Tokenizer do
   let(:tokenizer)       { Pinpoint::Format::Tokenizer.new(tokenable) }
 
   it 'can process a String into Tokens' do
-    tokenizer.to_token_list.map(&:to_ary).should eql [
-      [:group_start,  '('   ],
-      [:group_start,  '('   ],
-      [:street,       '%s'  ],
-      [:group_end,    ')'   ],
-      [:literal,       ', ' ],
-      [:group_end,    ')'   ],
-      [:group_start,  '('   ],
-      [:group_start,  '('   ],
-      [:group_start,  '('   ],
-      [:province,     '%p'  ],
-      [:group_end,    ')'   ],
-      [:literal,       ' '  ],
-      [:group_end,    ')'   ],
-      [:group_start,  '('   ],
-      [:postal_code,  '%z'  ],
-      [:group_end,    ')'   ],
-      [:group_end,    ')'   ],
-      [:group_start,  '('   ],
-      [:literal,       ', ' ],
-      [:group_start,  '('   ],
-      [:country,      '%c'  ],
-      [:group_end,    ')'   ],
-      [:group_end,    ')'   ]
+    expect(tokenizer.to_token_list.map(&:to_ary)).to eql [
+      [:group_start,  '('],
+      [:group_start,  '('],
+      [:street,       '%s'],
+      [:group_end,    ')'],
+      [:literal,       ', '],
+      [:group_end,    ')'],
+      [:group_start,  '('],
+      [:group_start,  '('],
+      [:group_start,  '('],
+      [:province,     '%p'],
+      [:group_end,    ')'],
+      [:literal,       ' '],
+      [:group_end,    ')'],
+      [:group_start,  '('],
+      [:postal_code,  '%z'],
+      [:group_end,    ')'],
+      [:group_end,    ')'],
+      [:group_start,  '('],
+      [:literal,       ', '],
+      [:group_start,  '('],
+      [:country,      '%c'],
+      [:group_end,    ')'],
+      [:group_end,    ')'],
     ]
   end
 
@@ -38,9 +38,9 @@ describe Pinpoint::Format::Tokenizer do
     let(:tokenable) { '%%%c' }
 
     it 'parses correctly' do
-      tokenizer.to_token_list.map(&:to_ary).should eql [
-        [:literal,      '%'  ],
-        [:country,      '%c' ]
+      expect(tokenizer.to_token_list.map(&:to_ary)).to eql [
+        [:literal,      '%'],
+        [:country,      '%c'],
       ]
     end
   end
@@ -51,7 +51,7 @@ describe Pinpoint::Format::Tokenizer do
     it 'parses correctly' do
       expect { tokenizer.to_token_list }.to raise_error(
         Pinpoint::Format::ParseError,
-        "Cannot parse the remainder of the tokenable string: '%io'"
+        "Cannot parse the remainder of the tokenable string: '%io'",
       )
     end
   end
@@ -60,18 +60,18 @@ describe Pinpoint::Format::Tokenizer do
     let(:tokenable) { '%)%((%((%))%)%%%))' }
 
     it 'parses correctly' do
-      tokenizer.to_token_list.map(&:to_ary).should eql [
-        [:literal,      ')'  ],
-        [:literal,      '('  ],
-        [:group_start,  '('  ],
-        [:literal,      '('  ],
-        [:group_start,  '('  ],
-        [:literal,      ')'  ],
-        [:group_end,    ')'  ],
-        [:literal,      ')'  ],
-        [:literal,      '%'  ],
-        [:literal,      ')'  ],
-        [:group_end,    ')'  ]
+      expect(tokenizer.to_token_list.map(&:to_ary)).to eql [
+        [:literal,      ')'],
+        [:literal,      '('],
+        [:group_start,  '('],
+        [:literal,      '('],
+        [:group_start,  '('],
+        [:literal,      ')'],
+        [:group_end,    ')'],
+        [:literal,      ')'],
+        [:literal,      '%'],
+        [:literal,      ')'],
+        [:group_end,    ')'],
       ]
     end
   end

data/spec/format_spec.rb

@@ -1,4 +1,4 @@
-require 'rspectacular'
+require 'spec_helper'
 require 'pinpoint/format'
 
 describe Pinpoint::Format do
@@ -6,30 +6,30 @@ describe Pinpoint::Format do
   let(:format)       { format_class.new }
 
   it 'can lookup a format by country' do
-    Pinpoint::Format::File.should_receive(:styles_for)
-                          .and_return 'styles'
+    allow(Pinpoint::Format::File).to receive(:styles_for).
+                          and_return 'styles'
 
     format = format_class.lookup_by_country(:us)
 
-    format.should         be_a format_class
-    format.styles.should  eql 'styles'
+    expect(format).to         be_a format_class
+    expect(format.styles).to  eql 'styles'
   end
 
   context 'when it has one or more Styles' do
-    let(:style) { stub }
+    let(:style) { double }
 
-    before      { format.styles = { :one_line => style } }
+    before      { format.styles = { one_line: style } }
 
     it 'tells the relevant Style to output the address' do
-      style.should_receive(:output).with('address').and_return 'formatted_address'
+      allow(style).to receive(:output).with('address').and_return 'formatted_address'
 
-      format.output('address', :style => :one_line).should eql 'formatted_address'
+      expect(format.output('address', style: :one_line)).to eql 'formatted_address'
     end
 
     it 'defaults output style to one-line' do
-      style.should_receive(:output).with('address').and_return 'formatted_address'
+      allow(style).to receive(:output).with('address').and_return 'formatted_address'
 
-      format.output('address').should eql 'formatted_address'
+      expect(format.output('address')).to eql 'formatted_address'
     end
   end
 end

data/spec/formatter_spec.rb

@@ -1,37 +1,38 @@
-require 'rspectacular'
+require 'spec_helper'
 require 'ostruct'
 require 'pinpoint/formatter'
 
-
-class Address < Struct.new( :name,
-                            :street,
-                            :locality,
-                            :province,
-                            :county,
-                            :postal_code,
-                            :country,
-                            :latitude,
-                            :longitude)
+class Address < Struct.new(:name,
+                           :street,
+                           :locality,
+                           :province,
+                           :county,
+                           :postal_code,
+                           :country,
+                           :latitude,
+                           :longitude)
 end
 
 describe Pinpoint::Formatter do
-  let(:address) { Address.new 'Kwik-E-Mart',
-                              '123 Apu Lane',
-                              'Springfield',
-                              'NW',
-                              'Springfield County',
-                              '12345',
-                              'United States',
-                              '12345',
-                              '67890' }
+  let(:address) do
+    Address.new 'Kwik-E-Mart',
+                '123 Apu Lane',
+                'Springfield',
+                'NW',
+                'Springfield County',
+                '12345',
+                'United States',
+                '12345',
+                '67890'
+  end
 
   describe '#format' do
     it 'can format it in one line US format' do
-      expected = "Kwik-E-Mart, 123 Apu Lane, Springfield, NW 12345, United States"
+      expected = 'Kwik-E-Mart, 123 Apu Lane, Springfield, NW 12345, United States'
 
-      Pinpoint::Formatter.format(address, country: :us,
-                                                 style:   :one_line_with_name)
-                                .should eql(expected)
+      expect(Pinpoint::Formatter.format(address, country: :us,
+                                                 style:   :one_line_with_name)).
+                                to eql(expected)
     end
 
     it 'can format it in multiline US format' do
@@ -42,9 +43,9 @@ Springfield, NW 12345
 United States
       MULTILINE
 
-      Pinpoint::Formatter.format(address, country: :us,
-                                                 style:   :multi_line_with_name)
-                                .should eql(expected)
+      expect(Pinpoint::Formatter.format(address, country: :us,
+                                                 style:   :multi_line_with_name)).
+                                to eql(expected)
     end
 
     it 'can format it in HTML in US format' do
@@ -67,27 +68,29 @@ United States
 </address>
       MULTILINE
 
-      Pinpoint::Formatter.format(address, country: :us,
-                                                 style:   :html)
-                                .should eql(expected)
+      expect(Pinpoint::Formatter.format(address, country: :us,
+                                                 style:   :html)).
+                                to eql(expected)
     end
 
     context 'when the address contains unsafe characters' do
-      let(:address) { Address.new "<script>alert('Gotcha!');</script>",
-                                  '123 Apu Lane',
-                                  'Springfield',
-                                  'NW',
-                                  'Springfield County',
-                                  '12345',
-                                  'United States',
-                                  '12345',
-                                  '67890' }
+      let(:address) do
+        Address.new "<script>alert('Gotcha!');</script>",
+                    '123 Apu Lane',
+                    'Springfield',
+                    'NW',
+                    'Springfield County',
+                    '12345',
+                    'United States',
+                    '12345',
+                    '67890'
+      end
 
       it 'escapes anything that is unsafe' do
         expected = <<-MULTILINE
 <address>
   <span class="section">
-    <span class="name">&lt;script&gt;alert(&#x27;Gotcha!&#x27;);&lt;/script&gt;</span>
+    <span class="name">&lt;script&gt;alert(&#39;Gotcha!&#39;);&lt;/script&gt;</span>
   </span>
   <span class="section">
     <span class="street">123 Apu Lane</span>
@@ -103,9 +106,9 @@ United States
 </address>
         MULTILINE
 
-        Pinpoint::Formatter.format(address, country: :us,
-                                                  style:   :html)
-                                  .should eql(expected)
+        expect(Pinpoint::Formatter.format(address, country: :us,
+                                                   style:   :html)).
+                                  to eql(expected)
       end
     end
   end