isomorphic 0.1.0

data/lib/isomorphic/factory.rb

@@ -0,0 +1,173 @@
+require "isomorphic/errors"
+
+module Isomorphic
+  # Generic base class for Isomorphic factory errors.
+  #
+  # @abstract
+  class FactoryError < Isomorphic::IsomorphicError
+  end
+
+  # Raised when an Isomorphic factory cannot find a class.
+  class InvalidFactoryClass < Isomorphic::FactoryError
+    # @!attribute [r] klass
+    #   @return [Class] the class
+    # @!attribute [r] const_name
+    #   @return [#to_sym] the constant name
+    attr_reader :klass, :const_name
+
+    # Default constructor.
+    #
+    # @param message [#to_s] the message
+    # @param base [Module] the base module
+    # @param klass [Class] the class
+    # @param const_name [#to_sym] the constant name
+    def initialize(message = nil, base, klass, const_name)
+      super(message, base)
+
+      @klass, @const_name = klass, const_name
+    end
+  end
+
+  module Factory
+    # Generic base class for Isomorphic factories.
+    #
+    # @abstract Subclass and override {#const_get} and {#xmlattrs} to implement a custom class.
+    class AbstractFactory
+      # @!attribute [r] base
+      #   @return [Module] the base module
+      attr_reader :base
+
+      # Default constructor
+      #
+      # @param base [Module] the base module
+      def initialize(base)
+        super()
+
+        @base = base
+      end
+
+      # Build a new instance of the given class.
+      #
+      # @param klass [Class] the class
+      # @param options [Hash<#to_sym, Object>] the options
+      # @option options [Hash<#to_sym, Object>] :attributes ({}) the attributes for the new instance
+      # @option options [Hash<#to_sym, #to_s>] :xmlattrs ({}) the XML attributes for the new instance
+      # @yieldparam instance [Object] the new instance
+      # @yieldreturn [void]
+      # @return [Object] the new instance
+      # @raise [Isomorphic::InvalidFactoryClass] if the given class cannot be found
+      def for(klass, **options, &block)
+        unless klass.is_a?(::Class) && (klass.parents[-2] == base)
+          raise Isomorphic::InvalidFactoryClass.new(nil, base, klass, nil)
+        end
+
+        instance = klass.new
+
+        if options.key?(:attributes)
+          update_attributes(instance, options[:attributes])
+        end
+
+        send(:xmlattrs).select { |xmlattr_name|
+          instance.respond_to?(:"xmlattr_#{xmlattr_name}=")
+        }.each do |xmlattr_name|
+          instance.send(:"xmlattr_#{xmlattr_name}=", send(:"xmlattr_#{xmlattr_name}_for", instance))
+        end
+
+        unless block.nil?
+          case block.arity
+            when 1 then block.call(instance)
+            else instance.instance_eval(&block)
+          end
+        end
+
+        instance
+      end
+
+      # Build a chain of new instances by reflecting on the instance methods for
+      # the given instance and then return the end of the chain.
+      #
+      # @param instance [Object] the instance
+      # @param method_names [Array<#to_sym>] the method names
+      # @param options [Hash<#to_sym, Object>] the options
+      # @option options [Boolean] :try (false) return +nil+ if any receiver in the chain is blank
+      # @option options [Hash<#to_sym, Object>] :attributes ({}) the attributes for the new instance
+      # @option options [Hash<#to_sym, #to_s>] :xmlattrs ({}) the XML attributes for the new instance
+      # @return [Object, nil] the new instance or +nil+
+      # @raise [Isomorphic::InvalidFactoryClass] if any class in the chain cannot be found
+      def path(instance, *method_names, **options)
+        method_names.inject([instance.class, instance]) { |pair, method_name|
+          orig_class, orig_instance = *pair
+
+          if orig_instance.nil? && options[:try]
+            [::NilClass, orig_instance]
+          else
+            s = method_name.to_s
+            const_name = s[0].upcase.concat(s[1..-1])
+
+            new_class = const_get(base, instance_class, const_name)
+
+            unless new_class.is_a?(::Class)
+              raise Isomorphic::InvalidFactoryClass.new(nil, base, orig_class, const_name)
+            end
+
+            new_instance = orig_instance.send(method_name) || (options[:try] ? nil : orig_instance.send(:"#{method_name}=", send(:for, new_class)))
+
+            [new_class, new_instance]
+          end
+        }[1]
+      end
+
+      # Is the chain of instances present?
+      #
+      # @param instance [Object] the instance
+      # @param method_names [Array<#to_sym>] the method names
+      # @return [Boolean] +true+ if the chain of instances is present; otherwise, +false+
+      # @raise [Isomorphic::InvalidFactoryClass] if any class in the chain cannot be found
+      def path?(instance, *method_names)
+        !path(instance, *method_names, try: true).nil?
+      end
+
+      # Updates the attributes of the instance from the passed-in hash.
+      #
+      # @param instance [Object] the instance
+      # @param attributes [Hash<#to_sym, Object>] the attributes
+      # @return [void]
+      #
+      # @note Before assignment, attributes from the passed-in hash are duplicated.
+      def update_attributes(instance, attributes = {})
+        attributes.each do |method_name, value|
+          instance.send(:"#{method_name}=", ::Marshal.load(::Marshal.dump(value)))
+        end
+
+        return
+      end
+
+      # Returns the array of XML attribute names that are accepted by this factory.
+      #
+      # @return [Array<#to_sym>] the XML attribute names
+      #
+      # @note For each XML attribute name, e.g., +name+, a corresponding instance method +#xmlattr_{name}_for(instance)+ must be defined.
+      def xmlattrs
+        []
+      end
+
+      protected
+
+      # Checks for a constant with the given name in the base module.
+      #
+      # @param base [Module] the base module
+      # @param klass [Class] the class
+      # @param const_name [#to_sym] the constant name
+      # @return [Class, Module, nil] the constant with the given name or +nil+ if not defined
+      #
+      # @note Subclasses override this instance method to implement custom dereferencing strategies for constants.
+      def const_get(base, klass, const_name)
+        if klass.const_defined?(const_name)
+          klass.const_get(const_name)
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/isomorphic/hash_with_indifferent_access.rb

