address_concern 2.0.0

data/lib/address_concern/address_associations.rb

@@ -0,0 +1,66 @@
+module AddressConcern::AddressAssociations
+  extend ActiveSupport::Concern
+  module ClassMethods
+    # Creates a belongs_to +address+ association, named "address" by default but a different name may be
+    # provided. In the Address model, creates an inverse association unless you pass +inverse: false+.
+    #
+    # You can pass options to the belongs_to, like this:
+    #   belongs_to_address :work_address, dependent: :destroy
+    #
+    # You can also pass options to the inverse has_one assocation in the Address model, via the
+    # +inverse+ option:
+    #   belongs_to_address :home_address, inverse: {foreign_key: :physical_address_id}
+    def belongs_to_address(name = :address, inverse: nil, **options)
+      options.reverse_merge!({
+        class_name: 'Address'
+      })
+      raise "association :#{name} already exists on #{self}" if reflect_on_association(name)
+      belongs_to name, **options
+      #puts %(reflect_on_association(#{name})=#{reflect_on_association(name).inspect})
+
+      unless inverse == false
+        inverse ||= {}
+        inverse.reverse_merge!({
+          name:        self.name.underscore.to_sym,
+          inverse_of:  name,
+          class_name:  self.name,
+          foreign_key: "#{name}_id",
+        })
+        name       = inverse.delete(:name)
+        inverse_of = inverse.delete(:inverse_of)
+        Address.class_eval do
+          raise "association :#{name} already exists on #{self}" if reflect_on_association(name)
+          has_one name, inverse_of: inverse_of, **inverse
+          #puts %(reflect_on_association(#{name})=#{reflect_on_association(name).inspect})
+        end
+      end
+    end
+
+    # Creates a has_one +address+ association, representing the one and only address associated with the current record
+    def has_address
+      has_one :address, as: :addressable
+      create_addressable_association_on_address
+    end
+
+    # Creates a has_many +addresses+ association, representing all addresses associated with the current record
+    def has_addresses(options = {})
+      has_many :addresses, as: :addressable
+      (options[:types] || ()).each do |type|
+        has_one :"#{type}_address", -> { where({address_type: type}) }, class_name: 'Address', as: :addressable
+      end
+      create_addressable_association_on_address
+    end
+
+    def create_addressable_association_on_address
+      Address.class_eval do
+        unless reflect_on_association(:addressable)
+          belongs_to :addressable, :polymorphic => true
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include AddressConcern::AddressAssociations
+end

data/lib/address_concern/attribute_normalizer.rb

@@ -0,0 +1,9 @@
+require 'attribute_normalizer'
+require 'facets/string/cleanlines'
+
+AttributeNormalizer.configure do |config|
+  config.normalizers[:cleanlines] = lambda do |input, options|
+    input.to_s.cleanlines.to_a.join("\n")
+  end
+end
+

data/lib/address_concern/version.rb

@@ -0,0 +1,5 @@
+module AddressConcern
+  def self.version
+    "2.0.0"
+  end
+end

data/lib/address_concern.rb

@@ -0,0 +1,11 @@
+require 'rails'
+require 'carmen'
+require 'active_record'
+require 'active_record_ignored_attributes'
+
+Carmen.i18n_backend.append_locale_path File.join(File.dirname(__FILE__), '../config/locale/overlay/en')
+
+require 'address_concern/version'
+require 'address_concern/attribute_normalizer'
+require_relative 'address_concern/address'
+require_relative 'address_concern/address_associations'

data/lib/generators/address_concern/install_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators'
+module AddressConcern
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+
+     def self.source_root
+        @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+     end
+ 
+     def self.next_migration_number(dirname)
+      if ActiveRecord::Base.timestamped_migrations
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+ 
+    def create_migration_file
+      migration_template 'migration.rb', 'db/migrate/create_addresses.rb'
+    end
+  end
+end

data/lib/generators/address_concern/templates/configurable.yml

@@ -0,0 +1,33 @@
+# This file controls what config variables you want to be able to allow your users
+# to set, as well as those you'll be able to access from within the application.
+# 
+# If you want to be able to access a string config[:site_title], for example:
+#   
+# site_title:
+#   name: Site Title
+#   type: string
+#   default: My Site
+#   
+# 'name' is the name that appears in the edit form
+# 
+# 'type' can be 'string' for a text field, 'password' for a password field or 'text' for a text area
+#   'type' defaults to 'string'
+# 
+# 'default' is the default value to use if there's no entry in the database. Otherwise, nil will be returned
+# 
+# Some Examples:
+#   
+# site_title:
+#   name: Site Title
+#   default: My Site
+#   type: string
+#   
+# site_description:
+#   name: Description for Google
+#   default: Lots of Awesomeness Here
+#   type: text
+#   
+# secret:
+#   name: Secret Password for Accessing Secret Areas
+#   default: secret
+#   type: password

