delineate 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c80a9bfec2ba77cc6cdb8ae3f60451cecb42b09e
-  data.tar.gz: 7c18f5138e3661086b03e9b3894296bbc09fc86f
+  metadata.gz: 7fcb6ebbc0458a87120f829033d853357317bfa1
+  data.tar.gz: a7ee9aef7c42dd4c1e794935ac6e71c6ada2c7af
 SHA512:
-  metadata.gz: 15b35ff7187adb21b2117e9204ec033a80c70f1616541aab7d410e672682747ab3609e6c61b9bdd1230fdbe015f738817984278cc84c3c2d0d5177582c4bc853
-  data.tar.gz: d00ed37e44867047b35ace1747be62bb5901c65e8aaf9e5b1532f6e7b3becc15d8f57ace996bcad158c5e01178ac5b8b8e4ce6ccb67d8b26536c9518bda06c96
+  metadata.gz: 80fd619678b2808735873628329e4b8d6b7103e586ce3f70c12b9b44e0d2b65fec6f593cac7e625ae9101d65c39f9fe15f2ba24843b5ce42dfaeaa8e97b3e3ef
+  data.tar.gz: e2c886ce454cf4782be0bf957d38a64dd677ee2133960a9c8b0ca8dbbcb6c00a55bad653070b315bb5ff498c01d363ae9b6f9485c512ffd3593b7e5f2d2fa90c

data/README.rdoc

@@ -1,14 +1,10 @@
-*NOTE*: This code is published for the purpose of exposing some of my work, and is
-not yet intended to be a fully productized library. Please consider this an
-implementation sample only. The library will be packaged as a full gem real soon now.
-
-
 = Delineate
 
-The delineate gem  provides ActiveRecord serialization DSL for mapping model attributes and associations.
-The functionality is similar in concept to that provided by ActiveModel Serializers with many enhancements,
-including built in bi-directional support, i.e. deserialization (parsing) of attributes and nested
-associations.
+The delineate gem provides ActiveRecord serialization/deserialization DSL for mapping
+model attributes and associations. The functionality is similar in concept to that provided
+by ActiveModel Serializers with several enhancements including bi-directional support
+(i.e. parsing of input attributes and nested associations) and multiple maps for
+different use cases.
 
 == About Attribute Maps
 
@@ -264,8 +260,11 @@ superclass map, do:
 
 === Serializng Out
 
+tbd
+
 === Serializing In
 
+tbd
 
 == Roadmap
 

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.6.1

data/delineate.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: delineate 0.6.0 ruby lib
+# stub: delineate 0.6.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "delineate"
-  s.version = "0.6.0"
+  s.version = "0.6.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Tom Smith"]
-  s.date = "2014-02-21"
+  s.date = "2014-02-23"
   s.description = "ActiveRecord serializer DSL for mapping model attributes and associations. Similar to  ActiveModel Serializers with many enhancements including bi-directional support, i.e. deserialization."
   s.email = "tsmith@landfall.com"
   s.extra_rdoc_files = [
@@ -31,12 +31,14 @@ Gem::Specification.new do |s|
     "lib/class_inheritable_attributes.rb",
     "lib/core_extensions.rb",
     "lib/delineate.rb",
-    "lib/delineate/attribute_map/attribute_map.rb",
-    "lib/delineate/attribute_map/csv_serializer.rb",
-    "lib/delineate/attribute_map/json_serializer.rb",
-    "lib/delineate/attribute_map/map_serializer.rb",
-    "lib/delineate/attribute_map/xml_serializer.rb",
+    "lib/delineate/attribute_map.rb",
     "lib/delineate/map_attributes.rb",
+    "lib/delineate/map_serializer.rb",
+    "lib/delineate/schema.rb",
+    "lib/delineate/serialization.rb",
+    "lib/delineate/serializers/csv_serializer.rb",
+    "lib/delineate/serializers/json_serializer.rb",
+    "lib/delineate/serializers/xml_serializer.rb",
     "spec/database.yml",
     "spec/delineate_spec.rb",
     "spec/spec_helper.rb",

data/lib/core_extensions.rb

@@ -4,6 +4,10 @@ class Object
     yield(value)
     value
   end
+
+  def is_not_a?(klass)
+    !self.is_a?(klass)
+  end
 end
 
 class Hash

data/lib/delineate.rb

@@ -1,11 +1,11 @@
+require 'active_record'
+
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'core_extensions'
-require 'active_record'
 
+require 'delineate/attribute_map'
 require 'delineate/map_attributes'
-require 'delineate/attribute_map/csv_serializer'
-require 'delineate/attribute_map/xml_serializer'
-require 'delineate/attribute_map/json_serializer'
+require 'delineate/map_serializer'
 
 $LOAD_PATH.shift

data/lib/delineate/{attribute_map/attribute_map.rb → attribute_map.rb}

@@ -1,13 +1,14 @@
 require 'active_support/core_ext/hash/deep_dup.rb'
 
-module Delineate
+require 'delineate/serialization'
+require 'delineate/schema'
 
-  module AttributeMap
+module Delineate
 
   # == Attribute Maps
   #
   # The AttributeMap class provides the ability to expose an ActiveRecord model's
-  # attributes and associations in a customized way. By speciying an attribute map,
+  # attributes and associations in a customized way. By specifying an attribute map,
   # the model's internal attributes and associations can be de-coupled from its
   # presentation or interface, allowing a consumer's interaction with the model to
   # remain consistent even if the model implementation or schema changes.
@@ -28,7 +29,7 @@ module Delineate
   #
   # The map_attributes class method establishes an attribute map that
   # will be used by the model's <map-name>_attributes and <map-name>_attributes= methods.
-  # This map specifies the atrribute names, access permissions, and other options
+  # This map specifies the attribute names, access permissions, and other options
   # as viewed by a user of the model's public API. In the example above, 3 of the
   # the model's attributes are exposed through the API.
   #
@@ -52,7 +53,7 @@ module Delineate
   #
   # :rw   This value, which is the default, means that the attribute is read-write.
   # :ro   The :ro value designates the attribute as read-only. Attempts to set the
-  #       attribute's value will silently fail.
+  #       attribute's value will be ignored.
   # :w    The attribute value can be set, but does not appear when the attributes
   #       read.
   # :none Use this option when merging in a map to ignore the attribute defined in
@@ -238,7 +239,7 @@ module Delineate
       validate_association_options(options, block_given?)
 
       model_attr = (options[:model_attr] || name).to_sym
-      reflection = get_model_association(model_attr)
+      reflection = model_association_reflection(model_attr)
 
       attr_map = options.delete(:attr_map) || AttributeMap.new(reflection.class_name, @name)
       attr_map.instance_variable_set(:@options, {:override => options[:override]}) if options[:override]
@@ -257,155 +258,6 @@ module Delineate
                              :collection => (reflection.macro == :has_many || reflection.macro == :has_and_belongs_to_many)}
     end
 