@@ -0,0 +1,62 @@
+require "active_support/hash_with_indifferent_access"
+
+module Isomorphic
+  # Implements a hash where keys +:foo+, +"foo"+ and +Foo+ are considered to be the same.
+  class HashWithIndifferentAccess < ::ActiveSupport::HashWithIndifferentAccess
+    # @!attribute [r] inflector
+    #   @return [Isomorphic::Inflector::AbstractInflector] the inflector
+    attr_reader :inflector
+
+    # Default constructor.
+    #
+    # @param inflector [Isomorphic::Inflector::AbstractInflector] the inflector
+    # @param constructor [Hash, #to_hash] the hash or constructor for a hash
+    # @raise [Isomorphic::InflectorError] if a key in the hash or the constructor for the hash is invalid
+    def initialize(inflector, constructor = {})
+      @inflector = inflector
+
+      super(constructor)
+    end
+
+    # Same as {Hash#[]} where the key passed as argument can be either a string, a symbol or a class.
+    #
+    # @param key [Object] the key
+    # @return [Object] the value
+    # @raise [Isomorphic::InflectorError] if the key is invalid
+    def [](key)
+      super(convert_key(key))
+    end
+
+    # Same as {Hash#assoc} where the key passed as argument can be either a string, a symbol or a class.
+    #
+    # @param key [Object] the key
+    # @return [Array<Object>, nil] the key-value pair or +nil+ if the key is not present
+    # @raise [Isomorphic::InflectorError] if the key is invalid
+    def assoc(key)
+      super(convert_key(key))
+    end
+
+    if ::Hash.new.respond_to?(:dig)
+      # Same as {Hash#dig} where the key passed as argument can be either a string, a symbol or a class.
+      #
+      # @param args [Array<Object>] the keys
+      # @return [Object, nil] the value or nil
+      # @raise [Isomorphic::InflectorError] if a key is invalid
+      def dig(*args)
+        args[0] = convert_key(args[0]) if args.size > 0
+        super(*args)
+      end
+    end
+
+    private
+
+    # Inflect upon the given key.
+    #
+    # @param key [Object] the key
+    # @return [String] the inflected key
+    # @raise [Isomorphic::InflectorError] if the key is invalid
+    def convert_key(key)
+      inflector.isomorphism(key)
+    end
+  end
+end

