pinpoint 0.4.0 → 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ec389cf558be0cf394dc052c78fcab7cead09b1f
+  data.tar.gz: 3196679d69559c65e2e325217fe59f5d6f2b0362
+SHA512:
+  metadata.gz: ab7ec3591033e820b5123d6df82209929bcdf8103c3a99cf9fd60cdef7d0a773641093fa0449349821ec213e2b789d17e7dcd946dbfd2786e17ff59a0b424788
+  data.tar.gz: a337577be69629350c0efb96b54e3bfbf65067d8bd2810c04ccdd85aa75e392ddff02e7e71cb4301064ca419ee84e0db0a898f44eb5b0fd32af9778cfed2ccc6

data/README.md

@@ -5,6 +5,8 @@ Pinpoint
 
 _(Un)conventional Address Composition for Ruby (and Rails)_
 
+[![Build Status](https://secure.travis-ci.org/jfelchner/pinpoint.png?branch=master)](http://travis-ci.org/jfelchner/pinpoint) [![Code Climate](https://codeclimate.com/github/jfelchner/pinpoint.png)](https://codeclimate.com/github/jfelchner/pinpoint) [![Code Climate](https://codeclimate.com/github/jfelchner/pinpoint/coverage.png)](https://codeclimate.com/github/jfelchner/pinpoint)
+
 Supported Rubies
 --------------------------------
 * MRI Ruby 1.9.2

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'

data/lib/pinpoint/address.rb

@@ -6,42 +6,42 @@ module Pinpoint
     include Mapable
 
     ATTRIBUTE_NAMES = [
-        :name,
-        :street_and_premises,
-        :city,
-        :state,
-        :county,
-        :postal_code,
-        :country,
-        :latitude,
-        :longitude
-      ]
+      :name,
+      :street_and_premises,
+      :city,
+      :state,
+      :county,
+      :postal_code,
+      :country,
+      :latitude,
+      :longitude,
+    ]
 
     attr_accessor *ATTRIBUTE_NAMES
 
     # City Aliases
-    alias :locality       :city
-    alias :locality=      :city=
+    alias_method :locality,       :city
+    alias_method :locality=,      :city=
 
     # Street Aliases
-    alias :street         :street_and_premises
-    alias :street=        :street_and_premises=
+    alias_method :street,         :street_and_premises
+    alias_method :street=,        :street_and_premises=
 
     # State Aliases
-    alias :region         :state
-    alias :region=        :state=
-    alias :province       :state
-    alias :province=      :state=
+    alias_method :region,         :state
+    alias_method :region=,        :state=
+    alias_method :province,       :state
+    alias_method :province=,      :state=
 
     # Zip Code Aliases
-    alias :zip_code       :postal_code
-    alias :zip_code=      :postal_code=
-    alias :zip            :postal_code
-    alias :zip=           :postal_code=
+    alias_method :zip_code,       :postal_code
+    alias_method :zip_code=,      :postal_code=
+    alias_method :zip,            :postal_code
+    alias_method :zip=,           :postal_code=
 
     # County Aliases
-    alias :district       :county
-    alias :district=      :county=
+    alias_method :district,       :county
+    alias_method :district=,      :county=
 
     def initialize(options = {})
       options.each do |key, value|
@@ -69,11 +69,12 @@ module Pinpoint
       blank?(country)
     end
 
-    def to_s(options = { :country => :us, :format => :one_line })
+    def to_s(options = { country: :us, format: :one_line })
       Formatter.format(self, options)
     end
 
-  private
+    private
+
     def present?(value)
       !blank?(value)
     end

data/lib/pinpoint/config/patterns.rb

@@ -2,6 +2,6 @@ module Pinpoint
   FORMATS = {
     # Zip Code:               5 digits
     #                         Optionally followed by a dash and 4 more digits
-    :zip_code                 => /^\d{5}(?:\-\d{4})?$/,
+    zip_code: /\A\d{5}(?:\-\d{4})?\z/,
   }
 end

data/lib/pinpoint/config/us_states.rb

@@ -1,3 +1,3 @@
-Pinpoint::US_STATES = %w(AK AL AR AZ CA CO CT DC DE FL GA HI IA ID IL IN KS KY LA MA MD
-  ME MI MN MO MS MT NC ND NE NH NJ NM NV NY OH OK OR PA RI SC SD TN TX UT VA VT
-  WA WI WV WY)
+Pinpoint::US_STATES = %w{AK AL AR AZ CA CO CT DC DE FL GA HI IA ID IL IN KS KY LA MA MD
+                         ME MI MN MO MS MT NC ND NE NH NJ NM NV NY OH OK OR PA RI SC SD TN TX UT VA VT
+                         WA WI WV WY}

data/lib/pinpoint/format.rb

@@ -26,7 +26,7 @@ module Pinpoint
     # Returns a Format loaded with all of the styles that it is capable of.
     #
     def self.lookup_by_country(country)
-      format = self.new
+      format = new
       format.styles = Pinpoint::Format::File.styles_for(country)
       format
     end

data/lib/pinpoint/format/file.rb

@@ -4,7 +4,6 @@ require 'pinpoint/format/style'
 module Pinpoint
   class Format
     class File
-
       ##
       # Public: Loads the format for the given country from the appropriate
       # YAML file.
@@ -38,7 +37,7 @@ module Pinpoint
       end
 
       def self.raw_style_data(country)
-        YAML::load(format_yaml_contents(country))
+        YAML.load(format_yaml_contents(country))
       end
     end
   end

data/lib/pinpoint/format/list.rb

@@ -42,11 +42,11 @@ module Pinpoint
       private
 
       def get(country)
-        self.formats[country]
+        formats[country]
       end
 
       def set(country, format)
-        self.formats[country] = format
+        formats[country] = format
       end
     end
   end

data/lib/pinpoint/format/parser.rb

@@ -7,7 +7,6 @@ require 'pinpoint/format/tokenizer'
 module Pinpoint
   class Format
     class Parser
-
       ##
       # Public: Initializes a Parser and converts the passed String into
       # a TokenList that will be utilized when it is parsed.

data/lib/pinpoint/format/style.rb

@@ -4,7 +4,6 @@ require 'active_support/core_ext/string/output_safety'
 module Pinpoint
   class Format
     class Style
-
       ##
       # Public: Processes the style information gleaned from the Pinpoint YAML
       # format and generates a Style from it.
@@ -17,7 +16,7 @@ module Pinpoint
       # Returns a Pinpoint::Format::Style based on the information passed in.
       #
       def self.from_yaml(style_definition)
-        style = self.new
+        style = new
         style.send(:structure=, Format::Parser.new(style_definition).parse)
         style
       end
@@ -57,7 +56,7 @@ module Pinpoint
       # Returns a String containing data from the context and String literals
       #
       def process(structure, context)
-        processed = "".html_safe
+        processed = ''.html_safe
 
         structure.each_with_object(processed) do |token, result|
           result << case token
@@ -70,7 +69,7 @@ module Pinpoint
                     end
         end
 
-        processed.match(no_alphanumerics) ? "".html_safe : processed
+        processed.match(no_alphanumerics) ? ''.html_safe : processed
       end
 
       def no_alphanumerics

data/lib/pinpoint/format/token.rb

@@ -39,7 +39,7 @@ module Pinpoint
           locality:    :locality,
           province:    :province,
           postal_code: :postal_code,
-          country:     :country
+          country:     :country,
         }
       end
     end

