pinpoint 0.1.0 → 0.2.0

data/lib/pinpoint/address.rb

@@ -2,20 +2,28 @@ require 'pinpoint/formatter'
 
 module Pinpoint
   class Address
-    attr_accessor :name,
-                  :street,
-                  :city,
-                  :state,
-                  :county,
-                  :zip_code,
-                  :country,
-                  :latitude,
-                  :longitude
+    ATTRIBUTE_NAMES = [
+        :name,
+        :street_and_premises,
+        :city,
+        :state,
+        :county,
+        :postal_code,
+        :country,
+        :latitude,
+        :longitude
+      ]
+
+    attr_accessor *ATTRIBUTE_NAMES
 
     # City Aliases
     alias :locality       :city
     alias :locality=      :city=
 
+    # Street Aliases
+    alias :street         :street_and_premises
+    alias :street=        :street_and_premises=
+
     # State Aliases
     alias :region         :state
     alias :region=        :state=
@@ -23,12 +31,10 @@ module Pinpoint
     alias :province=      :state=
 
     # Zip Code Aliases
-    alias :postal_code    :zip_code
-    alias :postal_code=   :zip_code=
-    alias :postalcode     :zip_code
-    alias :postalcode=    :zip_code=
-    alias :zip            :zip_code
-    alias :zip=           :zip_code=
+    alias :zip_code       :postal_code
+    alias :zip_code=      :postal_code=
+    alias :zip            :postal_code
+    alias :zip=           :postal_code=
 
     # County Aliases
     alias :district       :county
@@ -41,10 +47,10 @@ module Pinpoint
     end
 
     def complete?
-      present?(street)    &&
-      present?(city)      &&
-      present?(state)     &&
-      present?(zip_code)
+      present?(street_and_premises) &&
+      present?(city)                &&
+      present?(state)               &&
+      present?(postal_code)
     end
 
     def incomplete?
@@ -52,10 +58,10 @@ module Pinpoint
     end
 
     def empty?
-      blank?(street)      &&
-      blank?(city)        &&
-      blank?(state)       &&
-      blank?(zip_code)
+      blank?(street_and_premises) &&
+      blank?(city)                &&
+      blank?(state)               &&
+      blank?(postal_code)
     end
 
     def to_s(options = { :country => :us, :format => :one_line })

data/lib/pinpoint/composable.rb

@@ -0,0 +1,48 @@
+require 'pinpoint/model_support'
+require 'pinpoint/validations'
+
+module Pinpoint
+  module Composable
+    ##
+    # Public: Allows fields on a class to be composed/decomposed to
+    # Pinpoint::Addresses.
+    #
+    # field_name - The object to apply the accessors to
+    # options    - A Hash of options to apply to the method call
+    #
+    #           :validate   - A Boolean describing whether to include
+    #                         ActiveModel::Validations into the class for the
+    #                         address fields.
+    #           :prefix     - If set, then all fields which make up the Address
+    #                         will be prefixed with that string (eg: #venue_city
+    #                         instead of just #city) If you do not want field
+    #                         names to be prefixed simply set it to false.
+    #                         (defaults to the field name).
+    #
+    # Example
+    #
+    #   # Implicit Prefix (will look for fields such as 'address_city')
+    #   pinpoint :address
+    #
+    #   # Explicit Prefix (will look for fields such as 'venue_city')
+    #   pinpoint :location, :prefix => :venue
+    #
+    #   # No Prefix (will look for fields such as 'city')
+    #   pinpoint :location, :prefix => false
+    #
+    #   # Include field validations
+    #   pinpoint :address, :validate => true
+    #
+    # Returns nothing
+    #
+    def pinpoint(field_name, options = {})
+      options[:field_field_name] = field_name
+
+      if options[:validate]
+        Pinpoint::Validations.define(self, options)
+      end
+
+      Pinpoint::ModelSupport.define_address_accessors(self, options)
+    end
+  end
+end

data/lib/pinpoint/model_support.rb