data/lib/generators/address_concern/templates/migration.rb

@@ -0,0 +1,37 @@
+class CreateAddresses < ActiveRecord::Migration[4.2]
+  def self.up
+    create_table :addresses do |t|
+      t.references :addressable, :polymorphic => true
+      t.string   :address_type   # to allow shipping/billing/etc. address
+
+      t.string   :name
+      t.text     :address
+      t.string   :city
+      t.string   :state
+      t.string   :postal_code
+      t.string   :country
+      t.string   :country_alpha2
+      t.string   :country_alpha3
+      t.string   :email
+      t.string   :phone
+      t.timestamps
+    end
+
+    change_table :addresses do |t|
+      t.index  :addressable_id
+      t.index  :addressable_type
+      t.index  :address_type
+      t.index  :name
+      t.index  :state
+      t.index  :country
+      t.index  :country_alpha2
+      t.index  :country_alpha3
+      t.index  :email
+      t.index  :phone
+    end
+  end
+
+  def self.down
+    drop_table :addresses
+  end
+end

data/spec/models/address_spec.rb

@@ -0,0 +1,303 @@
+require 'spec_helper'
+
+describe Address do
+  describe 'setting country by name' do
+    let(:address) { Address.new }
+    specify 'setting to known country' do
+      address.country = 'Iceland'
+      address.country_name.should == 'Iceland'
+      address.country_code.should == 'IS'
+    end
+
+    specify 'setting to unknown country' do
+      # Set it to a known country first to show that it actually *clears* these fields if they were previously set
+      address.country = 'Iceland'
+
+      #expect { expect {
+      address.country = 'Fireland'
+      #}.to change(address, :country_name).to(nil)
+      #}.to change(address, :country_code).to(nil)
+      address.country_name.should eq nil
+      address.country_code.should eq nil
+
+      address.country = 'Northern Ireland'
+      address.country_name.should eq nil
+      address.country_code.should eq nil
+
+      address.country = 'USA'
+      address.country_name.should eq nil
+      address.country_code.should eq nil
+    end
+  end
+
+  describe 'setting country by code' do
+    let(:address) { Address.new }
+    specify 'setting to known country' do
+      address.country_code = 'IS'
+      address.country_name.should == 'Iceland'
+      address.country_code.should == 'IS'
+    end
+
+    specify 'setting to unknown country' do
+      # Set it to a known country first to show that it actually *clears* these fields if they were previously set
+      address.country_code = 'IS'
+
+      #expect { expect {
+      address.country = 'FL'
+      #}.to change(address, :country_name).to(nil)
+      #}.to change(address, :country_code).to(nil)
+      address.country_name.should eq nil
+      address.country_code.should eq nil
+    end
+
+    specify 'setting to a country that is part of another country (weird)' do
+      # Not currently possible using country_code=
+    end
+  end
+
+  describe 'country aliases:' do
+    let(:address) { Address.new }
+    ['The Democratic Republic of the Congo', 'Democratic Republic of the Congo'].each do |_| specify _ do
+      address.country = _
+      address.country_name.should           == 'Congo, The Democratic Republic of the'
+      address.country_name_from_code.should == 'Congo, The Democratic Republic of the'
+    end; end
+  end
+
+  describe 'started_filling_out?' do
+    [:address, :city, :state, :postal_code].each do |attr_name|
+      it "should be true when #{attr_name} (and only #{attr_name}) is present" do
+        Address.new(attr_name => 'something').should be_started_filling_out
+      end
+    end
+    it "should be true when country (and only country) is present" do
+      Address.new(:country => 'Latvia').should be_started_filling_out
+    end
+  end
+
+  describe 'normalization' do
+    describe 'address' do
+      it { should normalize_attribute(:address).from("  Line 1  \n    Line 2    \n    ").to("Line 1\nLine 2")}
+      [:name, :city, :state, :postal_code, :country].each do |attr_name|
+        it { should normalize_attribute(attr_name) }
+      end
+    end
+  end
+
+  describe 'parts and lines' do
+    it do
+      address = Address.new(
+        address: '10 Some Road',
+        city: 'Watford', state: 'HRT', postal_code: 'WD25 9JZ',
+        country: 'United Kingdom'
+      )
+      address.parts.should == [
+        '10 Some Road',
+        'Watford',
+        'Hertfordshire',
+        'WD25 9JZ',
+        'United Kingdom'
+      ]
+      address.lines.should == [
+        '10 Some Road',
+        'Watford WD25 9JZ',
+        'United Kingdom'
+      ]
+      address.city_line.should == 'Watford WD25 9JZ'
+      address.city_state_name.should == 'Watford, Hertfordshire'
+    end
+  end
+
+  describe '#city_state/#city_state_country' do
+    context "when address doesn't have a state" do
+      let(:user) { User.create }
+      subject { user.build_physical_address(address: '123', city: 'Stockholm', country_name: 'Sweden') }
+      it { subject.city_state_code.should    == 'Stockholm' }
+      it { subject.city_state_name.should    == 'Stockholm' }
+      it { subject.city_state_country.should == 'Stockholm, Sweden' }
+    end
+    context "when address has a state abbrevitation in :state field" do
+      let(:user) { User.create }
+      subject { user.build_physical_address(address: '123', city: 'Nelspruit', state: 'MP', country_name: 'South Africa') }
+      it { subject.city_state_code.should    == 'Nelspruit, MP' }
+      it { subject.city_state_name.should    == 'Nelspruit, Mpumalanga' }
+      it { subject.city_state_country.should == 'Nelspruit, Mpumalanga, South Africa' }
+    end
+    context "when address has a state abbrevitation in :state field (Denmark)" do
+      let(:user) { User.create }
+      subject { user.build_physical_address(address: '123', city: 'Copenhagen', state: '84', country_name: 'Denmark') }
+      it { subject.city_state_name.should    == 'Copenhagen, Hovedstaden' }
+      it { subject.state_name.should         == 'Hovedstaden' }
+    end
+
+    # United States
+    context "when address has a state name entered for :state instead of an abbreviation" do
+      let(:user) { User.create }
+      subject { user.build_physical_address(address: '123', city: 'Ocala', state: 'Florida', country_name: 'United States') }
+      it { subject.city_state_code.should    == 'Ocala, Florida' }
+      it { subject.city_state_name.should    == 'Ocala, Florida' }
+      it { subject.city_state_country.should == 'Ocala, Florida, United States' }
+    end
+    context "when address has a state abbrevitation in :state field" do
+      let(:user) { User.create }
+      subject { user.build_physical_address(address: '123', city: 'Ocala', state: 'FL', country_name: 'United States') }
+      it { subject.city_state_code.should    == 'Ocala, FL' }
+      it { subject.city_state_name.should    == 'Ocala, Florida' }
+      it { subject.city_state_country.should == 'Ocala, Florida, United States' }
+    end
+    context "when address has a state name entered for :state instead of an abbreviation, but state is for different country" do
+      let(:user) { User.create }
+      subject { user.build_physical_address(address: '123', city: 'Ocala', state: 'FL', country_name: 'Denmark') }
+      it { subject.city_state_code.should    == 'Ocala, FL' }
+      it { subject.city_state_name.should    == 'Ocala, FL' }
+      it { subject.city_state_country.should == 'Ocala, FL, Denmark' }
+    end
+  end
+
+  describe 'same_as?' do
+    it 'should be true when country is only present attribute and it matches' do
+      Address.new(country: 'United States').should be_same_as(
+      Address.new(country: 'United States'))
+    end
+    it 'should be true when country and state are only present attributes and they match' do
+      Address.new(state: 'Washington', country: 'United States').should be_same_as(
+      Address.new(state: 'Washington', country: 'United States'))
+    end
+    it "not should be true when address attribute doesn't match" do
+      Address.new(address: '123 C St.', state: 'Washington', country: 'United States').should_not be_same_as(
+      Address.new(address: '444 Z St.', state: 'Washington', country: 'United States'))
+    end
+  end
+
+  describe '#carmen_country' do
+    it { Address.new(country: 'South Africa').carmen_country.should be_a Carmen::Country }
+  end
+  describe '#carmen_state' do
+    it { Address.new(country: 'United States', state: 'OH!').carmen_state.should be_nil }
+    it { Address.new(country: 'United States', state: 'OH').carmen_state.should be_a Carmen::Region }
+    it { Address.new(country: 'United States', state: 'AA').carmen_state.should be_a Carmen::Region }
+    it { Address.new(country: 'South Africa',  state: 'MP').carmen_state.should be_a Carmen::Region }
+  end
+
+  describe '#states_for_country, etc.' do
+    it { Address.new(country: 'United States').states_for_country.map(&:code).should include 'AA' }
+    it { Address.new(country: 'United States').states_for_country.map(&:name).should include 'Ohio' }
+    it { Address.new(country: 'United States').states_for_country.map(&:name).should include 'District of Columbia' }
+    it { Address.new(country: 'United States').states_for_country.map(&:name).should include 'Puerto Rico' }
+    it { Address.new(country: 'South Africa').states_for_country.map(&:name).should include 'Mpumalanga' }
+    it { Address.new(country: 'Kenya').states_for_country.typed('province').should be_empty }
+    # At the time of this writing, it doesn't look like Carmen has been updated to
+    # include the 47 counties listed under https://en.wikipedia.org/wiki/ISO_3166-2:KE.
+    #it { Address.new(country: 'Kenya').states_for_country.map(&:name).should include 'Nyeri' }
+    it { Address.new(country: 'Denmark').state_options.should be_many }
+    it { Address.new(country: 'Denmark').state_options.map(&:name).should include 'Sjælland' }
+    it { Address.new(country: 'Denmark').state_possibly_included_in_postal_address?.should eq false }
+
+    # Auckland (AUK) is a subregion of the North Island (N) subregion
+    it { Address.new(country: 'New Zealand').state_options.map(&:code).should include 'AUK' }
+    it { Address.new(country: 'New Zealand').state_options.map(&:code).should_not include 'N' }
+    # Chatham Islands Territory (CIT) is a top-level region
+    it { Address.new(country: 'New Zealand').state_options.map(&:code).should include 'CIT' }
+
+    # Abra (ABR) is a subregion of the Cordillera Administrative Region (CAR) (15) subregion
+    it { Address.new(country: 'Philippines').state_options.map(&:code).should include 'ABR' }
+    it { Address.new(country: 'Philippines').state_options.map(&:code).should_not include '15' }
+    # National Capital Region (00) is a top-level region
+    it { Address.new(country: 'Philippines').state_options.map(&:code).should include '00' }
+
+    # https://en.wikipedia.org/wiki/Provinces_of_Indonesia
+    #   The provinces are officially grouped into seven geographical units
+    # Jawa Barat (JB) is a subregion of the Jawa (JW) subregion
+    it { Address.new(country: 'Indonesia').state_options.map(&:code).should include 'JB' }
+    it { Address.new(country: 'Indonesia').state_options.map(&:code).should_not include 'JW' }
+    # The province is not called "Jakarta Raya" according to
+    # https://en.wikipedia.org/wiki/ISO_3166-2:ID and https://en.wikipedia.org/wiki/Jakarta — it's
+    # called 'DKI Jakarta', which is short for 'Daerah Khusus Ibukota Jakarta' ('Special Capital
+    # City District of Jakarta'),
+    it { Address.new(country: 'Indonesia').state_options.map(&:name).should include 'DKI Jakarta' }
+
+    # At the time of this writing, it doesn't look like Carmen has been updated to reflect the new 18
+    # regions of France.
+    it { Address.new(country: 'France').state_options.size.should eq 0 }
+    #it { Address.new(country: 'France').state_options.size.should eq 18 }
+    #it { Address.new(country: 'France').state_options.map(&:name).should include 'Auvergne-Rhône-Alpes' }
+  end
+
+  describe 'associations' do
+    # To do (or maybe not even necessary—seems to work with only the has_one side of the association):
+    #describe 'when we have a polymorphic belongs_to :addressable in Address' do
+    #belongs_to :addressable, :polymorphic => true
+
+    describe 'Company has_one :address' do
+      let(:company) { Company.create }
+
+      it do
+        company.address.should == nil
+        address = company.build_address(address: '1')
+        company.save!
+        company.reload.address.should == address
+        address.addressable.should == company
+      end
+
+    end
+
+    describe 'User has_many :addresses' do
+      let(:user) { User.create }
+
+      it do
+        user.addresses.should == []
+        address_1 = user.addresses.build(address: '1')
+        address_2 = user.addresses.build(address: '2')
+        user.save!; user.reload
+        user.addresses.should == [address_1, address_2]
+      end
+
+      specify 'should able to set and retrieve a specific address by type (shipping or billing)' do
+        physical_address = user.build_physical_address(address: 'Physical')
+        shipping_address = user.build_shipping_address(address: 'Shipping')
+        billing_address  = user.build_billing_address( address: 'Billing')
+        vacation_address = user.addresses.build(address: 'Vacation', :address_type => 'Vacation')
+        user.save!; user.reload
+        user.physical_address.should == physical_address
+        user.shipping_address.should == shipping_address
+        user.billing_address. should == billing_address
+        user.addresses.to_set.should == [physical_address, shipping_address, billing_address, vacation_address].to_set
+        physical_address.addressable.should == user
+        shipping_address.addressable.should == user
+        billing_address .addressable.should == user
+      end
+    end
+
+    describe 'Employee belongs_to :home_address' do
+      subject!(:employee) { Employee.create! }
+
+      it do
+        employee.home_address.should == nil
+        employee.work_address.should == nil
+        home_address = employee.build_home_address(address: '1')
+        work_address = employee.build_work_address(address: '2')
+        employee.save!
+        employee.reload.home_address.should == home_address
+        employee.reload.work_address.should == work_address
+        home_address.employee_home.should == employee
+        work_address.employee_work.should == employee
+      end
+    end
+
+    describe 'Child belongs_to :secret_hideout' do
+      subject!(:child) { Child.create! }
+
+      it do
+        child.address.       should == nil
+        child.secret_hideout.should == nil
+        address        = child.build_address(address: '2')
+        secret_hideout = child.build_secret_hideout(address: '1')
+        child.save!
+        child.reload.address.       should == address
+        child.reload.secret_hideout.should == secret_hideout
+        address.       child.                   should == child
+        secret_hideout.child_for_secret_hideout.should == child
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require 'bundler'
+require 'bundler/setup'
+Bundler.require(:default, :development)
+
+#---------------------------------------------------------------------------------------------------
+
+__DIR__ = Pathname.new(__FILE__).dirname
+$LOAD_PATH.unshift __DIR__
+$LOAD_PATH.unshift __DIR__ + '../lib'
+
+#---------------------------------------------------------------------------------------------------
+# ActiveRecord
+
+require 'active_record'
+
+log_file_path = __DIR__ + 'test.log'
+log_file_path.truncate(0) rescue nil
+ActiveRecord::Base.logger = Logger.new(log_file_path)
+
+driver = (ENV["DB"] or "sqlite3").downcase
+database_config = YAML::load(File.open(__DIR__ + "support/database.#{driver}.yml"))
+ActiveRecord::Base.establish_connection(database_config)
+
+require __DIR__ + 'support/schema'
+require 'generators/address_concern/templates/migration'
+CreateAddresses.up
+
+#---------------------------------------------------------------------------------------------------
+# RSpec
+
+require 'rspec'
+
+require 'active_record_ignored_attributes/matchers'
+
+
+RSpec.configure do |config|
+  config.include AttributeNormalizer::RSpecMatcher #, :type => :models
+  config.expect_with(:rspec) { |c| c.syntax = :should }
+  config.example_status_persistence_file_path = "tmp/rspec_status.txt"
+end
+
+require 'address_concern'
+
+require_relative 'support/models/application_record'
+require_relative 'support/models/address'
+
+# Requires supporting ruby files in spec/support/
+Dir[__DIR__ + 'support/**/*.rb'].each do |f|
+  require f
+end