-    # Returns a schema hash according to the attribute map. This information
-    # could be used to generate clients.
-    #
-    # The schema hash has two keys: +attributes+ and +associations+. The content
-    # for each varies depeding on the +access+ parameter which can take values
-    # of :read, :write, or nil. The +attributes+ hash looks like this:
-    #
-    #   :read or :write   { :name => :string, :age => :integer }
-    #   :nil              { :name => {:type => :string, :access => :rw}, :age => { :type => :integer, :access => :rw} }
-    #
-    # The +associations+ hash looks like this:
-    #
-    #   :read or :write   { :posts => {}, :comments => {:optional => true} }
-    #   nil               { :posts => {:access => :rw}, :comments => {:optional => true, :access=>:ro} }
-    #
-    # This method uses the +columns_hash+ provided by ActiveRecord. You can implement
-    # that method in your custom models if you want to customize the schema output.
-    #
-    def schema(access = nil, schemas = [])
-      schemas.push(@klass_name)
-      resolve
-
-      columns = (klass_cti_subclass? ? klass.cti_base_class.columns_hash : {}).merge klass.columns_hash
-      attrs = {}
-      @attributes.each do |attr, opts|
-        attr_type = (column = columns[model_attribute(attr).to_s]) ? column.type : nil
-        if (access == :read && opts[:access] != :w) or (access == :write && opts[:access] != :ro)
-          attrs[attr] = attr_type
-        elsif access.nil?
-          attrs[attr] = {:type => attr_type, :access => opts[:access] || :rw}
-        end
-      end
-
-      associations = {}
-      @associations.each do |assoc_name, assoc|
-        include_assoc = (access == :read && assoc[:options][:access] != :w) || (access == :write && assoc[:options][:access] != :ro) || access.nil?
-        if include_assoc
-          associations[assoc_name] = {}
-          associations[assoc_name][:optional] = true if assoc[:options][:optional]
-        end
-
-        associations[assoc_name][:access] = (assoc[:options][:access] || :rw) if access.nil?
-
-        if include_assoc && assoc[:attr_map] && assoc[:attr_map] != assoc[:klass_name].to_s.constantize.attribute_map(@name)
-          associations[assoc_name].merge! assoc[:attr_map].schema(access, schemas) unless schemas.include?(assoc[:klass_name])
-        end
-      end
-
-      schemas.pop
-      {:attributes => attrs, :associations => associations}
-    end
-
-    def resolved?
-      @resolved
-    end
-
-    # Will raise an exception of the map cannot be fully resolved
-    def resolve!
-      resolve(:must_resolve)
-      self
-    end
-
-    # Attempts to resolve the map and the maps it depends on. If must_resolve is truthy, will
-    # raise an exception if map cannot be resolved.
-    def resolve(must_resolve = false, resolving = [])
-      return true if @resolved
-      return true if resolving.include?(@klass_name)    # prevent infinite recursion
-
-      resolving.push(@klass_name)
-
-      result = resolve_associations(must_resolve, resolving)
-      result = false unless resolve_sti_baseclass(must_resolve, resolving)
-
-      resolving.pop
-      @resolved = result
-    end
-
-    # Values for includes param:
-    #   nil = include all attributes
-    #   [] = do not include optional attributes
-    #   [...] = include the specified optional attributes
-    def serializable_attribute_names(includes = nil)
-      attribute_names = @attributes.keys.reject {|k| @attributes[k][:access] == :w}
-      return attribute_names if includes.nil?
-
-      attribute_names.delete_if do |key|
-        (option = @attributes[key][:optional]) && !includes.include?(key) && !includes.include?(option)
-      end
-    end
-
-    def serializable_association_names(includes = nil)
-      return @associations.keys if includes.nil?
-
-      @associations.inject([]) do |assoc_names, assoc|
-        assoc_names << assoc.first if !(option = assoc.last[:options][:optional]) || includes.include?(assoc.first) || includes.include?(option)
-        assoc_names
-      end
-    end
-
-    # Given the specified api attributes hash, translates the attribute names to
-    # the corresponding model attribute names. Recursive translation on associations
-    # is performed. API attributes that are defined as read-only are removed.
-    #
-    # Input can be a single hash or an array of hashes.
-    def map_attributes_for_write(attrs, options = nil)
-      raise "Cannot process map #{@klass_name}:#{@name} for write because it has not been resolved" if !resolve
-
-      (attrs.is_a?(Array) ? attrs : [attrs]).each do |attr_hash|
-        raise ArgumentError, "Expected attributes hash but received #{attr_hash.inspect}" if !attr_hash.is_a?(Hash)
-
-        attr_hash.dup.symbolize_keys.each do |k, v|
-          if assoc = @associations[k]
-            map_association_attributes_for_write(assoc, attr_hash, k)
-          else
-            if @write_attributes.has_key?(k)
-              attr_hash.rename_key!(k, @write_attributes[k]) if @write_attributes[k] != k
-            else
-              attr_hash.delete(k)
-            end
-          end
-        end
-      end
-
-      attrs
-    end
-
-    def attribute_value(record, name)
-      model_attr = model_attribute(name)
-      model_attr == :type ? record.read_attribute(:type) : record.send(model_attr)
-    end
-
-    def model_association(name)
-      @associations[name][:options][:model_attr] || name
-    end
-
-    # Access the map of an association defined in this map. Will throw an
-    # error if the map cannot be found and resolved.
-    def association_attribute_map(association)
-      assoc = @associations[association]
-      validate(assoc_attr_map(assoc), assoc[:klass_name])
-      assoc_attr_map(assoc)
-    end
-
-    def validate(map, class_name)
-      raise(NameError, "Expected attribute map :#{@name} to be defined for class '#{class_name}'") if map.nil?
-      map.resolve! unless map.resolved?
-      map
-    end
-
     # Merges another AttributeMap instance into this instance.
     def merge!(other_attr_map, merge_opts = {})
       return if other_attr_map.nil?