data/lib/pinpoint/format/token_list.rb

@@ -3,7 +3,6 @@ require 'pinpoint/format/parse_error'
 module Pinpoint
   class Format
     class TokenList < Array
-
       ##
       # Public: Processes each item in the list by removing it and passing it to
       # the block.
@@ -15,7 +14,7 @@ module Pinpoint
       # Returns nothing
       #
       def process_each!
-        while size > 0 do
+        while size > 0
           token = delete_at(0)
 
           yield token
@@ -30,7 +29,7 @@ module Pinpoint
       #   'group_start' tokens does not match the number of 'group_end' tokens.
       #
       def valid?
-        raise Pinpoint::Format::UnevenNestingError if group_start_count != group_end_count
+        fail Pinpoint::Format::UnevenNestingError if group_start_count != group_end_count
 
         true
       end

data/lib/pinpoint/format/tokenizer.rb

@@ -30,7 +30,7 @@ module Pinpoint
       # Returns nothing
       #
       def each
-        self.tokenable.reset
+        tokenable.reset
 
         while current_token = next_token
           yield current_token
@@ -43,7 +43,7 @@ module Pinpoint
       # Returns a TokenList
       #
       def to_token_list
-        TokenList.new(self.to_a)
+        TokenList.new(to_a)
       end
 
       protected
