pinpoint 0.0.3 → 0.1.0

data/lib/pinpoint/version.rb

@@ -1,3 +1,3 @@
 module Pinpoint
-  VERSION = '0.0.3'
+  VERSION = '0.1.0'
 end

data/spec/address_spec.rb

@@ -1,4 +1,5 @@
-require 'spec_helper'
+require 'rspectacular'
+require 'pinpoint/address'
 
 describe 'Pinpoint::Address' do
   let(:address) { Pinpoint::Address.new }
@@ -7,6 +8,8 @@ describe 'Pinpoint::Address' do
   it { address.respond_to?(:region=).should       be_true }
   it { address.respond_to?(:province).should      be_true }
   it { address.respond_to?(:province=).should     be_true }
+  it { address.respond_to?(:locality).should      be_true }
+  it { address.respond_to?(:locality=).should     be_true }
   it { address.respond_to?(:postal_code).should   be_true }
   it { address.respond_to?(:postal_code=).should  be_true }
   it { address.respond_to?(:postalcode).should    be_true }

data/spec/format/file_spec.rb

@@ -0,0 +1,24 @@
+require 'rspectacular'
+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
+      one_line: 'foo'
+      multi_line: 'bar'
+      html: 'baz'
+    FORMAT_YAML
+
+    styles = file_class.styles_for(:us)
+
+    styles.keys.should eql [
+      :one_line,
+      :multi_line,
+      :html
+    ]
+
+    styles.values.should be_all { |s| s.class == Pinpoint::Format::Style }
+  end
+end

data/spec/format/list_spec.rb

@@ -0,0 +1,24 @@
+require 'rspectacular'
+require 'pinpoint/format/list'
+
+describe Pinpoint::Format::List do
+  let(:format_list_class) { Pinpoint::Format::List }
+  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)
+
+    format_list[:us]
+  end
+
+  it 'can memoize formats for performance' do
+    Pinpoint::Format.should_receive(:lookup_by_country)
+                    .once
+                    .with(:us)
+                    .and_return('format')
+
+    format_list[:us]
+    format_list[:us]
+  end
+end

data/spec/format/parser_spec.rb

@@ -0,0 +1,60 @@
+require 'rspectacular'
+require 'pinpoint/format/parser'
+
+describe Pinpoint::Format::Parser do
+  let(:parser_class)    { Pinpoint::Format::Parser }
+  let(:parsable_string) { '(%s, )((%l, )(%p )%z)(, %c)' }
+  let(:parser)          { parser_class.new(parsable_string) }
+
+  context 'when the parsable string contains literal parenthesis' do
+    let(:parsable_string) { '%)%((%((%))%)%%%))' }
+
+    it 'can properly parse a string' do
+      parser.parse.should eql [
+        ')',
+        '(',
+        [
+          '(',
+          [
+            ')'
+          ],
+          ')',
+          '%',
+          ')'
+        ]
+      ]
+    end
+  end
+
+  it 'checks that the token set is valid before attempting to process it' do
+    parser.send(:tokens).should_receive :valid?
+
+    parser.parse
+  end
+
+  context 'when the parsable string is typical' do
+    it 'can properly parse a string' do
+      parser.parse.should eql [
+        [
+          :street,
+          ', ',
+        ],
+        [
+          [
+            :locality,
+            ', '
+          ],
+          [
+            :province,
+            ' '
+          ],
+          :postal_code
+        ],
+        [
+          ', ',
+          :country
+        ]
+      ]
+    end
+  end
+end

data/spec/format/style_spec.rb

@@ -0,0 +1,57 @@
+require 'rspectacular'
+require 'pinpoint/format/style'
+
+describe Pinpoint::Format::Style do
+  let(:style_class) { Pinpoint::Format::Style }
+
+  it 'can instantiate itself based on a style definition' do
+    style_definition = '((%s, )(%l, ))(%p )%z(, %c)'
+    style            = style_class.from_yaml style_definition
+
+    style.send(:structure).first.first.should 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')
+
+    style.output(address).should 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')
+
+    style.output(address).should eql <<-MULTILINE
+a
+b, c d
+e
+    MULTILINE
+  end
+
+  it 'can safely output unsafe HTML' do
+    style_definition = "<span>%s</span>"
+    style            = style_class.from_yaml style_definition
+    address          = stub(:street => "<script>alert('Gotcha!');</script>")
+
+    style.output(address).should eql '<span>&lt;script&gt;alert(&#x27;Gotcha!&#x27;);&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: '')
+
+    style.output(address).should eql ''
+  end
+end

data/spec/format/token_set_spec.rb