@@ -445,6 +297,31 @@ module Delineate
       self
     end
 
+    def resolved?
+      @resolved
+    end
+
+    # Will raise an exception of the map cannot be fully resolved
+    def resolve!
+      resolve(:must_resolve)
+      self
+    end
+
+    # Attempts to resolve the map and the maps it depends on. If must_resolve is truthy, will
+    # raise an exception if map cannot be resolved.
+    def resolve(must_resolve = false, resolving = [])
+      return true if @resolved
+      return true if resolving.include?(@klass_name)    # prevent infinite recursion
+
+      resolving.push(@klass_name)
+
+      result = resolve_associations(must_resolve, resolving)
+      result = false unless resolve_sti_baseclass(must_resolve, resolving)
+
+      resolving.pop
+      @resolved = result
+    end
+
 
     protected
 
@@ -452,46 +329,55 @@ module Delineate
         @klass ||= @klass_name.constantize
       end
 
+      def klass_sti_subclass?
+        !klass.descends_from_active_record?
+      end
+
+      def klass_cti_subclass?
+        klass.respond_to?(:is_cti_subclass?) && klass.is_cti_subclass?
+      end
+
       def empty?
         @attributes.empty? && @associations.empty?
       end
 
+      def is_model_attr?(name)
+        klass.column_names.include?(name.to_s)
+      end
+
       def model_attribute(name)
         @attributes[name][:model_attr] || name
       end
 
+      def model_association_reflection(association)
+        returning association_reflection(association) do |reflection|
+          raise ArgumentError, "Association '#{association}' in model #{@klass_name} is not defined" if reflection.nil?
+          begin
+            reflection.klass
+          rescue
+            raise NameError, "Cannot resolve association class '#{reflection.class_name}' from model '#{@klass_name}'"
+          end
+        end
+      end
+
+      def association_reflection(model_assoc)
+        reflection = klass.reflect_on_association(model_assoc)
+        reflection || (klass.cti_base_class.reflect_on_association(model_assoc) if klass_cti_subclass?)
+      end
+
       def assoc_attr_map(assoc)
         assoc[:attr_map] || assoc[:klass_name].constantize.attribute_map(@name)
       end
 
-      # Map an association's attributes for writing. Will call
-      # map_attributes_for_write (resulting in recursion) on the association
-      # if it's a has_one or belongs_to, or calls map_attributes_for_write
-      # on each element of a has_many collection.
-      def map_association_attributes_for_write(assoc, attr_hash, key)
-        if assoc[:options][:access] == :ro
-          attr_hash.delete(key)       # Writes not allowed
-        else
-          assoc_attrs = attr_hash[key]
-          if assoc[:collection]
-            attr_hash[key] = xlate_params_for_nested_attributes_collection(assoc_attrs)
-
-            # Iterate thru each element in the collection and map its attributes
-            attr_hash[key].each do |entry_attrs|
-              entry_attrs = entry_attrs[1] if entry_attrs.is_a?(Array)
-              assoc_attr_map(assoc).map_attributes_for_write(entry_attrs)
-            end
-          else
-            # Association is a one-to-one; map its attributes
-            assoc_attr_map(assoc).map_attributes_for_write(assoc_attrs)
-          end
-
-          model_attr = assoc[:options][:model_attr] || key
-          attr_hash[(model_attr.to_s + '_attributes').to_sym] = attr_hash.delete(key)
-        end
+      def merge_option?(options)
+        options[:override] != :replace
       end
 
+      VALID_MAP_OPTIONS = [ :override, :no_primary_key_attr, :no_destroy_attr ]
       VALID_ASSOC_OPTIONS = [ :model_attr, :using, :override, :polymorphic, :access, :optional, :attr_map ]
+      VALID_ATTR_OPTIONS = [ :model_attr, :access, :optional, :read, :write, :using ]
+      VALID_ATTR_OPTIONS_MULTIPLE = [ :access, :optional ]
+      VALID_ACCESS_OPTIONS = [:ro, :rw, :w, :none]
 
       def validate_association_options(options, blk)
         options.assert_valid_keys(VALID_ASSOC_OPTIONS)
@@ -499,59 +385,36 @@ module Delineate
         options[:model_attr] = options.delete(:using) if options.key?(:using)
 
         raise ArgumentError, 'Cannot specify :override or provide block with :polymorphic' if options[:polymorphic] and (blk or options[:override])
-        raise ArgumentError, 'Option :override must be :replace or :merge' unless !options.key?(:override) || [:merge, :replace].include?(options[:override])
+        raise ArgumentError, 'Option :override must = :replace or :merge' unless !options.key?(:override) || [:merge, :replace].include?(options[:override])
       end
 
-      VALID_ATTR_OPTIONS = [ :model_attr, :access, :optional, :read, :write, :using ]
-      VALID_ATTR_OPTIONS_MULTIPLE = [ :access, :optional ]
-
       def validate_attribute_options(options, arg_count = 1)
         options.assert_valid_keys(VALID_ATTR_OPTIONS) if arg_count == 1
         options.assert_valid_keys(VALID_ATTR_OPTIONS_MULTIPLE) if arg_count > 1
 
         options[:model_attr] = options.delete(:using) if options.key?(:using)
-        options[:access] = :rw if !options.key?(:access)
+        options[:access] = :rw unless options.key?(:access)
 
         validate_access_option(options[:access])
         raise ArgumentError, 'Cannot specify :write option for read-only attribute' if options[:access] == :ro && options[:write]
       end
 
-      VALID_MAP_OPTIONS = [ :override, :no_primary_key_attr, :no_destroy_attr ]
-
       def validate_map_options(options)
         options.assert_valid_keys(VALID_MAP_OPTIONS)
         raise ArgumentError, 'Option :override must be :replace or :merge' unless !options.key?(:override) || [:merge, :replace].include?(options[:override])