@@ -93,7 +93,7 @@ module Pinpoint
           left_paren:  /%\(/,
           right_paren: /%\)/,
           group_start: /\(/,
-          group_end:   /\)/
+          group_end:   /\)/,
         }
       end
 
@@ -151,20 +151,20 @@ module Pinpoint
         return if tokenable.eos?
 
         case
-        when text = tokenable.scan(token_map[:literal]);     Token.new(:literal,     text)
-        when text = tokenable.scan(token_map[:name]);        Token.new(:name,        text)
-        when text = tokenable.scan(token_map[:street]);      Token.new(:street,      text)
-        when text = tokenable.scan(token_map[:locality]);    Token.new(:locality,    text)
-        when text = tokenable.scan(token_map[:province]);    Token.new(:province,    text)
-        when text = tokenable.scan(token_map[:postal_code]); Token.new(:postal_code, text)
-        when text = tokenable.scan(token_map[:country]);     Token.new(:country,     text)
-        when text = tokenable.scan(token_map[:percent]);     Token.new(:literal,     '%')
-        when text = tokenable.scan(token_map[:left_paren]);  Token.new(:literal,     '(')
-        when text = tokenable.scan(token_map[:right_paren]); Token.new(:literal,     ')')
-        when text = tokenable.scan(token_map[:group_start]); Token.new(:group_start, text)
-        when text = tokenable.scan(token_map[:group_end]);   Token.new(:group_end,   text)
+        when text = tokenable.scan(token_map[:literal]) then     Token.new(:literal,     text)
+        when text = tokenable.scan(token_map[:name]) then        Token.new(:name,        text)
+        when text = tokenable.scan(token_map[:street]) then      Token.new(:street,      text)
+        when text = tokenable.scan(token_map[:locality]) then    Token.new(:locality,    text)
+        when text = tokenable.scan(token_map[:province]) then    Token.new(:province,    text)
+        when text = tokenable.scan(token_map[:postal_code]) then Token.new(:postal_code, text)
+        when text = tokenable.scan(token_map[:country]) then     Token.new(:country,     text)
+        when text = tokenable.scan(token_map[:percent]) then     Token.new(:literal,     '%')
+        when text = tokenable.scan(token_map[:left_paren]) then  Token.new(:literal,     '(')
+        when text = tokenable.scan(token_map[:right_paren]) then Token.new(:literal,     ')')
+        when text = tokenable.scan(token_map[:group_start]) then Token.new(:group_start, text)
+        when text = tokenable.scan(token_map[:group_end]) then   Token.new(:group_end,   text)
         else
-          raise ParseError, "Cannot parse the remainder of the tokenable string: '#{tokenable.rest}'"
+          fail ParseError, "Cannot parse the remainder of the tokenable string: '#{tokenable.rest}'"
         end
       end
     end

data/lib/pinpoint/formatter.rb