@@ -0,0 +1,43 @@
+require 'rspectacular'
+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) }
+
+  it 'is an Array' do; token_list.should 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
+  end
+
+  it 'is not valid if the number of group pair tokens is unequal' do
+    token_list = token_list_class.new [group_start_token]
+
+    expect { token_list.valid? }.to raise_error Pinpoint::Format::UnevenNestingError
+  end
+
+  it 'yields each token to the block when processing' do
+    result     = ''
+    token_list = token_list_class.new [group_start_token, group_end_token]
+
+    token_list.process_each! do |token|
+      result << token.type.to_s
+    end
+
+    result.should 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|
+    end
+
+    token_list.should be_empty
+  end
+end

data/spec/format/token_spec.rb

@@ -0,0 +1,25 @@
+require 'rspectacular'
+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'
+  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'
+  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
+  end
+end

data/spec/format/tokenizer_spec.rb

@@ -0,0 +1,78 @@
+require 'rspectacular'
+require 'pinpoint/format/tokenizer'
+
+describe Pinpoint::Format::Tokenizer do
+  let(:tokenizer_class) { Pinpoint::Format::Tokenizer }
+  let(:tokenable)       { '((%s), )(((%p) )(%z))(, (%c))' }
+  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,    ')'   ]
+    ]
+  end
+
+  context 'when the String passed contains literal percent sign tokens' do
+    let(:tokenable) { '%%%c' }
+
+    it 'parses correctly' do
+      tokenizer.to_token_list.map(&:to_ary).should eql [
+        [:literal,      '%'  ],
+        [:country,      '%c' ]
+      ]
+    end
+  end
+
+  context 'when the String passed contains an improper syntax' do
+    let(:tokenable) { '%%%c%io' }
+
+    it 'parses correctly' do
+      expect { tokenizer.to_token_list }.to raise_error(
+        Pinpoint::Format::ParseError,
+        "Cannot parse the remainder of the tokenable string: '%io'"
+      )
+    end
+  end
+
+  context 'when the String passed contains complex grouping and parenthesis literals' 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,    ')'  ]
+      ]
+    end
+  end
+end

data/spec/format_spec.rb

@@ -0,0 +1,35 @@
+require 'rspectacular'
+require 'pinpoint/format'
+
+describe Pinpoint::Format do
+  let(:format_class) { Pinpoint::Format }
+  let(:format)       { format_class.new }
+
+  it 'can lookup a format by country' do
+    Pinpoint::Format::File.should_receive(:styles_for)
+                          .and_return 'styles'
+
+    format = format_class.lookup_by_country(:us)
+
+    format.should         be_a format_class
+    format.styles.should  eql 'styles'
+  end
+
+  context 'when it has one or more Styles' do
+    let(:style) { stub }
+
+    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'
+
+      format.output('address', :style => :one_line).should eql 'formatted_address'
+    end
+
+    it 'defaults output style to one-line' do
+      style.should_receive(:output).with('address').and_return 'formatted_address'
+
+      format.output('address').should eql 'formatted_address'
+    end
+  end
+end

data/spec/formatter_spec.rb

@@ -0,0 +1,112 @@
+require 'rspectacular'
+require 'ostruct'
+require 'pinpoint/formatter'
+
+
+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' }
+
+  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"
+
+      Pinpoint::Formatter.format(address, country: :us,
+                                                 style:   :one_line_with_name)
+                                .should eql(expected)
+    end
+
+    it 'can format it in multiline US format' do
+      expected = <<-MULTILINE
+Kwik-E-Mart
+123 Apu Lane
+Springfield, NW 12345
+United States
+      MULTILINE
+
+      Pinpoint::Formatter.format(address, country: :us,
+                                                 style:   :multi_line_with_name)
+                                .should eql(expected)
+    end
+
+    it 'can format it in HTML in US format' do
+      expected = <<-MULTILINE
+<address>
+  <span class="section">
+    <span class="name">Kwik-E-Mart</span>
+  </span>
+  <span class="section">
+    <span class="street">123 Apu Lane</span>
+  </span>
+  <span class="section">
+    <span class="locality">Springfield</span>
+    <span class="province">NW</span>
+    <span class="postal_code">12345</span>
+  </span>
+  <span class="section">
+    <span class="country">United States</span>
+  </span>
+</address>
+      MULTILINE
+
+      Pinpoint::Formatter.format(address, country: :us,
+                                                 style:   :html)
+                                .should 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' }
+
+      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>
+  <span class="section">
+    <span class="street">123 Apu Lane</span>
+  </span>
+  <span class="section">
+    <span class="locality">Springfield</span>
+    <span class="province">NW</span>
+    <span class="postal_code">12345</span>
+  </span>
+  <span class="section">
+    <span class="country">United States</span>
+  </span>
+</address>
+        MULTILINE
+
+        Pinpoint::Formatter.format(address, country: :us,
+                                                  style:   :html)
+                                  .should eql(expected)
+      end
+    end
+  end
+end