-        if options[:override] == :replace && klass.descends_from_active_record? && !klass_cti_subclass?
-          raise ArgumentError, "Cannot specify :override => :replace in map_attributes for #{@klass_name} unless it is a CTI or STI subclass"
+        if options[:override] == :replace && !klass_sti_subclass? && !klass_cti_subclass?
+          raise ArgumentError, "Cannot specify :override => :replace in map_attributes for #{@klass_name} unless it is an STI or CTI subclass"
         end
       end
 
       def validate_access_option(opt)
-        raise ArgumentError, 'Invalid value for :access option' if opt and ![:ro, :rw, :w, :none].include?(opt)
+        raise ArgumentError, 'Invalid value for :access option' if opt and !VALID_ACCESS_OPTIONS.include?(opt)
       end
 
-      def get_model_association(association)
-        returning association_reflection(association) do |reflection|
-          raise ArgumentError, "Association '#{association}' in model #{@klass_name} is not defined yet" if reflection.nil?
-          begin
-            reflection.klass
-          rescue
-            raise NameError, "Cannot resolve association class '#{reflection.class_name}' from model '#{@klass_name}'"
-          end
-        end
-      end
-
-      def association_reflection(model_assoc)
-        reflection = klass.reflect_on_association(model_assoc)
-        reflection || (klass.cti_base_class.reflect_on_association(model_assoc) if klass_cti_subclass?)
-      end
-
-      def is_model_attr?(name)
-        klass.column_names.include?(name.to_s)
-      end
-
-      def merge_option?(options)
-        options[:override] != :replace
+      def validate(map, class_name)
+        raise(NameError, "Expected attribute map :#{@name} to be defined for class '#{class_name}'") if map.nil?
+        map.resolve! unless map.resolved?
+        map
       end
 
       def resolve_associations(must_resolve, resolving)
@@ -584,7 +447,7 @@ module Delineate
       def resolve_sti_baseclass(must_resolve, resolving)
         result = true
 
-        if !klass.descends_from_active_record? && !@sti_baseclass_merged && result && @options[:override] != :replace
+        if klass_sti_subclass? && !@sti_baseclass_merged && merge_option?(@options)
           if klass.superclass.attribute_maps.try(:fetch, @name, nil).try(:resolve, must_resolve, resolving)
             @resolved = @sti_baseclass_merged = true
             self.copy(klass.superclass.attribute_maps[@name].dup.merge!(self))
@@ -597,11 +460,7 @@ module Delineate
         result
       end
 
-      def klass_cti_subclass?
-        klass.respond_to?(:is_cti_subclass) && klass.is_cti_subclass?
-      end
-
-      # Checks to see if an assocation specifies a merge, and the association class's
+      # Checks to see if an association specifies a merge, and the association class's
       # attribute map attempts to merge the association parent attribute map.
       def detect_circular_merge(assoc)
         return if assoc.nil? || assoc[:attr_map].nil? || !merge_option?(assoc[:options])
@@ -678,37 +537,8 @@ module Delineate
         end
       end
 
-      # The params hash generated from XML/JSON needs to be translated to a form
-      # compatible with ActiveRecord nested attributes, specifically with respect
-      # to association collections. For example, when the XML input is:
-      #
-      #   <entries>
-      #     <entry>
-      #       ... entry 1 stuff ...
-      #     </entry>
-      #     <entry>
-      #       ... entry 2 stuff ...
-      #     </entry>
-      #   </entries>
-      #
-      # Rails constructs the resulting params hash as:
-      #
-      #   {"entries"=>{"entry"=>[{... entry 1 stuff...}, {... entry 2 stuff...}]}}
-      #
-      # which is incompatible with ActiveRecord nested attrributes. So this method
-      # detects that pattern, and translates the above to:
-      #
-      #   {"entries"=> [{... entry 1 stuff...}, {... entry 2 stuff...}]}
-      #
-      def xlate_params_for_nested_attributes_collection(assoc_attrs)
-        if assoc_attrs.is_a?(Hash) and assoc_attrs.keys.size == 1 and assoc_attrs[assoc_attrs.keys.first].is_a?(Array)
-          assoc_attrs[assoc_attrs.keys.first]
-        else
-          assoc_attrs
-        end
-      end
-
-  end
+    include Serialization
+    include Schema
 
   end
 end

data/lib/delineate/map_attributes.rb

@@ -1,5 +1,3 @@
-require 'delineate/attribute_map/attribute_map'
-require 'delineate/attribute_map/map_serializer'
 require 'class_inheritable_attributes'
 
 module ActiveRecord
@@ -95,23 +93,17 @@ module ActiveRecord
     # especially after the model class's associations and accepts_nested_attributes_for.
     #
     def self.map_attributes(map_name, options = {}, &blk)
-      map = Delineate::AttributeMap::AttributeMap.new(self.name, map_name, options)
+      map = Delineate::AttributeMap.new(self.name, map_name, options)
 
       # If this is a CTI subclass, init this map with its base class attributes and associations
-      if respond_to?(:is_cti_subclass) and is_cti_subclass? and options[:override] != :replace
-        base_class_map = cti_base_class.attribute_map(map_name)
-        raise "Base class for CTI subclass #{self.name} must specify attribute map #{map_name}" if base_class_map.nil?
-
-        base_class_map.attributes.each { |attr, opts| map.attribute(attr, opts.dup) }
-        base_class_map.associations.each do |name, assoc|
-          map.association(name, assoc[:options].merge({:attr_map => assoc[:attr_map].try(:dup)})) unless assoc[:klass_name] == self.name
-        end
-      end
+      inherit_cti_base_class(map, options) if cti_subclass? && options[:override] != :replace
 
       # Parse the map specification DSL
       map.instance_eval(&blk)
 
-      define_attribute_map_methods(map_name)      # define map accessor methods
+      # Define the map accessor methods on this class
+      define_attribute_map_methods(map_name)
+
       attribute_maps[map_name] = map
     end
 
@@ -176,11 +168,25 @@ module ActiveRecord
         end
       end
 
+      # Returns true if this AR class is a CTI subclass.
+      def self.cti_subclass?
+        respond_to?(:is_cti_subclass?) and is_cti_subclass?
+      end
+
+      # Initialize this map with its CTI base class attributes and associations
+      def self.inherit_cti_base_class(map, options)
+        base_class_map = cti_base_class.attribute_map(map.name)
+        raise "Base class for CTI subclass #{self.name} must specify attribute map #{map.name}" unless base_class_map
+
+        map.copy(base_class_map)
+        map.instance_variable_set(:@resolved, false)
+      end
+
       def serializer_class(format)
         if format == :hash