@@ -2,7 +2,6 @@ require 'pinpoint/format/list'
 
 module Pinpoint
   class Formatter
-
     ##
     # Public: Is able to process an Address into numerous formats based on the
     # country and style, or a completely custom format.
@@ -74,7 +73,7 @@ module Pinpoint
 
       format  = formats[country]
 
-      format.output address, :style => style
+      format.output address, style: style
     end
 
     private

data/lib/pinpoint/mapable.rb

@@ -5,7 +5,6 @@ require 'pinpoint/mapable_services/mapquest'
 
 module Pinpoint
   module Mapable
-
     ##
     # Public: Creates a URL which can be used to locate the Mapable on a map
     # using one of the supported services:
@@ -32,8 +31,8 @@ module Pinpoint
       service              = options.fetch(:via, :google_maps)
       service_class        = service_class_for(service)
 
-      service_class.map_url location:       self.to_s,
-                            location_name:  self.name
+      service_class.map_url location:      to_s,
+                            location_name: name
     end
 
     private

data/lib/pinpoint/mapable_services/google_maps.rb

@@ -3,7 +3,6 @@ require 'cgi'
 module Pinpoint
   module MapableService
     class GoogleMaps
-
       ##
       # Private: Renders a URL for a given location and location name using the
       # Google Maps mapping service.

data/lib/pinpoint/mapable_services/mapquest.rb

@@ -3,7 +3,6 @@ require 'cgi'
 module Pinpoint
   module MapableService
     class Mapquest
-
       ##
       # Private: Renders a URL for a given location and location name using the
       # Mapquest mapping service.

data/lib/pinpoint/mapable_services/yahoo_maps.rb

@@ -3,7 +3,6 @@ require 'cgi'
 module Pinpoint
   module MapableService
     class YahooMaps
-
       ##
       # Private: Renders a URL for a given location and location name using the
       # Yahoo Maps mapping service.

data/lib/pinpoint/model_support.rb

@@ -62,7 +62,7 @@ module Pinpoint
       object.send(:define_method, field_name) do
         address_fields_and_values = field_pairs.map do |field_pair|
                                       [field_pair[0], send(field_pair[1])]
-                                    end
+        end
 
         address_fields_and_values = Hash[address_fields_and_values]
 
@@ -136,12 +136,12 @@ module Pinpoint
                                    gsub(/\A#{prefix}/, '').
                                    gsub(/=\z/, '').
                                    to_sym
-                           end
+      end
 
       {
         base_fields:   base_fields,
         reader_fields: reader_fields,
-        writer_fields: writer_fields
+        writer_fields: writer_fields,
       }
     end
 

data/lib/pinpoint/version.rb

@@ -1,3 +1,3 @@
 module Pinpoint
-  VERSION = '0.4.0'
+  VERSION = '0.4.1'
 end

data/spec/address_spec.rb

@@ -1,48 +1,48 @@
-require 'rspectacular'
+require 'spec_helper'
 require 'pinpoint/address'
 
 describe 'Pinpoint::Address' do
   let(:address) { Pinpoint::Address.new }
 
-  it { address.respond_to?(:region).should        be_true }
-  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?(:zip).should           be_true }
-  it { address.respond_to?(:zip=).should          be_true }
-  it { address.respond_to?(:district).should      be_true }
-  it { address.respond_to?(:district=).should     be_true }
+  it { expect(address.respond_to?(:region)).to        eql true }
+  it { expect(address.respond_to?(:region=)).to       eql true }
+  it { expect(address.respond_to?(:province)).to      eql true }
+  it { expect(address.respond_to?(:province=)).to     eql true }
+  it { expect(address.respond_to?(:locality)).to      eql true }
+  it { expect(address.respond_to?(:locality=)).to     eql true }
+  it { expect(address.respond_to?(:postal_code)).to   eql true }
+  it { expect(address.respond_to?(:postal_code=)).to  eql true }
+  it { expect(address.respond_to?(:zip)).to           eql true }
+  it { expect(address.respond_to?(:zip=)).to          eql true }
+  it { expect(address.respond_to?(:district)).to      eql true }
+  it { expect(address.respond_to?(:district=)).to     eql true }
 
   describe '#new' do
     context 'when it is passed a set of initial values as a Hash' do
       let(:address) do
         Pinpoint::Address.new(
-          name:       'The Frist Center for the Visual Arts',
-          street:     '919 Broadway',
-          city:       'Nashville',
-          state:      'Tennessee',
-          county:     'Davidson',
-          zip_code:   '37203',
-          country:    'United States',
-          latitude:   '36.15885623029150',
-          longitude:  '-86.78226636970851'
+          name:      'The Frist Center for the Visual Arts',
+          street:    '919 Broadway',
+          city:      'Nashville',
+          state:     'Tennessee',
+          county:    'Davidson',
+          zip_code:  '37203',
+          country:   'United States',
+          latitude:  '36.15885623029150',
+          longitude: '-86.78226636970851',
         )
       end
 
       it 'sets its values properly' do