data/spec/support/database.mysql2.yml

@@ -0,0 +1,3 @@
+adapter: mysql2
+database: address_concern_test
+username: root

data/spec/support/database.sqlite3.yml

@@ -0,0 +1,2 @@
+adapter: sqlite3
+database: ":memory:"

data/spec/support/models/address.rb

@@ -0,0 +1,3 @@
+class Address < ApplicationRecord
+  include AddressConcern::Address
+end

data/spec/support/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/spec/support/models/child.rb

@@ -0,0 +1,4 @@
+class Child < ApplicationRecord
+  belongs_to_address
+  belongs_to_address :secret_hideout, inverse: {name: :child_for_secret_hideout}
+end

data/spec/support/models/company.rb

@@ -0,0 +1,3 @@
+class Company < ApplicationRecord
+  has_address
+end

data/spec/support/models/employee.rb

@@ -0,0 +1,4 @@
+class Employee < ApplicationRecord
+  belongs_to_address :home_address, foreign_key: :physical_address_id, inverse: {name: :employee_home, foreign_key: :physical_address_id}
+  belongs_to_address :work_address, dependent: :destroy,               inverse: {name: :employee_work}
+end

data/spec/support/models/user.rb

@@ -0,0 +1,3 @@
+class User < ApplicationRecord
+  has_addresses :types => [:physical, :shipping, :billing]
+end

data/spec/support/schema.rb

@@ -0,0 +1,19 @@
+ActiveRecord::Schema.define do
+  create_table :users, :force => true do |t|
+    t.string :name
+  end
+  create_table :employees, :force => true do |t|
+    t.string :name
+    t.belongs_to :physical_address
+    t.belongs_to :work_address
+  end
+  create_table :companies, :force => true do |t|
+    t.string :name
+  end
+  create_table :children, :force => true do |t|
+    t.string :name
+    t.belongs_to :address
+    t.belongs_to :secret_hideout
+  end
+end
+