-          Delineate::AttributeMap::MapSerializer
+          Delineate::MapSerializer
         else
-          "Delineate::AttributeMap::#{format.to_s.camelize}Serializer".constantize
+          "Delineate::Serializers::#{format.to_s.camelize}Serializer".constantize
         end
       end
 
@@ -191,7 +197,7 @@ module ActiveRecord
           raise ArgumentError, "Missing attribute map :#{map_name} for class #{self.class.name}" if map.nil?
         end
 
-        raise ArgumentError, "The map parameter :#{map_name} for class #{self.class.name} is invalid" if !map.is_a?(Delineate::AttributeMap::AttributeMap)
+        raise ArgumentError, "The map parameter :#{map_name} for class #{self.class.name} is invalid" if !map.is_a?(Delineate::AttributeMap)
         raise ArgumentError, 'Invalid format parameter' unless [:hash, :csv, :xml, :json].include?(format)
         map
       end

data/lib/delineate/map_serializer.rb

@@ -0,0 +1,173 @@
+module Delineate #:nodoc:
+
+  # The MapSerializer class serves as the base class for processing the
+  # reading and writing of ActiveRecord model attributes through an
+  # attribute map. Each serializer class supports its own external format
+  # for the input/output of the attributes. The format handled by MapSerializer
+  # is a hash.
+  class MapSerializer
+
+    # Creates a serializer for a single record.
+    #
+    # The +attribute_map+ parameter can be an AttributeMap instance or the
+    # name of the record's attribute map. The +options+ hash is used to
+    # filter which attributes and associations are to be serialized for
+    # output, and can have the following keys:
+    #
+    #   :include  Specifies which optional attributes and associations to output.
+    #   :only     Restricts the attributes and associations to only those specified.
+    #   :except   Processes attributes and associations except those specified.
+    #
+    # See the description for +mapped_attributes+ for more info about options.
+    #
+    def initialize(record, attribute_map, options = nil)
+      @record = record
+      attribute_map = record.send(:attribute_map, attribute_map) if attribute_map.is_a?(Symbol)
+      @attribute_map = attribute_map
+      @options = options ? options.dup : {}
+    end
+
+    # Returns the record's mapped attributes in the serializer's intrinsic format.
+    #
+    # For the MapSerializer class the attributes are returned as a hash,
+    # and the +options+ parameter is ignored.
+    def serialize(options = {})
+      @attribute_map.resolve! unless @attribute_map.resolved?
+      serializable_record
+    end
+
+    # Takes a record's attributes in the serializer's intrinsic format, and
+    # returns a hash suitable for direct assignment to the record's collection
+    # of attributes. For example:
+    #
+    #   s = ActiveRecord::AttributeMap::MapSerializer.new(record, :api)
+    #   record.attributes = s.serialize_in(attrs_hash)
+    #
+    def serialize_in(attributes, options = {})
+      @attribute_map.resolve! unless @attribute_map.resolved?
+      @attribute_map.map_attributes_for_write(attributes, options)
+    end
+
+    # Returns the record's mapped attributes in the serializer's "internal"
+    # format, usually this is a hash.
+    def serializable_record
+      returning(serializable_record = Hash.new) do
+        serializable_attribute_names.each do |name|
+          serializable_record[name] = @attribute_map.attribute_value(@record, name)
+        end
+
+        add_includes do |association, records, opts|
+          polymorphic = @attribute_map.associations[association][:options][:polymorphic]
+          assoc_map = association_attribute_map(association)
+
+          if records.is_a?(Enumerable)
+            serializable_record[association] = records.collect do |r|
+              assoc_map = attribute_map_for_record(r) if polymorphic
+              self.class.new(r, assoc_map, opts).serializable_record
+            end
+          else
+            assoc_map = attribute_map_for_record(records) if polymorphic
+            serializable_record[association] = self.class.new(records, assoc_map, opts).serializable_record
+          end
+        end
+      end
+    end
+
+    protected
+
+      # Returns the list of mapped attribute names that are to be output
+      # by applying the serializer's +:include+, +:only+, and +:except+
+      # options to the attribute map.
+      def serializable_attribute_names
+        includes = @options[:include] || []
+        includes = [] if includes.is_a?(Hash)
+        attribute_names = @attribute_map.serializable_attribute_names(Array(includes))
+
+        if @options[:only]
+          @options.delete(:except)
+          attribute_names & Array(@options[:only])
+        else
+          @options[:except] = Array(@options[:except])
+          attribute_names - @options[:except]
+        end
+      end
+
+      # Returns the list of mapped association names that are to be output
+      # by applying the serializer's +:include+ to the attribute map.
+      def serializable_association_names(includes)
+        assoc_includes = includes
+        if assoc_includes.is_a?(Array)
+          if (h = includes.detect {|i| i.is_a?(Hash)})
+            assoc_includes = h.dup
+            includes.each { |i| assoc_includes[i] = {} unless i.is_a?(Hash) }
+          end
+        end
+
+        include_has_options = assoc_includes.is_a?(Hash)
+        include_associations = include_has_options ? assoc_includes.keys : Array(assoc_includes)
+        associations = @attribute_map.serializable_association_names(include_associations)
+
+        if @options[:only]
+          @options.delete(:except)
+          associations = associations & Array(@options[:only])
+        else
+          @options[:except] = Array(@options[:except])
+          associations = associations - @options[:except]
+        end
+
+        [assoc_includes, associations]
+      end
+
+      # Helper for serializing nested models
+      def add_includes(&block)
+        includes = @options.delete(:include)
+        assoc_includes, associations = serializable_association_names(includes)
+
+        for association in associations
+          model_assoc = @attribute_map.model_association(association)
+
+          records = case reflection(model_assoc).macro
+          when :has_many, :has_and_belongs_to_many
+            @record.send(model_assoc).to_a
+          when :has_one, :belongs_to
+            @record.send(model_assoc)
+          end
+
+          yield(association, records, assoc_includes.is_a?(Hash) ? assoc_includes[association] : {}) if records
+        end
+
+        @options[:include] = includes if includes
+      end
+
+      # Returns an association's attribute map - argument is external name
+      def association_attribute_map(association)
+        @attribute_map.association_attribute_map(association)
+      end
+
+      # Returns the attribute map for the specified record - ensures it
+      # is resolved and valid.
+      def attribute_map_for_record(record)
+        map = record.attribute_map(@attribute_map.name)
+        raise(NameError, "Expected attribute map :#{@attribute_map.name} to be defined for class '#{record.class.name}'") if map.nil?
+        map.resolve!
+      end
+
+      # Gets association reflection
+      def reflection(model_assoc)
+        klass = @record.class
+        reflection = klass.reflect_on_association(model_assoc)
+        reflection || (klass.cti_base_class.reflect_on_association(model_assoc) if klass.is_cti_subclass?)
+      end
+
+      SERIALIZER_CLASS_OPTIONS = [:include, :only, :except, :context]
+
+      def remove_serializer_class_options(options)
+        options.reject {|k,v| SERIALIZER_CLASS_OPTIONS.include?(k)}
+      end
+
+  end
+end
+
+require 'delineate/serializers/csv_serializer'
+require 'delineate/serializers/json_serializer'
+require 'delineate/serializers/xml_serializer'