-        address.name.should       eql 'The Frist Center for the Visual Arts'
-        address.street.should     eql '919 Broadway'
-        address.city.should       eql 'Nashville'
-        address.state.should      eql 'Tennessee'
-        address.county.should     eql 'Davidson'
-        address.zip_code.should   eql '37203'
-        address.country.should    eql 'United States'
-        address.latitude.should   eql '36.15885623029150'
-        address.longitude.should  eql '-86.78226636970851'
+        expect(address.name).to       eql 'The Frist Center for the Visual Arts'
+        expect(address.street).to     eql '919 Broadway'
+        expect(address.city).to       eql 'Nashville'
+        expect(address.state).to      eql 'Tennessee'
+        expect(address.county).to     eql 'Davidson'
+        expect(address.zip_code).to   eql '37203'
+        expect(address.country).to    eql 'United States'
+        expect(address.latitude).to   eql '36.15885623029150'
+        expect(address.longitude).to  eql '-86.78226636970851'
       end
     end
   end
@@ -51,64 +51,64 @@ describe 'Pinpoint::Address' do
     context 'when any of the main parts of the address are blank' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     '',
-          city:       'Nashville',
-          state:      'Tennessee',
-          zip_code:   '37203',
-          country:    'US'
+          street:   '',
+          city:     'Nashville',
+          state:    'Tennessee',
+          zip_code: '37203',
+          country:  'US',
         )
       end
 
       it 'is false' do
-        address.should_not be_complete
+        expect(address).not_to be_complete
       end
     end
 
     context 'when any of the main parts of the address are missing' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     nil,
-          city:       'Nashville',
-          state:      'Tennessee',
-          zip_code:   '37203',
-          country:    'US'
+          street:   nil,
+          city:     'Nashville',
+          state:    'Tennessee',
+          zip_code: '37203',
+          country:  'US',
         )
       end
 
       it 'is false' do
-        address.should_not be_complete
+        expect(address).not_to be_complete
       end
     end
 
     context 'when all of the main parts of the address are present' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     '919 Broadway',
-          city:       'Nashville',
-          state:      'Tennessee',
-          zip_code:   '37203',
-          country:    'US'
+          street:   '919 Broadway',
+          city:     'Nashville',
+          state:    'Tennessee',
+          zip_code: '37203',
+          country:  'US',
         )
       end
 
       it 'is true' do
-        address.should be_complete
+        expect(address).to be_complete
       end
     end
 
     context 'when all of the main parts of the address are missing' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     nil,
-          city:       nil,
-          state:      nil,
-          zip_code:   nil,
-          country:    nil
+          street:   nil,
+          city:     nil,
+          state:    nil,
+          zip_code: nil,
+          country:  nil,
         )
       end
 
       it 'is false' do