data/lib/isomorphic/inflector.rb

@@ -0,0 +1,180 @@
+require "active_support/inflector"
+
+require "isomorphic/errors"
+require "isomorphic/hash_with_indifferent_access"
+
+module Isomorphic
+  # Generic base class for Isomorphic inflector errors.
+  #
+  # @abstract
+  class InflectorError < Isomorphic::IsomorphicError
+  end
+
+  # Raised when an Isomorphic inflector cannot find a class.
+  class InvalidInflectionClass < Isomorphic::InflectorError
+    # @!attribute [r] klass
+    #   @return [Class] the class
+    attr_reader :klass
+
+    # Default constructor.
+    #
+    # @param message [#to_s] the message
+    # @param base [Module] the base module
+    # @param klass [Class] the class
+    def initialize(message = nil, base, klass)
+      super(message, base)
+
+      @klass = klass
+    end
+  end
+
+  # Raised when an Isomorphic inflector cannot find an instance method by name.
+  class InvalidInflectionMethodName < Isomorphic::InflectorError
+    # @!attribute [r] method_name
+    #   @return [#to_sym] the method name
+    attr_reader :method_name
+
+    # Default constructor.
+    #
+    # @param message [#to_s] the message
+    # @param base [Module] the base module
+    # @param method_name [#to_sym] the method name
+    def initialize(message = nil, base, method_name)
+      super(message, base)
+
+      @method_name = method_name
+    end
+  end
+
+  # Raised when an Isomorphic inflector cannot find an inflectable term.
+  class InvalidInflectionTerm < Isomorphic::InflectorError
+    # @!attribute [r] term
+    #   @return [Object] the inflectable term
+    attr_reader :term
+
+    # Default constructor.
+    #
+    # @param message [#to_s] the message
+    # @param base [Module] the base module
+    # @param term [Object] the inflectable term
+    def initialize(message = nil, base, term)
+      super(message, base)
+
+      @term = term
+    end
+  end
+
+  module Inflector
+    # Generic base class for Isomorphic inflectors.
+    #
+    # @abstract
+    class AbstractInflector
+      # @!attribute [r] base
+      #   @return [Module] the base module
+      attr_reader :base
+
+      # Default constructor
+      #
+      # @param base [Module] the base module
+      def initialize(base)
+        super()
+
+        @base = base
+      end
+
+      # Inflect upon the given hash or constructor for a hash.
+      #
+      # @param constructor [Hash, #to_hash] the hash or constructor for a hash
+      # @return [Isomorphic::HashWithIndifferentAccess] the inflected hash
+      # @raise [Isomorphic::InflectorError] if a key in the given hash or constructor for a hash is invalid
+      def convert_hash(constructor = {})
+        Isomorphic::HashWithIndifferentAccess.new(self, constructor)
+      end
+
+      # Inflect upon the given terms.
+      #
+      # @example Inflect upon a {String}
+      #   Isomorphic::Inflector.new(Foo).isomorphism("bar") #=> "foo_bar"
+      # @example Inflect upon a {Symbol}
+      #   Isomorphic::Inflector.new(Foo).isomorphism(:bar) #=> "foo_bar"
+      # @example Inflect upon a {Class}
+      #   Isomorphic::Inflector.new(Foo).isomorphism(Foo::Bar) #=> "foo_bar"
+      # @example Inflect upon an {Array} of inflectable terms
+      #   Isomorphic::Inflector.new(Foo).isomorphism(["bar", "fum", "baz"]) #=> "foo_bar_and_foo_fum_and_foo_baz"
+      # @example Inflect upon an inflectable term-alias pair
+      #   Isomorphic::Inflector.new(Foo).isomorphism([["bar", "ex1"]]) #=> "foo_bar_as_ex1"
+      # @example Inflect upon an {Array} of inflectable term-alias pairs
+      #   Isomorphic::Inflector.new(Foo).isomorphism([["bar", "ex1"], ["bar", "ex2"], ["bar", "ex3"]]) #=> "foo_bar_as_ex1_and_foo_bar_as_ex2_and_foo_bar_as_ex3"
+      #
+      # @param terms [Array<Object>] the inflectable terms
+      # @return [String] the inflection
+      # @raise [Isomorphic::InflectorError] if an inflectable term is invalid
+      def isomorphism(terms)
+        isomorphism_for(terms)
+      end
+
+      protected
+
+      # Converts the name of the given class.
+      #
+      # @param klass [Class] the class
+      # @return [String] the underscored name of the class, where occurrences of +"/"+ are replaced with +"_"+
+      def convert_class(klass)
+        ::ActiveSupport::Inflector.underscore(klass.name).gsub("/", "_")
+      end
+
+      private
+
+      def isomorphism_for(terms)
+        unless terms.is_a?(::Array)
+          terms = [terms]
+        end
+
+        terms.collect { |term|
+          case term
+            when ::Array            then isomorphism_for_array(term)
+            when ::Class            then isomorphism_for_class(term)
+            when ::String, ::Symbol then isomorphism_for_method_name(term)
+            else raise Isomorphic::InvalidInflectionTerm.new(nil, base, term)
+          end
+        }.join("_and_")
+      end
+
+      def isomorphism_for_array(array)
+        method_name = \
+          case array[0]
+            when ::Class            then isomorphism_for_class(array[0])
+            when ::String, ::Symbol then isomorphism_for_method_name(array[0])
+            else raise Isomorphic::InvalidInflectionTerm.new(nil, base, array)
+          end
+
+        method_suffix = \
+          case array[1]
+            when ::NilClass         then ""
+            when ::String, ::Symbol then ::Kernel.sprintf("_as_%s", array[1])
+            else raise Isomorphic::InvalidInflectionTerm.new(nil, base, array)
+          end
+
+        "#{method_name}#{method_suffix}"
+      end
+
+      def isomorphism_for_class(klass)
+        unless klass.is_a?(::Class) && (klass.parents[-2] == base)
+          raise Isomorphic::InvalidInflectionClass.new(nil, base, klass)
+        end
+
+        convert_class(klass)
+      end
+
+      def isomorphism_for_method_name(method_name)
+        s = method_name.to_s
+
+        unless s.starts_with?(::Kernel.sprintf("%s_", convert_class(base)))
+          raise Isomorphic::InvalidInflectionMethodName.new(nil, base, method_name)
+        end
+
+        s
+      end
+    end
+  end
+end