data/lib/delineate/schema.rb

@@ -0,0 +1,69 @@
+module Delineate
+  module Schema
+    extend ActiveSupport::Concern
+
+    # Returns a schema hash according to the attribute map. This information
+    # could be used to generate clients.
+    #
+    # The schema hash has two keys: +attributes+ and +associations+. The content
+    # for each varies depending on the +access+ parameter which can take values
+    # of :read, :write, or nil. The +attributes+ hash looks like this:
+    #
+    #   :read or :write   { :name => :string, :age => :integer }
+    #   :nil              { :name => {:type => :string, :access => :rw}, :age => { :type => :integer, :access => :rw} }
+    #
+    # The +associations+ hash looks like this:
+    #
+    #   :read or :write   { :posts => {}, :comments => {:optional => true} }
+    #   nil               { :posts => {:access => :rw}, :comments => {:optional => true, :access=>:ro} }
+    #
+    # This method uses the +columns_hash+ provided by ActiveRecord. You can implement
+    # that method in your models if you want to customize the schema output.
+    #
+    def schema(access = nil, schema_classes = [])
+      schema_classes.push(@klass_name)
+      resolve
+
+      attrs = schema_attributes(access)
+      associations = schema_associations(access, schema_classes)
+
+      schema_classes.pop
+      {:attributes => attrs, :associations => associations}
+    end
+
+    private
+
+      def schema_attributes(access)
+        columns = (klass_cti_subclass? ? klass.cti_base_class.columns_hash : {}).merge klass.columns_hash
+
+        returning({}) do |attrs|
+          @attributes.each do |attr, opts|
+            attr_type = (column = columns[model_attribute(attr).to_s]) ? column.type : nil
+            if (access == :read && opts[:access] != :w) or (access == :write && opts[:access] != :ro)
+              attrs[attr] = attr_type
+            elsif access.nil?
+              attrs[attr] = {:type => attr_type, :access => opts[:access] || :rw}
+            end
+          end
+        end
+      end
+
+      def schema_associations(access, schema_classes)
+        returning({}) do |associations|
+          @associations.each do |assoc_name, assoc|
+            include_assoc = (access == :read && assoc[:options][:access] != :w) || (access == :write && assoc[:options][:access] != :ro) || access.nil?
+            next unless include_assoc
+
+            associations[assoc_name] = {}
+            associations[assoc_name][:optional] = true if assoc[:options][:optional]
+            associations[assoc_name][:access] = (assoc[:options][:access] || :rw) if access.nil?
+
+            if assoc[:attr_map] && assoc[:attr_map] != assoc[:klass_name].to_s.constantize.attribute_map(@name)
+              associations[assoc_name].merge!(assoc[:attr_map].schema(access, schema_classes)) unless schema_classes.include?(assoc[:klass_name])
+            end
+          end
+        end
+      end
+
+  end
+end

data/lib/delineate/serialization.rb