-        address.should_not be_complete
+        expect(address).not_to be_complete
       end
     end
   end
@@ -117,64 +117,64 @@ describe 'Pinpoint::Address' do
     context 'when any of the main parts of the address are blank' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     '',
-          city:       'Nashville',
-          state:      'Tennessee',
-          zip_code:   '37203',
-          country:    'US'
+          street:   '',
+          city:     'Nashville',
+          state:    'Tennessee',
+          zip_code: '37203',
+          country:  'US',
         )
       end
 
       it 'is true' do
-        address.should be_incomplete
+        expect(address).to be_incomplete
       end
     end
 
     context 'when any of the main parts of the address are missing' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     nil,
-          city:       'Nashville',
-          state:      'Tennessee',
-          zip_code:   '37203',
-          country:    'US'
+          street:   nil,
+          city:     'Nashville',
+          state:    'Tennessee',
+          zip_code: '37203',
+          country:  'US',
         )
       end
 
       it 'is true' do
-        address.should be_incomplete
+        expect(address).to be_incomplete
       end
     end
 
     context 'when all of the main parts of the address are present' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     '919 Broadway',
-          city:       'Nashville',
-          state:      'Tennessee',
-          zip_code:   '37203',
-          country:    'US'
+          street:   '919 Broadway',
+          city:     'Nashville',
+          state:    'Tennessee',
+          zip_code: '37203',
+          country:  'US',
         )
       end
 
       it 'is false' do
-        address.should_not be_incomplete
+        expect(address).not_to be_incomplete
       end
     end
 
     context 'when all of the main parts of the address are missing' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     nil,
-          city:       nil,
-          state:      nil,
-          zip_code:   nil,
-          country:    nil
+          street:   nil,
+          city:     nil,
+          state:    nil,
+          zip_code: nil,
+          country:  nil,
         )
       end
 
       it 'is false' do
-        address.should_not be_incomplete
+        expect(address).not_to be_incomplete
       end
     end
   end
@@ -183,64 +183,64 @@ describe 'Pinpoint::Address' do
     context 'when any of the main parts of the address are blank' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     '',
-          city:       'Nashville',
-          state:      'Tennessee',
-          zip_code:   '37203',
-          country:    'US'
+          street:   '',
+          city:     'Nashville',
+          state:    'Tennessee',
+          zip_code: '37203',
+          country:  'US',
         )
       end
 
       it 'is false' do
-        address.should_not be_empty
+        expect(address).not_to be_empty
       end
     end
 
     context 'when any of the main parts of the address are missing' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     nil,
-          city:       'Nashville',
-          state:      'Tennessee',
-          zip_code:   '37203',
-          country:    'US'
+          street:   nil,
+          city:     'Nashville',
+          state:    'Tennessee',
+          zip_code: '37203',
+          country:  'US',
         )
       end
 
       it 'is false' do
-        address.should_not be_empty
+        expect(address).not_to be_empty
       end
     end
 
     context 'when all of the main parts of the address are present' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     '919 Broadway',
-          city:       'Nashville',
-          state:      'Tennessee',
-          zip_code:   '37203',
-          country:    'US'
+          street:   '919 Broadway',
+          city:     'Nashville',
+          state:    'Tennessee',
+          zip_code: '37203',
+          country:  'US',
         )
       end
 
       it 'is false' do
-        address.should_not be_empty
+        expect(address).not_to be_empty
       end
     end
 
     context 'when all of the main parts of the address are missing' do
       let(:address) do
         Pinpoint::Address.new(
-          street:     nil,
-          city:       nil,
-          state:      nil,
-          zip_code:   nil,
-          country:    nil
+          street:   nil,
+          city:     nil,
+          state:    nil,
+          zip_code: nil,
+          country:  nil,
         )
       end
 
       it 'is true' do
-        address.should be_empty
+        expect(address).to be_empty
       end
     end
   end