address_concern 2.0.1 → 2.1.0

data/{lib/address_concern → app/models/concerns}/address_associations.rb

@@ -1,3 +1,4 @@
+# Comparable to the ActsAsAddressable concern of effective_addresses.
 module AddressConcern::AddressAssociations
   extend ActiveSupport::Concern
   module ClassMethods
@@ -10,6 +11,7 @@ module AddressConcern::AddressAssociations
     # 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'
@@ -36,27 +38,46 @@ module AddressConcern::AddressAssociations
       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
+    # Creates a has_one +address+ association. If you don't give a name, it will just be called
+    # "address", which can be used if this record only needs to be associated with a single address.
+    #
+    # If you need it to be associated with multiple address records, pass the name/type of each. For
+    # example:
+    #
+    #   has_address :billing
+    #
+    def has_address(type = nil)
+      has_one address_name_for_type(type), -> { where({address_type: type}) }, class_name: 'Address', as: :addressable
+      create_addressable_association_on_address_if_needed
+    end
+
+    def address_name_for_type(type)
+      if type
+        :"#{type}_address"
+      else
+        :address
+      end
     end
 
     # Creates a has_many +addresses+ association, representing all addresses associated with the current record
-    def has_addresses(options = {})
+    #
+    # If +types+ is given, adds a has_address(type) association for each type.
+    #
+    # Comparable to acts_as_addressable from effective_addresses.
+    #
+    def has_addresses(types = [])
       has_many :addresses, as: :addressable
-      (options[:types] || ()).each do |type|
-        has_one :"#{type}_address", -> { where({address_type: type}) }, class_name: 'Address', as: :addressable
+      (types || []).each do |type|
+        has_address(type)
       end
-      create_addressable_association_on_address
+      create_addressable_association_on_address_if_needed
     end
 
-    def create_addressable_association_on_address
+    def create_addressable_association_on_address_if_needed(**options)
       Address.class_eval do
-        unless reflect_on_association(:addressable)
-          belongs_to :addressable, :polymorphic => true
-        end
+        return if reflect_on_association(:addressable)
       end
+      Address.belongs_to_addressable(**options)
     end
   end
 end

data/app/models/concerns/attributes_slice.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module AddressConcern
+module AttributesSlice
+  extend ActiveSupport::Concern
+
+  # Returns a hash containing the attributes with the keys passed in, similar to
+  # attributes.slice(*attr_names).
+  #
+  # This lets you use a list of attr_names as symbols to get a subset of attributes.
+  # Because writing attributes.symbolize_keys.slice is too long.
+  #
+  # Unlike with attributes.slice, these "attributes" can be any instance method of the receiver;
+  # they don't have to be present in the `attributes` hash itself. (The `attributes` hash only
+  # includes columns in the associated table, not "virtual attributes" that are available only as
+  # Ruby methods and not present as columns in the table. attributes.slice also doesn't let you
+  # access the attributes via any attribute aliases you've added.)
+  #
+  # If you _don't_ want to include virtual attributes, pass include_virtual: false.
+  #
+  # Examples:
+  #   attributes_slice
+  #   => {}
+  #
+  #   attributes_slice(:name, :age, :confirmed?)
+  #   => {:name => 'First Last', :age => 42, :confirmed? => true}
+  #
+  #   attributes_slice(:name, is_confirmed: :confirmed?)
+  #   => {:name => 'First Last', :is_confirmed => true}
+  #
+  #   attributes_slice(:name, is_confirmed: -> { _1.confirmed? })
+  #   => {:name => 'First Last', :is_confirmed => true}
+  #
+  def attributes_slice(*attr_names, include_virtual: true, **hash)
+    hash.transform_values { |_proc|
+      _proc.to_proc.call(self)
+    }.reverse_merge(
+      if include_virtual
+        attr_names.each_with_object({}.with_indifferent_access) do |attr_name, hash|
+          hash[attr_name] = send(attr_name)
+        end
+      else
+        # When we only want "real" attributes
+        attributes.symbolize_keys.slice(*keys.map(&:to_sym)).with_indifferent_access
+      end
+    )
+  end
+  alias_method :read_attributes, :attributes_slice
+
+  def attributes_except(*keys)
+    attributes.symbolize_keys.except(*keys.map(&:to_sym))
+  end
+end
+end

data/app/models/concerns/inspect_base.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module AddressConcern
+module InspectBase
+  def inspect_base(*_items, class: true, id: true)
+    items = _items.map { |item|
+      if item.is_a?(Hash)
+        item.map { |k, v|
+          "#{k}: #{v}"
+        }.join(', ')
+      elsif item.respond_to?(:to_proc) && item.to_proc.arity <= 0
+        item.to_proc.(self)
+      else
+        item.to_s
+      end
+    }
+
+    _class = binding.local_variable_get(:class)
+    _id    = binding.local_variable_get(:id)
+
+    '<' +
+    [
+      (_class == true ? self.class : _class),
+      ("#{self.id || 'new'}:" if _id),
+    ].join(' ') + ' ' +
+    [
+      *items,
+    ].filter_map(&:presence).map(&:to_s).join(', ') +
+    '>'
+  end
+end
+end

data/config/address_concern.rb

@@ -0,0 +1,3 @@
+#AddressConcern.setup do |config|
+  # ...
+#end

data/lib/address_concern/attribute_normalizer.rb

@@ -1,9 +1,13 @@
-require 'attribute_normalizer'
-require 'facets/string/cleanlines'
+if false
+  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")
+  require_relative '../core_extensions/string/cleanlines'
+  using String::Cleanlines
+
+  AttributeNormalizer.configure do |config|
+    config.normalizers[:cleanlines] = ->(input, options) {
+      input.to_s.cleanlines.to_a.join("\n")
+    }
   end
 end