@@ -0,0 +1,131 @@
+module Delineate
+  module Serialization
+    extend ActiveSupport::Concern
+
+    # Values for includes param:
+    #   nil = include all attributes
+    #   [] = do not include optional attributes
+    #   [...] = include the specified optional attributes
+    def serializable_attribute_names(includes = nil)
+      attribute_names = @attributes.keys.reject {|k| @attributes[k][:access] == :w}
+      return attribute_names if includes.nil?
+
+      attribute_names.delete_if do |key|
+        (option = @attributes[key][:optional]) && !includes.include?(key) && !includes.include?(option)
+      end
+    end
+
+    def serializable_association_names(includes = nil)
+      return @associations.keys if includes.nil?
+
+      @associations.inject([]) do |assoc_names, assoc|
+        assoc_names << assoc.first if !(option = assoc.last[:options][:optional]) || includes.include?(assoc.first) || includes.include?(option)
+        assoc_names
+      end
+    end
+
+    def attribute_value(record, name)
+      model_attr = model_attribute(name)
+      model_attr == :type ? record.read_attribute(:type) : record.send(model_attr)
+    end
+
+    def model_association(name)
+      @associations[name][:options][:model_attr] || name
+    end
+
+    # Access the map of an association defined in this map. Will throw an
+    # error if the map cannot be found and resolved.
+    def association_attribute_map(association)
+      assoc = @associations[association]
+      validate(assoc_attr_map(assoc), assoc[:klass_name])
+      assoc_attr_map(assoc)
+    end
+
+    # Given the specified api attributes hash, translates the attribute names to
+    # the corresponding model attribute names. Recursive translation on associations
+    # is performed. API attributes that are defined as read-only are removed.
+    #
+    # Input can be a single hash or an array of hashes.
+    def map_attributes_for_write(attrs, options = nil)
+      raise "Cannot process map #{@klass_name}:#{@name} for write because it has not been resolved" if !resolve
+
+      (attrs.is_a?(Array) ? attrs : [attrs]).each do |attr_hash|
+        raise ArgumentError, "Expected attributes hash but received #{attr_hash.inspect}" if attr_hash.is_not_a?(Hash)
+
+        attr_hash.dup.symbolize_keys.each do |k, v|
+          if (assoc = @associations[k])
+            map_association_attributes_for_write(assoc, attr_hash, k)
+          else
+            if @write_attributes.has_key?(k)
+              attr_hash.rename_key!(k, @write_attributes[k]) if @write_attributes[k] != k
+            else
+              attr_hash.delete(k)
+            end
+          end
+        end
+      end
+
+      attrs
+    end
+
+    private
+
+      # Map an association's attributes for writing. Will call
+      # map_attributes_for_write (resulting in recursion) on the association
+      # if it's a has_one or belongs_to, or calls map_attributes_for_write
+      # on each element of a has_many collection.
+      def map_association_attributes_for_write(assoc, attr_hash, key)
+        if assoc[:options][:access] == :ro
+          attr_hash.delete(key)       # Writes not allowed
+        else
+          assoc_attrs = attr_hash[key]
+          if assoc[:collection]
+            attr_hash[key] = xlate_params_for_nested_attributes_collection(assoc_attrs)
+
+            # Iterate thru each element in the collection and map its attributes
+            attr_hash[key].each do |entry_attrs|
+              entry_attrs = entry_attrs[1] if entry_attrs.is_a?(Array)
+              assoc_attr_map(assoc).map_attributes_for_write(entry_attrs)
+            end
+          else
+            # Association is a one-to-one; map its attributes
+            assoc_attr_map(assoc).map_attributes_for_write(assoc_attrs)
+          end
+
+          model_attr = assoc[:options][:model_attr] || key
+          attr_hash[(model_attr.to_s + '_attributes').to_sym] = attr_hash.delete(key)
+        end
+      end
+
+      # The Rails params hash generated from XML/JSON needs to be translated to a form
+      # compatible with ActiveRecord nested attributes, specifically with respect
+      # to association collections. For example, when the XML input is:
+      #
+      #   <entries>
+      #     <entry>
+      #       ... entry 1 stuff ...
+      #     </entry>
+      #     <entry>
+      #       ... entry 2 stuff ...
+      #     </entry>
+      #   </entries>
+      #
+      # Rails constructs the resulting params hash as:
+      #
+      #   {"entries"=>{"entry"=>[{... entry 1 stuff...}, {... entry 2 stuff...}]}}
+      #
+      # which is incompatible with ActiveRecord nested attributes. So this method
+      # detects that pattern, and translates the above to:
+      #
+      #   {"entries"=> [{... entry 1 stuff...}, {... entry 2 stuff...}]}
+      #
+      def xlate_params_for_nested_attributes_collection(assoc_attrs)
+        if assoc_attrs.is_a?(Hash) and assoc_attrs.keys.size == 1 and assoc_attrs[assoc_attrs.keys.first].is_a?(Array)
+          assoc_attrs[assoc_attrs.keys.first]
+        else
+          assoc_attrs
+        end
+      end
+
+  end
+end

data/lib/delineate/{attribute_map → serializers}/csv_serializer.rb

@@ -1,7 +1,7 @@
 require 'csv'
 
 module Delineate
-  module AttributeMap
+  module Serializers
 
     # AttributeMap serializer that handles CSV as the external data format.
     class CsvSerializer < MapSerializer

data/lib/delineate/{attribute_map → serializers}/json_serializer.rb

@@ -1,5 +1,5 @@
 module Delineate
-  module AttributeMap
+  module Serializers
 
     # AttributeMap serializer that handles JSON as the external data format.
     class JsonSerializer < MapSerializer

data/lib/delineate/{attribute_map → serializers}/xml_serializer.rb

@@ -1,5 +1,5 @@
 module Delineate
-  module AttributeMap
+  module Serializers
 
     # AttributeMap serializer that handles XML as the external data format.
     class XmlSerializer < MapSerializer

data/spec/delineate_spec.rb

@@ -481,7 +481,7 @@ describe "AttributeMap Serializer" do
 end
 
 
-describe "AttributeMap Deerializer" do
+describe "AttributeMap Deserializer" do
   it "handles inputting attributes from a hash for new objects" do
     h = {:title => "New title", :content => "New content"}
 
@@ -660,3 +660,17 @@ describe "AttributeMap Deerializer" do
   end
 
 end
+
+describe "AttributeMap Schema" do
+  it "shows a map schema" do
+    expected_schema = {:attributes=>
+                            {:id=>{:type=>:integer, :access=>:rw}, :title=>{:type=>:string, :access=>:rw}, :content=>{:type=>:text, :access=>:rw}, :created_at=>{:type=>:datetime, :access=>:ro}, :heavy_attr=>{:type=>nil, :access=>:ro}},
+                       :associations=>
+                            {:author=>{:access=>:rw, :attributes=>{:id=>{:type=>:integer, :access=>:rw}, :first_name=>{:type=>:string, :access=>:rw}, :last_name=>{:type=>:string, :access=>:rw}, :name=>{:type=>nil, :access=>:ro}}, :associations=>{:email=>{:access=>:rw}, :posts=>{:optional=>true, :access=>:rw}, :author_group=>{:optional=>true, :access=>:rw}}},
+                             :topics=>{:access=>:rw}, :comments=>{:optional=>true, :access=>:rw}
+                            }
+    }
+    expect(Post.attribute_map(:api).schema).to eql(expected_schema)
+  end
+
+end

data/spec/spec_helper.rb

@@ -2,11 +2,9 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'rubygems'
-#require 'bundler/setup'
-#Bundler.require
 
-#require 'simplecov'
-#SimpleCov.start
+require 'simplecov'
+SimpleCov.start
 
 ENV['RAILS_ENV'] = 'test'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delineate
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Tom Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-21 00:00:00.000000000 Z
+date: 2014-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
@@ -144,12 +144,14 @@ files:
 - lib/class_inheritable_attributes.rb
 - lib/core_extensions.rb
 - lib/delineate.rb
-- lib/delineate/attribute_map/attribute_map.rb
-- lib/delineate/attribute_map/csv_serializer.rb
-- lib/delineate/attribute_map/json_serializer.rb
-- lib/delineate/attribute_map/map_serializer.rb
-- lib/delineate/attribute_map/xml_serializer.rb
+- lib/delineate/attribute_map.rb
 - lib/delineate/map_attributes.rb
+- lib/delineate/map_serializer.rb
+- lib/delineate/schema.rb
+- lib/delineate/serialization.rb
+- lib/delineate/serializers/csv_serializer.rb
+- lib/delineate/serializers/json_serializer.rb
+- lib/delineate/serializers/xml_serializer.rb
 - spec/database.yml
 - spec/delineate_spec.rb
 - spec/spec_helper.rb