@@ -0,0 +1,157 @@
+require 'active_support/core_ext/object/blank'
+require 'pinpoint/address'
+
+module Pinpoint
+  module ModelSupport
+    ##
+    # Private: Defines address accessors for a given object.
+    #
+    # object  - The object to apply the accessors to
+    # options - A Hash of options to apply to the method call
+    #
+    #           :field_name - The String or Symbol representing the name of the
+    #                         field pair to create (eg: #venue and #venue=).
+    #           :prefix     - If set, then all fields which make up the Address
+    #                         will be prefixed with that string (eg: #venue_city
+    #                         instead of just #city) If you do not want field
+    #                         names to be prefixed simply set it to false.
+    #                         (defaults to the field name).
+    #
+    # Example
+    #
+    #   # Without a Prefix
+    #   define_address_accessors my_object, field_name: :venue
+    #
+    #   # With a Prefix
+    #   define_address_accessors my_object, field_name: :address,
+    #                                       prefix:     :venue
+    #
+    # Returns nothing
+    #
+    def self.define_address_accessors(object, options = {})
+      field_name                 = options.fetch(:field_name)
+      options[:prefix]           = options.fetch(:prefix, field_name)
+      options[:address_fields] ||= find_address_fields(object, options)
+
+      define_address_reader(object, options)
+      define_address_setter(object, options)
+      define_address_predicates(object, options)
+    end
+
+    private
+
+    ##
+    # Private: Defines the reader for the composed Address field.
+    #
+    # The defined method will collect all of the disparate pieces of information
+    # from the model and create a Pinpoint::Address that represents that
+    # information.
+    #
+    # object  - (See .define_address_accessors object parameter)
+    # options - (See .define_address_accessors options parameter)
+    #
+    # Returns nothing
+    #
+    def self.define_address_reader(object, options)
+      field_name       = options.fetch(:field_name)
+      attribute_fields = options.fetch(:address_fields).fetch(:base_fields)
+      reader_fields    = options.fetch(:address_fields).fetch(:reader_fields)
+      field_pairs      = attribute_fields.zip reader_fields
+
+      # TODO: Memoize
+      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
+        address_fields_and_values = Hash[address_fields_and_values]
+
+        Pinpoint::Address.new(address_fields_and_values)
+      end
+    end
+
+    ##
+    # Private: Defines the writer for the composed Address field.
+    #
+    # The defined method will read all of the pieces of the address from the
+    # Address that is passed in and set that information on the model's address
+    # fields.
+    #
+    # object  - (See .define_address_accessors object parameter)
+    # options - (See .define_address_accessors options parameter)
+    #
+    # Returns nothing
+    #
+    def self.define_address_setter(object, options)
+      name          = options.fetch(:field_name)
+      reader_fields = options.fetch(:address_fields).fetch(:base_fields)
+      writer_fields = options.fetch(:address_fields).fetch(:writer_fields)
+      field_pairs   = reader_fields.zip writer_fields
+
+      object.send(:define_method, "#{name}=") do |address|
+        field_pairs.each do |field_pair|
+          send(field_pair[1], address.send(field_pair[0]))
+        end
+      end
+    end
+
+    ##
+    # Private: Defines a method which checks to see if the composed address
+    # field is incomplete.
+    #
+    # This is used mainly to remove the need to 'reach into' the Address itself.
+    #
+    # object  - (See .define_address_accessors object parameter)
+    # options - (See .define_address_accessors options parameter)
+    #
+    # Returns nothing
+    #
+    def self.define_address_predicates(object, options)
+      name = options.fetch(:field_name)
+
+      object.send(:define_method, "#{name}_incomplete?") do
+        send(:"#{name}").incomplete?
+      end
+    end
+
+    ##
+    # Private: Finds the writer and reader methods that will be used whenever
+    # the composed address field is read from or written to.
+    #
+    # Additionally it maps writer fields back to the field that must be read
+    # from on the Address to get the proper value.
+    #
+    # Returns a Hash of 'base', 'reader' and 'writer' fields.
+    #
+    def self.find_address_fields(object, options)
+      prefix             = options[:prefix].blank? ? '' : "#{options[:prefix]}_"
+      address_attrs      = Pinpoint::Address::ATTRIBUTE_NAMES
+      reader_field_names = address_attrs.map { |field| :"#{prefix}#{field}" }
+      writer_field_names = address_attrs.map { |field| :"#{prefix}#{field}=" }
+
+      reader_fields      = find_existing_methods(object, reader_field_names)
+      writer_fields      = find_existing_methods(object, writer_field_names)
+      base_fields        = writer_fields.map do |field|
+                             field.to_s.
+                                   gsub(/\A#{prefix}/, '').
+                                   gsub(/=\z/, '').
+                                   to_sym
+                           end
+
+      {
+        base_fields:   base_fields,
+        reader_fields: reader_fields,
+        writer_fields: writer_fields
+      }
+    end
+
+    ##
+    # Private: Finds the items that are common between the fields being passed
+    # in and the public instance methods on the object.
+    #
+    # Returns an Array of common methods
+    #
+    def self.find_existing_methods(object, fields)
+      fields & object.public_instance_methods
+    end
+  end
+end

data/lib/pinpoint/validations.rb

@@ -3,32 +3,35 @@ require 'pinpoint/config/patterns'
 
 module Pinpoint
   module Validations
-    def install_validations(name)
-      instance_eval <<-VALIDATIONIZATION
-        validates :#{name}_name,
+    def self.define(object, options)
+      name   = options.fetch(:field_name)
+      prefix = options.fetch(:prefix, name).blank? ? '' : "#{options[:prefix]}_"
+
+      object.instance_eval <<-VALIDATIONIZATION
+        validates :#{prefix}name,
                   :length         => {
                     :maximum      => 140 }
 
-        validates :#{name}_street_and_premises,
+        validates :#{prefix}street_and_premises,
                   :presence       => {
                     :if           => :#{name}_incomplete? },
                   :length         => {
                     :maximum      => 255 }
 
-        validates :#{name}_city,
+        validates :#{prefix}city,
                   :presence       => {
                     :if           => :#{name}_incomplete? },
                   :length         => {
                     :maximum      => 60 }
 
-        validates :#{name}_state_or_province,
+        validates :#{prefix}state,
                   :presence       => {
                     :if           => :#{name}_incomplete? },
                   :inclusion      => {
                     :in           => Pinpoint::US_STATES,
                     :allow_blank  => true }
 
-        validates :#{name}_postal_code,
+        validates :#{prefix}postal_code,
                   :presence       => {
                     :if           => :#{name}_incomplete? },
                   :format         => {

data/lib/pinpoint/version.rb

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

data/lib/pinpoint.rb

@@ -1,48 +1,6 @@
 require 'pinpoint/version'
-require 'pinpoint/validations'
+require 'pinpoint/composable'
 require 'pinpoint/address'
 
 module Pinpoint
-  module ClassMethods
-    include Validations
-
-    def pinpoint(name, options = {})
-      if options[:validate]
-        install_validations(name)
-      end
-
-      define_method name do
-        # TODO: Memoize
-
-        Pinpoint::Address.new(
-          :name        => respond_to?(:"#{name}_name")                ? send(:"#{name}_name")                 : '',
-          :street      => respond_to?(:"#{name}_street_and_premises") ? send(:"#{name}_street_and_premises")  : '',
-          :city        => respond_to?(:"#{name}_city")                ? send(:"#{name}_city")                 : '',
-          :state       => respond_to?(:"#{name}_state_or_province")   ? send(:"#{name}_state_or_province")    : '',
-          :county      => respond_to?(:"#{name}_district_or_county")  ? send(:"#{name}_district_or_county")   : '',
-          :postal_code => respond_to?(:"#{name}_postal_code")         ? send(:"#{name}_postal_code")          : '',
-          :country     => respond_to?(:"#{name}_country")             ? send(:"#{name}_country")              : '',
-          :latitude    => respond_to?(:"#{name}_latitude")            ? send(:"#{name}_latitude")             : '',
-          :longitude   => respond_to?(:"#{name}_longitude")           ? send(:"#{name}_longitude")            : ''
-        )
-      end
-
-      define_method "#{name}=" do |address|
-        send(:"#{name}_name=",                address.name)
-        send(:"#{name}_street_and_premises=", address.street)
-        send(:"#{name}_city=",                address.city)
-        send(:"#{name}_state_or_province=",   address.state)
-        send(:"#{name}_postal_code=",         address.zip_code)
-        send(:"#{name}_country=",             address.country)
-      end
-
-      define_method "#{name}_incomplete?" do
-        send(:"#{name}").incomplete?
-      end
-    end
-  end
-
-  def self.included(base)
-    base.extend ClassMethods
-  end
 end

data/spec/address_spec.rb

@@ -12,8 +12,6 @@ describe 'Pinpoint::Address' do
   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 }
-  it { address.respond_to?(:postalcode=).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 }

data/spec/model_support_spec.rb

@@ -0,0 +1,234 @@
+require 'rspectacular'
+require 'pinpoint/model_support'
+
+class PinpointableAccessorClass
+  def initialize(options = {})
+    options.each do |key, value|
+      send("#{key}=", value)
+    end
+  end
+end
+
+class PinpointableAccessorClassWithNoPrefixedFields < PinpointableAccessorClass
+  attr_accessor :name,
+                :street_and_premises,
+                :city,
+                :state,
+                :county,
+                :postal_code,
+                :country,
+                :latitude,
+                :longitude
+end
+
+class PinpointableAccessorClassWithPrefixedFields < PinpointableAccessorClass
+  attr_accessor :my_address_name,
+                :my_address_street_and_premises,
+                :my_address_city,
+                :my_address_state,
+                :my_address_county,
+                :my_address_postal_code,
+                :my_address_country,
+                :my_address_latitude,
+                :my_address_longitude
+end
+
+class PinpointableAccessorClassWithIncompleteFields < PinpointableAccessorClass
+  attr_accessor :name,
+                :street_and_premises,
+                :city,
+                :state
+end
+
+describe Pinpoint::ModelSupport do
+  let(:model_support_module) { Pinpoint::ModelSupport }
+
+  context 'when only a composed name is passed in' do
+    let(:pinpointable_class) { PinpointableAccessorClassWithPrefixedFields }
+    let(:pinpointable)       { pinpointable_class.new(
+                                 my_address_name:                 'name',
+                                 my_address_street_and_premises:  'street',
+                                 my_address_city:                 'city',
+                                 my_address_state:                'state',
+                                 my_address_county:               'county',
+                                 my_address_postal_code:          'postal_code',
+                                 my_address_country:              'country',
+                                 my_address_latitude:             'latitude',
+                                 my_address_longitude:            'longitude' ) }
+
+    it 'can add a reader to a class' do
+      model_support_module.define_address_accessors(pinpointable_class,
+                                                    field_name: :my_address)
+
+      pinpointable.should respond_to :my_address
+    end
+
+    it 'can compose an Address with the proper values from the model' do
+      model_support_module.define_address_accessors(pinpointable_class,
+                                                    field_name: :my_address)
+
+      Pinpoint::Address.should_receive(:new).with(
+        name:                 'name',
+        street_and_premises:  'street',
+        city:                 'city',
+        state:                'state',
+        county:               'county',
+        postal_code:          'postal_code',
+        country:              'country',
+        latitude:             'latitude',
+        longitude:            'longitude'
+      )
+
+      pinpointable.my_address
+    end
+
+    it 'can deconstruct an Address into its component pieces' do
+      model_support_module.define_address_accessors(pinpointable_class,
+                                                    field_name: :my_address)
+
+      address = Pinpoint::Address.new(name:                 'name',
+                                      street_and_premises:  'street',
+                                      city:                 'city',
+                                      state:                'state',
+                                      county:               'county',
+                                      postal_code:          'postal_code',
+                                      country:              'country',
+                                      latitude:             'latitude',
+                                      longitude:            'longitude')
+
+      pinpointable.should_receive :my_address_name=,                :with => 'name'
+      pinpointable.should_receive :my_address_street_and_premises=, :with => 'street'
+      pinpointable.should_receive :my_address_city=,                :with => 'city'
+      pinpointable.should_receive :my_address_state=,               :with => 'state'
+      pinpointable.should_receive :my_address_county=,              :with => 'county'
+      pinpointable.should_receive :my_address_postal_code=,         :with => 'postal_code'
+      pinpointable.should_receive :my_address_country=,             :with => 'country'
+      pinpointable.should_receive :my_address_latitude=,            :with => 'latitude'
+      pinpointable.should_receive :my_address_longitude=,           :with => 'longitude'
+
+      pinpointable.my_address = address
+    end
+  end
+
+  context 'when a composed name is passed in along with a prefix' do
+    let(:pinpointable_class) { PinpointableAccessorClassWithPrefixedFields }
+    let(:pinpointable)       { pinpointable_class.new( my_address_name:                 'name',
+                                                       my_address_street_and_premises:  'street',
+                                                       my_address_city:                 'city',
+                                                       my_address_state:                'state',
+                                                       my_address_county:               'county',
+                                                       my_address_postal_code:          'postal_code',
+                                                       my_address_country:              'country',
+                                                       my_address_latitude:             'latitude',
+                                                       my_address_longitude:            'longitude' ) }
+
+    it 'can add a reader to a class' do
+      model_support_module.define_address_accessors(pinpointable_class,
+                                                    field_name: :address,
+                                                    prefix:     :my_address)
+
+      pinpointable.should respond_to :address
+    end
+
+    it 'can compose an Address with the proper values from the model' do
+      model_support_module.define_address_accessors(pinpointable_class,
+                                                    field_name: :address,
+                                                    prefix:     :my_address)
+
+      Pinpoint::Address.should_receive(:new).with(
+        name:                 'name',
+        street_and_premises:  'street',
+        city:                 'city',
+        state:                'state',
+        county:               'county',
+        postal_code:          'postal_code',
+        country:              'country',
+        latitude:             'latitude',
+        longitude:            'longitude'
+      )
+
+      pinpointable.address
+    end
+
+    it 'can deconstruct an Address into its component pieces' do
+      model_support_module.define_address_accessors(pinpointable_class,
+                                                    field_name: :address,
+                                                    prefix:     :my_address)
+
+      address = Pinpoint::Address.new(name:                 'name',
+                                      street_and_premises:  'street',
+                                      city:                 'city',
+                                      state:                'state',
+                                      county:               'county',
+                                      postal_code:          'postal_code',
+                                      country:              'country',
+                                      latitude:             'latitude',
+                                      longitude:            'longitude')
+
+      pinpointable.should_receive :my_address_name=,                 :with => 'name'
+      pinpointable.should_receive :my_address_street_and_premises=,  :with => 'street'
+      pinpointable.should_receive :my_address_city=,                 :with => 'city'
+      pinpointable.should_receive :my_address_state=,                :with => 'state'
+      pinpointable.should_receive :my_address_county=,               :with => 'county'
+      pinpointable.should_receive :my_address_postal_code=,          :with => 'postal_code'
+      pinpointable.should_receive :my_address_country=,              :with => 'country'
+      pinpointable.should_receive :my_address_latitude=,             :with => 'latitude'
+      pinpointable.should_receive :my_address_longitude=,            :with => 'longitude'
+
+      pinpointable.address = address
+    end
+  end
+
+  context 'when an object is referenced which does not implement all of the fields' do
+    let(:pinpointable_class) { PinpointableAccessorClassWithIncompleteFields }
+    let(:pinpointable)       { pinpointable_class.new( name:                 'name',
+                                                       street_and_premises:  'street',
+                                                       city:                 'city',
+                                                       state:                'state' ) }
+
+    it 'can compose an Address with the proper values from the model' do
+      model_support_module.define_address_accessors(pinpointable_class,
+                                                    field_name:   :address,
+                                                    prefix:       false)
+
+      Pinpoint::Address.should_receive(:new).with(
+        name:                 'name',
+        street_and_premises:  'street',
+        city:                 'city',
+        state:                'state'
+      )
+
+      pinpointable.address
+    end
+
+    it 'can deconstruct an Address into its component pieces' do
+      model_support_module.define_address_accessors(pinpointable_class,
+                                                    field_name:   :address,
+                                                    prefix:       false)
+
+      address = Pinpoint::Address.new(name:                 'name',
+                                      street_and_premises:  'street',
+                                      city:                 'city',
+                                      state:                'state',
+                                      county:               'county',
+                                      postal_code:          'postal_code',
+                                      country:              'country',
+                                      latitude:             'latitude',
+                                      longitude:            'longitude')
+
+      pinpointable.should_receive :name=,                 :with => 'name'
+      pinpointable.should_receive :street_and_premises=,  :with => 'street'
+      pinpointable.should_receive :city=,                 :with => 'city'
+      pinpointable.should_receive :state=,                :with => 'state'
+
+      pinpointable.address = address
+    end
+  end
+
+  context 'when a composed name is not passed in' do
+    it 'throws an error' do
+      expect { model_support_module.define_address_accessors(pinpointable_class) }.to(
+        raise_error)
+    end
+  end
+end

data/spec/validations_spec.rb

@@ -5,30 +5,31 @@ require 'pinpoint'
 
 class ValidatablePinpointable
   include ActiveModel::Validations
-  include Pinpoint
+  extend Pinpoint::Composable
 
-  attr_accessor :address_name,
-                :address_street_and_premises,
-                :address_city,
-                :address_state_or_province,
-                :address_postal_code,
-                :address_country
+  attr_accessor :name,
+                :street_and_premises,
+                :city,
+                :state,
+                :postal_code,
+                :country
 
-  pinpoint :address, :validate => true
+  pinpoint :address, prefix:   false,
+                     validate: true
 end
 
 class UnvalidatablePinpointable
   include ActiveModel::Validations
-  include Pinpoint
+  extend Pinpoint::Composable
 
   attr_accessor :address_name,
                 :address_street_and_premises,
                 :address_city,
-                :address_state_or_province,
+                :address_state,
                 :address_postal_code,
                 :address_country
 
-  pinpoint :address
+  pinpoint :address, :prefix => :address
 end
 
 describe 'Pinpoint::Validations' do
@@ -36,60 +37,60 @@ describe 'Pinpoint::Validations' do
     subject { ValidatablePinpointable.new }
 
     describe '#address_name' do
-      it { should     have_valid(:address_name).when                    nil, ('*' * 140)           }
-      it { should_not have_valid(:address_name).when                    ('*' * 141)                }
+      it { should     have_valid(:name).when                  nil, ('*' * 140)           }
+      it { should_not have_valid(:name).when                  ('*' * 141)                }
     end
 
-    describe '#address_state_or_province' do
-      it { should     have_valid(:address_street_and_premises).when     nil, ('*' * 255)           }
-      it { should_not have_valid(:address_street_and_premises).when     ('*' * 256)                }
+    describe '#address_state' do
+      it { should     have_valid(:street_and_premises).when   nil, ('*' * 255)           }
+      it { should_not have_valid(:street_and_premises).when   ('*' * 256)                }
     end
 
     describe '#address_city' do
-      it { should     have_valid(:address_city).when                    nil, ('*' * 60)            }
-      it { should_not have_valid(:address_city).when                    ('*' * 61)                 }
+      it { should     have_valid(:city).when                  nil, ('*' * 60)            }
+      it { should_not have_valid(:city).when                  ('*' * 61)                 }
     end
 
     describe '#address_street_and_premises' do
-      it { should     have_valid(:address_state_or_province).when       nil, '', 'NY', 'MO'        }
-      it { should_not have_valid(:address_state_or_province).when       'WP', 'NI', 'PO'           }
+      it { should     have_valid(:state).when                 nil, '', 'NY', 'MO'        }
+      it { should_not have_valid(:state).when                 'WP', 'NI', 'PO'           }
     end
 
     describe '#address_postal_code' do
-      it { should     have_valid(:address_postal_code).when             nil, '', 12345, 12345-1234 }
-      it { should_not have_valid(:address_postal_code).when             'asdf', '123456'           }
+      it { should     have_valid(:postal_code).when           nil, '', 12345, 12345-1234 }
+      it { should_not have_valid(:postal_code).when           'asdf', '123456'           }
     end
 
     context "when the street address is set" do
-      before { subject.address_street_and_premises = "foo" }
+      before { subject.street_and_premises = "foo" }
 
-      it('the city should not be valid when blank')     { should_not have_valid(:address_city).when                  nil, '' }
-      it('the state should not be valid when blank')    { should_not have_valid(:address_state_or_province).when     nil, '' }
-      it('the zip code should not be valid when blank') { should_not have_valid(:address_postal_code).when           nil, '' }
+      it('the city should not be valid when blank')     { should_not have_valid(:city).when         nil, '' }
+      it('the state should not be valid when blank')    { should_not have_valid(:state).when        nil, '' }
+      it('the zip code should not be valid when blank') { should_not have_valid(:postal_code).when  nil, '' }
     end
 
     context "when the city is set" do
-      before { subject.address_city = "foo" }
+      before { subject.city = "foo" }
 
-      it('the street should not be valid when blank')   { should_not have_valid(:address_street_and_premises).when   nil, '' }
-      it('the state should not be valid when blank')    { should_not have_valid(:address_state_or_province).when     nil, '' }
-      it('the zip code should not be valid when blank') { should_not have_valid(:address_postal_code).when           nil, '' }
+      it('the street should not be valid when blank')   { should_not have_valid(:street_and_premises).when   nil, '' }
+      it('the state should not be valid when blank')    { should_not have_valid(:state).when                 nil, '' }
+      it('the zip code should not be valid when blank') { should_not have_valid(:postal_code).when           nil, '' }
     end
 
     context "when the state is set" do
-      before { subject.address_state_or_province= "FO" }
+      before { subject.state = "FO" }
 
-      it('the street should not be valid when blank')   { should_not have_valid(:address_street_and_premises).when   nil, '' }
-      it('the city should not be valid when blank')     { should_not have_valid(:address_city).when                  nil, '' }
-      it('the zip code should not be valid when blank') { should_not have_valid(:address_postal_code).when           nil, '' }
+      it('the street should not be valid when blank')   { should_not have_valid(:street_and_premises).when   nil, '' }
+      it('the city should not be valid when blank')     { should_not have_valid(:city).when                  nil, '' }
+      it('the zip code should not be valid when blank') { should_not have_valid(:postal_code).when           nil, '' }
     end
 
     context "when the zip is set" do
-      before { subject.address_postal_code = "12345" }
+      before { subject.postal_code = "12345" }
 
-      it('the street should not be valid when blank')   { should_not have_valid(:address_street_and_premises).when   nil, '' }
-      it('the city should not be valid when blank')     { should_not have_valid(:address_city).when                  nil, '' }
-      it('the state should not be valid when blank')    { should_not have_valid(:address_state_or_province).when     nil, '' }
+      it('the street should not be valid when blank')   { should_not have_valid(:street_and_premises).when   nil, '' }
+      it('the city should not be valid when blank')     { should_not have_valid(:city).when                  nil, '' }
+      it('the state should not be valid when blank')    { should_not have_valid(:state).when                 nil, '' }
     end
   end
 
@@ -97,55 +98,55 @@ describe 'Pinpoint::Validations' do
     subject { UnvalidatablePinpointable.new }
 
     describe '#address_name' do
-      it { should     have_valid(:address_name).when                    ('*' * 141)                }
+      it { should     have_valid(:address_name).when                ('*' * 141)      }
     end
 
-    describe '#address_state_or_province' do
-      it { should     have_valid(:address_street_and_premises).when     ('*' * 256)                }
+    describe '#address_state' do
+      it { should     have_valid(:address_street_and_premises).when ('*' * 256)      }
     end
 
     describe '#address_city' do
-      it { should     have_valid(:address_city).when                    ('*' * 61)                 }
+      it { should     have_valid(:address_city).when                ('*' * 61)       }
     end
 
     describe '#address_street_and_premises' do
-      it { should     have_valid(:address_state_or_province).when       'WP', 'NI', 'PO'           }
+      it { should     have_valid(:address_state).when               'WP', 'NI', 'PO' }
     end
 
     describe '#address_postal_code' do
-      it { should     have_valid(:address_postal_code).when             'asdf', '123456'           }
+      it { should     have_valid(:address_postal_code).when         'asdf', '123456' }
     end
 
     context "when the street address is set" do
       before { subject.address_street_and_premises = "foo" }
 
-      it('the city should not be valid when blank')     { should have_valid(:address_city).when                  nil, '' }
-      it('the state should not be valid when blank')    { should have_valid(:address_state_or_province).when     nil, '' }
-      it('the zip code should not be valid when blank') { should have_valid(:address_postal_code).when           nil, '' }
+      it('the city should not be valid when blank')     { should have_valid(:address_city).when         nil, '' }
+      it('the state should not be valid when blank')    { should have_valid(:address_state).when        nil, '' }
+      it('the zip code should not be valid when blank') { should have_valid(:address_postal_code).when  nil, '' }
     end
 
     context "when the city is set" do
       before { subject.address_city = "foo" }
 
-      it('the street should not be valid when blank')   { should have_valid(:address_street_and_premises).when   nil, '' }
-      it('the state should not be valid when blank')    { should have_valid(:address_state_or_province).when     nil, '' }
-      it('the zip code should not be valid when blank') { should have_valid(:address_postal_code).when           nil, '' }
+      it('the street should not be valid when blank')   { should have_valid(:address_street_and_premises).when  nil, '' }
+      it('the state should not be valid when blank')    { should have_valid(:address_state).when                nil, '' }
+      it('the zip code should not be valid when blank') { should have_valid(:address_postal_code).when          nil, '' }
     end
 
     context "when the state is set" do
-      before { subject.address_state_or_province= "FO" }
+      before { subject.address_state = "FO" }
 
-      it('the street should not be valid when blank')   { should have_valid(:address_street_and_premises).when   nil, '' }
-      it('the city should not be valid when blank')     { should have_valid(:address_city).when                  nil, '' }
-      it('the zip code should not be valid when blank') { should have_valid(:address_postal_code).when           nil, '' }
+      it('the street should not be valid when blank')   { should have_valid(:address_street_and_premises).when  nil, '' }
+      it('the city should not be valid when blank')     { should have_valid(:address_city).when                 nil, '' }
+      it('the zip code should not be valid when blank') { should have_valid(:address_postal_code).when          nil, '' }
     end
 
     context "when the zip is set" do
       before { subject.address_postal_code = "12345" }
 
-      it('the street should not be valid when blank')   { should have_valid(:address_street_and_premises).when   nil, '' }
-      it('the city should not be valid when blank')     { should have_valid(:address_city).when                  nil, '' }
-      it('the state should not be valid when blank')    { should have_valid(:address_state_or_province).when     nil, '' }
+      it('the street should not be valid when blank')   { should have_valid(:address_street_and_premises).when  nil, '' }
+      it('the city should not be valid when blank')     { should have_valid(:address_city).when                 nil, '' }
+      it('the state should not be valid when blank')    { should have_valid(:address_state).when                nil, '' }
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pinpoint
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-18 00:00:00.000000000 Z
+date: 2013-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -86,6 +86,7 @@ extra_rdoc_files:
 - LICENSE
 files:
 - lib/pinpoint/address.rb
+- lib/pinpoint/composable.rb
 - lib/pinpoint/config/formats/us.yml
 - lib/pinpoint/config/patterns.rb
 - lib/pinpoint/config/us_states.rb
@@ -99,6 +100,7 @@ files:
 - lib/pinpoint/format/tokenizer.rb
 - lib/pinpoint/format.rb
 - lib/pinpoint/formatter.rb
+- lib/pinpoint/model_support.rb
 - lib/pinpoint/validations.rb
 - lib/pinpoint/version.rb
 - lib/pinpoint.rb
@@ -115,7 +117,7 @@ files:
 - spec/format/tokenizer_spec.rb
 - spec/format_spec.rb
 - spec/formatter_spec.rb
-- spec/pinpoint_spec.rb
+- spec/model_support_spec.rb
 - spec/spec_helper.rb
 - spec/support/focused.rb
 - spec/support/pending.rb
@@ -156,7 +158,7 @@ test_files:
 - spec/format/tokenizer_spec.rb
 - spec/format_spec.rb
 - spec/formatter_spec.rb
-- spec/pinpoint_spec.rb
+- spec/model_support_spec.rb
 - spec/spec_helper.rb
 - spec/support/focused.rb
 - spec/support/pending.rb

data/spec/pinpoint_spec.rb

@@ -1,86 +0,0 @@
-require 'rspectacular'
-require 'pinpoint'
-
-class Pinpointable
-  include Pinpoint
-
-  attr_accessor :address_name,
-                :address_street_and_premises,
-                :address_city,
-                :address_state_or_province,
-                :address_postal_code,
-                :address_country
-
-  pinpoint :address
-end
-
-describe 'Pinpoint' do
-  let(:pinpointable) { Pinpointable.new }
-
-  describe '.pinpoint' do
-    it 'creates a method to access the address' do
-      pinpointable.respond_to?(:address).should be_true
-    end
-
-    it 'creates a method to set the address' do
-      pinpointable.respond_to?(:address=).should be_true
-    end
-  end
-
-  describe '#address' do
-    it 'is a Pinpoint::Address' do
-      pinpointable.address.should be_a Pinpoint::Address
-    end
-
-    context 'when the object has address information set' do
-      before do
-        pinpointable.address_name                 = 'The TARDIS'
-        pinpointable.address_street_and_premises  = '413 Citadel Drive'
-        pinpointable.address_city                 = 'Panopticon'
-        pinpointable.address_state_or_province    = 'Eye of Harmony'
-        pinpointable.address_postal_code          = '12345'
-      end
-
-      it 'has the correct address components' do
-        pinpointable.address.name.should      eql 'The TARDIS'
-        pinpointable.address.street.should    eql '413 Citadel Drive'
-        pinpointable.address.city.should      eql 'Panopticon'
-        pinpointable.address.state.should     eql 'Eye of Harmony'
-        pinpointable.address.county.should    eql ''
-        pinpointable.address.zip_code.should  eql '12345'
-        pinpointable.address.latitude.should  eql ''
-        pinpointable.address.longitude.should eql ''
-      end
-    end
-  end
-
-  describe '#address=' do
-    context 'when the object has address information set' do
-      before do
-        pinpointable.address_name                 = 'The TARDIS'
-        pinpointable.address_street_and_premises  = '413 Citadel Drive'
-        pinpointable.address_city                 = 'Panopticon'
-        pinpointable.address_state_or_province    = 'Eye of Harmony'
-        pinpointable.address_postal_code          = '12345'
-      end
-
-      it 'overrides the current address information with that stored in the Pinpoint::Address' do
-        pinpointable.address = Pinpoint::Address.new(
-          name:       'Buckingham Palace',
-          street:     '',
-          city:       'City of Westminster',
-          state:      'London',
-          zip_code:   'SW1A',
-          country:    'United Kingdom'
-        )
-
-        pinpointable.address_name.should                eql        'Buckingham Palace'
-        pinpointable.address_street_and_premises.should eql        ''
-        pinpointable.address_city.should                eql        'City of Westminster'
-        pinpointable.address_state_or_province.should   eql        'London'
-        pinpointable.address_postal_code.should         eql        'SW1A'
-        pinpointable.address_country.should             eql        'United Kingdom'
-      end
-    end
-  end
-end