-

data/lib/address_concern/engine.rb

@@ -0,0 +1,24 @@
+# This file is based on effective_addresses/lib/effective_addresses/engine.rb
+
+module AddressConcern
+  class Engine < ::Rails::Engine
+    engine_name 'address_concern'
+
+    config.autoload_paths   += Dir["#{config.root}/app/models/concerns"]
+    config.eager_load_paths += Dir["#{config.root}/app/models/concerns"]
+
+    initializer 'address_concern.active_record' do |app|
+      ActiveSupport.on_load :active_record do
+        # These are currently required from lib/address_concern.rb
+        AddressConcern::Address::Base
+        AddressConcern::AddressAssociations
+        # ActiveRecord::Base.extend(AddressConcern::Address::Base)
+      end
+    end
+
+    # Set up our default configuration options.
+    #initializer 'address_concern.defaults', before: :load_config_initializers do |app|
+    #  eval File.read("#{config.root}/config/address_concern.rb")
+    #end
+  end
+end

data/lib/address_concern/version.rb

@@ -1,5 +1,5 @@
 module AddressConcern
   def self.version
-    "2.0.1"
+    "2.1.0"
   end
 end

data/lib/address_concern.rb

@@ -1,11 +1,12 @@
 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'
+require 'address_concern/engine'
+
+require_relative '../app/models/concerns/address'
+require_relative '../app/models/concerns/address_associations'

data/lib/core_extensions/hash/reorder.rb

@@ -0,0 +1,11 @@
+module Hash::Reorder
+  refine Hash do
+    def reorder(*order)
+      slice(*order).merge except(*order)
+    end
+
+    def reorder!(*order)
+      replace(reorder(*order))
+    end
+  end
+end

data/lib/core_extensions/string/cleanlines.rb

@@ -0,0 +1,28 @@
+module String::Cleanlines
+  refine String do
+    # Copied from acets/string/cleanlines.rb
+
+    # Returns an Enumerator for iterating over each
+    # line of the string, stripped of whitespace on
+    # either side.
+    #
+    #   "this\nthat\nother\n".cleanlines.to_a  #=> ['this', 'that', 'other']
+    #
+    def cleanlines(&block)
+      if block
+        scan(/^.*?$/) do |line|
+          block.call(line.strip)
+        end
+      else
+        str = self
+        Enumerator.new do |output|
+          str.scan(/^.*?$/) do |line|
+            output.yield(line.strip)
+          end
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -4,16 +4,20 @@ class CreateAddresses < ActiveRecord::Migration[4.2]
       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_code
       t.string   :state
       t.string   :postal_code
+      t.string   :country_code
       t.string   :country
-      t.string   :country_alpha2
-      t.string   :country_alpha3
-      t.string   :email
-      t.string   :phone
+
+      # You could add other columns, such as these, but they are arguably not technically part of an
+      # address. In any case, they are outside the scope of this library.
+      #t.string   :name
+      #t.string   :email
+      #t.string   :phone
+
       t.timestamps
     end
 
@@ -21,13 +25,13 @@ class CreateAddresses < ActiveRecord::Migration[4.2]
       t.index  :addressable_id
       t.index  :addressable_type
       t.index  :address_type
-      t.index  :name
+
+      #t.index  :city
+      t.index  :state_code
       t.index  :state
+      #t.index  :postal_code
+      t.index  :country_code
       t.index  :country
-      t.index  :country_alpha2
-      t.index  :country_alpha3
-      t.index  :email
-      t.index  :phone
     end
   end
 

data/spec/models/acts_as_address_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe 'acts_as_address' do
+  def klass
+    described_class
+  end
+
+  # These models' table only have a single column for state and country.
+  # This tests both the default (zero-config) behavior and how the same column can be used for
+  # non-default (name or code).
+  describe AddressWithNameOnly do
+    it do
+      expect(klass.state_name_attribute).to eq :state
+      expect(klass.state_code_attribute).to eq nil
+      expect(klass.country_name_attribute).to eq :country
+      expect(klass.country_code_attribute).to eq nil
+    end
+  end
+
+  describe AddressWithCodeOnly do
+    it do
+      expect(klass.state_name_attribute).to eq  nil
+      expect(klass.state_code_attribute).to eq :state
+      expect(klass.country_name_attribute).to eq nil
+      expect(klass.country_code_attribute).to eq :country
+    end
+  end
+
+  # You can't use the same column for both name and code. If config tries to do that, which one
+  # takes precedence?
+  describe 'name_attribute == code_attribute' do
+    let(:klass) do
+      Class.new(ApplicationRecord) do
+        self.table_name = 'addresses'
+        acts_as_address(
+          country: {
+            name_attribute: 'country',
+            code_attribute: 'country',
+          }
+        )
+      end
+    end
+    let(:address) { klass.new }
+    it 'name takes precedence' do
+      expect(klass.country_name_attribute).to eq :country
+      expect(klass.country_code_attribute).to eq nil
+    end
+  end
+
+  describe 'address lines' do
+    describe Address do
+      it do
+        expect(klass.multi_line_address?).to eq true
+        expect(klass.address_attributes).to eq [:address]
+      end
+    end
+
+    describe AddressWithSeparateAddressColumns do
+      it do
+        expect(klass.multi_line_address?).to eq false
+        expect(klass.address_attributes).to eq [:address_1, :address_2, :address_3]
+      end
+    end
+  end
+end
+