data/lib/delineate/attribute_map/map_serializer.rb

@@ -1,170 +0,0 @@
-module Delineate #:nodoc:
-  module AttributeMap
-
-    # The MapSerializer class serves as the base class for processing the
-    # reading and writing of ActiveRecord model attributes through an
-    # attribute map. Each serializer class supports its own external format
-    # for the input/output of the attributes. The format handled by MapSerializer
-    # is a hash.
-    class MapSerializer
-
-      # Creates a serializer for a single record.
-      #
-      # The +attribute_map+ parameter can be an AttributeMap instance or the
-      # name of the record's attribute map. The +options+ hash is used to
-      # filter which attributes and associations are to be serialized for
-      # output, and can have the following keys:
-      #
-      #   :include  Specifies which optional attributes and associations to output.
-      #   :only     Restricts the attributes and associations to only those specified.
-      #   :except   Processes attributes and associations except those specified.
-      #
-      # See the description for +mapped_attributes+ for more info about options.
-      #
-      def initialize(record, attribute_map, options = nil)
-        @record = record
-        attribute_map = record.send(:attribute_map, attribute_map) if attribute_map.is_a?(Symbol)
-        @attribute_map = attribute_map
-        @options = options ? options.dup : {}
-      end
-
-      # Returns the record's mapped attributes in the serializer's intrinsic format.
-      #
-      # For the MapSerializer class the attributes are returned as a hash,
-      # and the +options+ parameter is ignored.
-      def serialize(options = {})
-        @attribute_map.resolve! unless @attribute_map.resolved?
-        serializable_record
-      end
-
-      # Takes a record's attributes in the serializer's intrinsic format, and
-      # returns a hash suitable for direct assignment to the record's collection
-      # of attributes. For example:
-      #
-      #   s = ActiveRecord::AttributeMap::MapSerializer.new(record, :api)
-      #   record.attributes = s.serialize_in(attrs_hash)
-      #
-      def serialize_in(attributes, options = {})
-        @attribute_map.resolve! unless @attribute_map.resolved?
-        @attribute_map.map_attributes_for_write(attributes, options)
-      end
-
-      # Returns the record's mapped attributes in the serializer's "internal"
-      # format, usually this is a hash.
-      def serializable_record
-        returning(serializable_record = Hash.new) do
-          serializable_attribute_names.each do |name|
-            serializable_record[name] = @attribute_map.attribute_value(@record, name)
-          end
-
-          add_includes do |association, records, opts|
-            polymorphic = @attribute_map.associations[association][:options][:polymorphic]
-            assoc_map = association_attribute_map(association)
-
-            if records.is_a?(Enumerable)
-              serializable_record[association] = records.collect do |r|
-                assoc_map = attribute_map_for_record(r) if polymorphic
-                self.class.new(r, assoc_map, opts).serializable_record
-              end
-            else
-              assoc_map = attribute_map_for_record(records) if polymorphic
-              serializable_record[association] = self.class.new(records, assoc_map, opts).serializable_record
-            end
-          end
-        end
-      end
-
-      protected
-
-        # Returns the list of mapped attribute names that are to be output
-        # by applying the serializer's +:include+, +:only+, and +:except+
-        # options to the attribute map.
-        def serializable_attribute_names
-          includes = @options[:include] || []
-          includes = [] if includes.is_a?(Hash)
-          attribute_names = @attribute_map.serializable_attribute_names(Array(includes))
-
-          if @options[:only]
-            @options.delete(:except)
-            attribute_names & Array(@options[:only])
-          else
-            @options[:except] = Array(@options[:except])
-            attribute_names - @options[:except]
-          end
-        end
-
-        # Returns the list of mapped association names that are to be output
-        # by applying the serializer's +:include+ to the attribute map.
-        def serializable_association_names(includes)
-          assoc_includes = includes
-          if assoc_includes.is_a?(Array)
-            if (h = includes.detect {|i| i.is_a?(Hash)})
-              assoc_includes = h.dup
-              includes.each { |i| assoc_includes[i] = {} unless i.is_a?(Hash) }
-            end
-          end
-
-          include_has_options = assoc_includes.is_a?(Hash)
-          include_associations = include_has_options ? assoc_includes.keys : Array(assoc_includes)
-          associations = @attribute_map.serializable_association_names(include_associations)
-
-          if @options[:only]
-            @options.delete(:except)
-            associations = associations & Array(@options[:only])
-          else
-            @options[:except] = Array(@options[:except])
-            associations = associations - @options[:except]
-          end
-
-          [assoc_includes, associations]
-        end
-
-        # Helper for serializing nested models
-        def add_includes(&block)
-          includes = @options.delete(:include)
-          assoc_includes, associations = serializable_association_names(includes)
-
-          for association in associations
-            model_assoc = @attribute_map.model_association(association)
-
-            records = case reflection(model_assoc).macro
-            when :has_many, :has_and_belongs_to_many
-              @record.send(model_assoc).to_a
-            when :has_one, :belongs_to
-              @record.send(model_assoc)
-            end
-
-            yield(association, records, assoc_includes.is_a?(Hash) ? assoc_includes[association] : {}) if records
-          end
-
-          @options[:include] = includes if includes
-        end
-
-        # Returns an association's attribute map - argument is external name
-        def association_attribute_map(association)
-          @attribute_map.association_attribute_map(association)
-        end
-
-        # Returns the attribute map for the specified record - ensures it
-        # is resolved and valid.
-        def attribute_map_for_record(record)
-          @attribute_map.validate(record.attribute_map(@attribute_map.name), record.class.name)
-        end
-
-        # Gets association reflection
-        def reflection(model_assoc)
-          klass = @record.class
-          reflection = klass.reflect_on_association(model_assoc)
-          reflection || (klass.cti_base_class.reflect_on_association(model_assoc) if klass.is_cti_subclass?)
-        end
-
-        SERIALIZER_CLASS_OPTIONS = [:include, :only, :except, :context]
-
-        def remove_serializer_class_options(options)
-          options.reject {|k,v| SERIALIZER_CLASS_OPTIONS.include?(k)}
-        end
-
-    end
-
-  end
-end