data/lib/isomorphic/lens.rb

@@ -0,0 +1,433 @@
+require "active_support/concern"
+require "active_support/core_ext/object/try"
+require "active_support/hash_with_indifferent_access"
+
+require "isomorphic/errors"
+
+module Isomorphic
+  # Generic base class for Isomorphic lens errors.
+  #
+  # @abstract
+  class LensError < Isomorphic::IsomorphicError
+  end
+
+  # Raised when an Isomorphic lens is invalid.
+  class InvalidLens < Isomorphic::LensError
+    # @!attribute [r] lens
+    #   @return [Isomorphic::Lens::AbstractLens] the lens
+    attr_reader :lens
+
+    # Default constructor.
+    #
+    # @param message [String] the message
+    # @param lens [Isomorphic::Lens::AbstractLens] the lens
+    def initialize(message = nil, lens)
+      super(message)
+
+      @lens = lens
+    end
+  end
+
+  module Lens
+    module Internal
+      # Included when the base class has a +#factory+ and +#inflector+, and hence, can build Isomorphic lenses.
+      module InstanceMethodsForLens
+        extend ::ActiveSupport::Concern
+
+        # Build a lens for the Active Record association with the given name.
+        #
+        # @param association [#to_s] the association name
+        # @return [Isomorphic::Lens::Association] the lens
+        def reflect_on_association(association)
+          Isomorphic::Lens::Association.new(factory, inflector, association, nil)
+        end
+
+        # Build a lens for the attribute with the given name.
+        #
+        # @param attribute_name [#to_s] the attribute name
+        # @param to [Proc] the optional modifier for after the getter
+        # @param from [Proc] the optional modifier for before the setter
+        # @return [Isomorphic::Lens::Attribute] the lens
+        def reflect_on_attribute(attribute_name, to = nil, from = nil)
+          Isomorphic::Lens::Attribute.new(factory, inflector, attribute_name, to, from)
+        end
+
+        # Build a lens for the given inflectable terms and optional arguments.
+        #
+        # @param terms [Array<Object>] the inflectable terms
+        # @param args [Array<Object>] the arguments for the isomorphism
+        # @return [Isomorphic::Lens::Isomorphism] the lens
+        # @raise [Isomorphic::InflectorError] if an inflectable term is invalid
+        def reflect_on_isomorphism(terms, *args)
+          Isomorphic::Lens::Isomorphism.new(factory, inflector, terms, *args)
+        end
+      end
+    end
+
+    # Generic base class for Isomorphic lenses.
+    #
+    # @abstract Subclass and override {#_get} and {#set} to implement a custom class.
+    class AbstractLens
+      # @!attribute [r] factory
+      #   @return [Isomorphic::Factory::AbstractFactory] the Isomorphic factory
+      # @!attribute [r] inflector
+      #   @return [Isomorphic::Inflector::AbstractInflector] the Isomorphic inflector
+      attr_reader :factory, :inflector
+
+      # Default constructor.
+      #
+      # @param factory [Isomorphic::Factory::AbstractFactory] the Isomorphic factory
+      # @param inflector [Isomorphic::Inflector::AbstractInflector] the Isomorphic inflector
+      def initialize(factory, inflector)
+        super()
+
+        @factory, @inflector = factory, inflector
+      end
+
+      # Getter.
+      #
+      # @param record_or_hash [ActiveRecord::Base, Hash<ActiveRecord::Base, ActiveRecord::Base>] the Active Record record or hash of records
+      # @return [Object] the value of the getter
+      # @raise [Isomorphic::InvalidLens] if the lens is invalid
+      def get(record_or_hash)
+        if record_or_hash.is_a?(::Hash)
+          record_or_hash.each_pair.inject({}) { |acc, pair|
+            association_record, record = *pair
+
+            acc[association_record] = _get(record)
+            acc
+          }
+        else
+          _get(record_or_hash)
+        end
+      end
+
+      # Setter.
+      #
+      # @param record [ActiveRecord::Base] the Active Record record
+      # @param isomorphism_instance [Object] the instance
+      # @param xmlattr_acc [ActiveSupport::HashWithIndifferentAccess] the accumulator of XML attributes by name
+      # @return [Object] the value of the setter
+      # @raise [Isomorphic::InvalidLens] if the lens is invalid
+      def set(record, isomorphism_instance, xmlattr_acc = ::ActiveSupport::HashWithIndifferentAccess.new)
+        raise ::NotImplementedError
+      end
+
+      protected
+
+      def _get(record)
+        raise ::NotImplementedError
+      end
+    end
+
+    # An Isomorphic lens for an Active Record association.
+    class Association < Isomorphic::Lens::AbstractLens
+      # @!attribute [r] association
+      #   @return [#to_s] the association name
+      attr_reader :association
+
+      # @!attribute [r] next_lens
+      #   @return [Isomorphic::Lens::AbstractLens] the next lens or +nil+ if this is the last lens in the composition
+      attr_reader :next_lens
+
+      # Default constructor.
+      #
+      # @param factory [Isomorphic::Factory::AbstractFactory] the Isomorphic factory
+      # @param inflector [Isomorphic::Inflector::AbstractInflector] the Isomorphic inflector
+      # @param association [#to_s] the association name
+      # @param next_lens [Isomorphic::Lens::AbstractLens] the next lens or +nil+ if this is the last lens in the composition
+      def initialize(factory, inflector, association, next_lens = nil)
+        super(factory, inflector)
+
+        @association, @next_lens = association, next_lens
+      end
+
+      # Returns the last lens in the composition.
+      #
+      # @return [Isomorphic::Lens::AbstractLens] the last lens or +nil+ if this is the last lens in the composition
+      def last_lens
+        next_lens.try { |current_lens|
+          while current_lens.is_a?(self.class)
+            current_lens = current_lens.next_lens
+          end
+        }.try { |current_lens|
+          current_lens.next_lens
+        }
+      end
+
+      def set(record, isomorphism_instance, xmlattr_acc = ::ActiveSupport::HashWithIndifferentAccess.new)
+        unless next_lens.is_a?(Isomorphic::Lens::AbstractLens)
+          raise Isomorphic::InvalidLens.new(nil, self)
+        end
+
+        reflection = record.class.reflect_on_association(association)
+
+        case reflection.macro
+        when :has_many, :has_and_belongs_to_many
+          raise Isomorphic::InvalidLens.new("invalid macro: #{reflection.macro}", self)
+        when :has_one, :belongs_to
+          next_lens.set(record.send(association) || record.send(:"build_#{association}"), isomorphism_instance, xmlattr_acc)
+        else
+          raise Isomorphic::InvalidLens.new("unknown macro: #{reflection.macro}", self)
+        end
+      end
+
+      # Compose this lens with a new lens for the Active Record association with the given name.
+      #
+      # @param association [#to_s] the association name
+      # @return [self]
+      def reflect_on_association(association)
+        append do
+          self.class.new(factory, inflector, association, nil)
+        end
+      end
+
+      # Compose this lens with a new lens for the attribute with the given name.
+      #
+      # @param attribute_name [#to_s] the attribute name
+      # @param to [Proc] the optional modifier for after the getter
+      # @param from [Proc] the optional modifier for before the setter
+      # @return [self]
+      def reflect_on_attribute(attribute_name, to = nil, from = nil)
+        append do
+          Isomorphic::Lens::Attribute.new(factory, inflector, attribute_name, to, from)
+        end
+      end
+
+      # Compose this lens with a new lens for the given inflectable terms and optional arguments.
+      #
+      # @param terms [Array<Object>] the inflectable terms
+      # @param args [Array<Object>] the arguments for the isomorphism
+      # @return [self]
+      # @raise [Isomorphic::InflectorError] if an inflectable term is invalid
+      def reflect_on_isomorphism(terms, *args)
+        append(with_next_lens: true) do |other|
+          Isomorphic::Lens::IsomorphismAssociation.new(factory, inflector, other.association, terms, *args)
+        end
+      end
+
+      protected
+
+      def _get(record)
+        unless next_lens.is_a?(Isomorphic::Lens::AbstractLens)
+          raise Isomorphic::InvalidLens.new(nil, self)
+        end
+
+        reflection = record.class.reflect_on_association(association)
+
+        case reflection.macro
+        when :has_many, :has_and_belongs_to_many
+          raise Isomorphic::InvalidLens.new("invalid macro: #{reflection.macro}", self)
+        when :has_one, :belongs_to
+          record.send(association).try { |association_record|
+            next_lens.get(association_record)
+          }
+        else
+          raise Isomorphic::InvalidLens.new("unknown macro: #{reflection.macro}", self)
+        end
+      end
+
+      private
+
+      def append(**options, &block)
+        others = [self]
+        current_lens = next_lens
+        while current_lens.is_a?(self.class)
+          others << current_lens
+          current_lens = current_lens.next_lens
+        end
+
+        if options[:with_next_lens]
+          if others.length == 1
+            block.call(others[0])
+          else
+            others[0..-2].reverse.inject(block.call(others[-1])) { |acc, other|
+              self.class.new(factory, inflector, other.association, acc)
+            }
+          end
+        else
+          others.reverse.inject(block.call) { |acc, other|
+            self.class.new(factory, inflector, other.association, acc)
+          }
+        end
+      end
+    end
+
+    # An Isomorphic lens for an attribute.
+    class Attribute < Isomorphic::Lens::AbstractLens
+      # @return [Proc] the identity morphism (returns the argument)
+      IDENTITY = ::Proc.new { |x| x }.freeze
+
+      # @!attribute [r] attribute_name
+      #   @return [String] the attribute name
+      attr_reader :attribute_name
+
+      # @!attribute [r] to
+      #   @return [Proc] the modifier for after the getter
+      # @!attribute [r] from
+      #   @return [Proc] the modifier for before the setter
+      attr_reader :to, :from
+
+      # Default constructor.
+      #
+      # @param factory [Isomorphic::Factory::AbstractFactory] the Isomorphic factory
+      # @param inflector [Isomorphic::Inflector::AbstractInflector] the Isomorphic inflector
+      # @param attribute_name [#to_s] the attribute name
+      # @param to [Proc] the modifier for after the getter
+      # @param from [Proc] the modifier for before the setter
+      def initialize(factory, inflector, attribute_name, to = nil, from = nil)
+        super(factory, inflector)
+
+        @attribute_name = attribute_name
+
+        @to = to || IDENTITY
+        @from = from || IDENTITY
+      end
+
+      def set(record, isomorphism_instance, xmlattr_acc = ::ActiveSupport::HashWithIndifferentAccess.new)
+        args = case from.arity
+          when 1 then [isomorphism_instance]
+          else [isomorphism_instance, xmlattr_acc]
+        end
+
+        record.instance_exec(*args, &from).try { |value|
+          record.send(:"#{attribute_name}=", value)
+        }
+      end
+
+      protected
+
+      def _get(record)
+        record.instance_exec(record.send(attribute_name), &to)
+      end
+    end
+
+    # An Isomorphic lens for inflectable terms.
+    class Isomorphism < Isomorphic::Lens::AbstractLens
+      # @!attribute [r] terms
+      #   @return [Array<Object>] the inflectable terms
+      # @!attribute [r] args
+      #   @return [Array<Object>] the arguments for the isomorphism
+      attr_reader :terms, :args
+
+      # @!attribute [r] method_name
+      #   @return [#to_sym] the instance method name that was inflected from the given inflectable terms
+      attr_reader :method_name
+
+      # Default constructor.
+      #
+      # @param factory [Isomorphic::Factory::AbstractFactory] the Isomorphic factory
+      # @param inflector [Isomorphic::Inflector::AbstractInflector] the Isomorphic inflector
+      # @param terms [Array<Object>] the inflectable terms
+      # @param args [Array<Object>] the arguments for the isomorphism
+      # @raise [Isomorphic::InflectorError] if an inflectable term is invalid
+      def initialize(factory, inflector, terms, *args)
+        super(factory, inflector)
+
+        @terms = terms
+        @args = args
+
+        @method_name = inflector.isomorphism(terms)
+      end
+
+      def set(record, isomorphism_instance, xmlattr_acc = ::ActiveSupport::HashWithIndifferentAccess.new)
+        (record.class.try(:"has_#{method_name}?") ? record.class.send(:"from_#{method_name}", isomorphism_instance, record, xmlattr_acc, *args) : record.class.send(:"from_#{method_name}", isomorphism_instance, *args)).try { |association_record|
+          factory.xmlattrs.try(:each) do |xmlattr_name|
+            isomorphism_instance.try(:"xmlattr_#{xmlattr_name}").try { |xmlattr_value|
+              xmlattr_acc[xmlattr_name] ||= {}
+              xmlattr_acc[xmlattr_name][xmlattr_value] = association_record
+            }
+          end
+
+          association_record
+        }
+      end
+
+      protected
+
+      def _get(record)
+        record.class.try(:"has_#{method_name}?") ? record.send(:"to_#{method_name}", nil, *args) : record.send(:"to_#{method_name}", *args)
+      end
+    end
+
+    # An Isomorphic lens for inflectable terms whose state is determined by an Active Record association.
+    class IsomorphismAssociation < Isomorphic::Lens::Isomorphism
+      # @!attribute [r] association
+      #   @return [#to_s] the association name
+      attr_reader :association
+
+      # Default constructor.
+      #
+      # @param factory [Isomorphic::Factory::AbstractFactory] the Isomorphic factory
+      # @param inflector [Isomorphic::Inflector::AbstractInflector] the Isomorphic inflector
+      # @param association [#to_s] the association name
+      # @param args [Array<Object>] the arguments for the isomorphism
+      def initialize(factory, inflector, association, *args)
+        super(factory, inflector, *args)
+
+        @association = association
+      end
+
+      def set(record, isomorphism_instance, xmlattr_acc = ::ActiveSupport::HashWithIndifferentAccess.new)
+        if association.nil?
+          super(record, isomorphism_instance)
+        else
+          reflection = record.class.reflect_on_association(association)
+
+          (reflection.klass.try(:"has_#{method_name}?") ? reflection.klass.send(:"from_#{method_name}", isomorphism_instance, nil, xmlattr_acc, *args) : reflection.klass.send(:"from_#{method_name}", isomorphism_instance, *args)).try { |association_record|
+            case reflection.macro
+            when :has_many, :has_and_belongs_to_many
+              factory.xmlattrs.try(:each) do |xmlattr_name|
+                isomorphism_instance.try(:"xmlattr_#{xmlattr_name}").try { |xmlattr_value|
+                  xmlattr_acc[xmlattr_name] ||= {}
+                  xmlattr_acc[xmlattr_name][xmlattr_value] = association_record
+                }
+              end
+
+              record.send(association).send(:<<, association_record)
+            when :has_one, :belongs_to
+              factory.xmlattrs.try(:each) do |xmlattr_name|
+                isomorphism_instance.try(:"xmlattr_#{xmlattr_name}").try { |xmlattr_value|
+                  xmlattr_acc[xmlattr_name] ||= {}
+                  xmlattr_acc[xmlattr_name][xmlattr_value] = association_record
+                }
+              end
+
+              record.send(:"#{association}=", association_record)
+            else
+              raise Isomorphic::InvalidLens.new("unknown macro: #{reflection.macro}", self)
+            end
+
+            association_record
+          }
+        end
+      end
+
+      protected
+
+      def _get(record)
+        if association.nil?
+          super(record)
+        else
+          reflection = record.class.reflect_on_association(association)
+
+          case reflection.macro
+          when :has_many, :has_and_belongs_to_many
+            record.send(association).try { |collection_proxy|
+              collection_proxy.to_a.inject({}) { |acc, association_record|
+                acc[association_record] = reflection.klass.try(:"has_#{method_name}?") ? association_record.send(:"to_#{method_name}", nil, *args) : association_record.send(:"to_#{method_name}", *args)
+                acc
+              }
+            }
+          when :has_one, :belongs_to
+            record.send(association).try { |association_record|
+              reflection.klass.try(:"has_#{method_name}?") ? association_record.send(:"to_#{method_name}", nil, *args) : association_record.send(:"to_#{method_name}", *args)
+            }
+          else
+            raise Isomorphic::InvalidLens.new("unknown macro: #{reflection.macro}", self)
+          end
+        end
+      end
+    end
+  end
+end