delineate 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7fcb6ebbc0458a87120f829033d853357317bfa1
-  data.tar.gz: a7ee9aef7c42dd4c1e794935ac6e71c6ada2c7af
+  metadata.gz: a6242128797a0959401231046cd088cf6c4d3cd5
+  data.tar.gz: 3c04565b00c65ee61c96c1f87b9154722060ef9f
 SHA512:
-  metadata.gz: 80fd619678b2808735873628329e4b8d6b7103e586ce3f70c12b9b44e0d2b65fec6f593cac7e625ae9101d65c39f9fe15f2ba24843b5ce42dfaeaa8e97b3e3ef
-  data.tar.gz: e2c886ce454cf4782be0bf957d38a64dd677ee2133960a9c8b0ca8dbbcb6c00a55bad653070b315bb5ff498c01d363ae9b6f9485c512ffd3593b7e5f2d2fa90c
+  metadata.gz: f5412696a28e4d9c40b97496ab6d5182943adbfb3b3b01e59bd4203d4ee47b4feef056f3348300cba91ba3990424ec83e932742e24b81b7635c2a848b21e07b5
+  data.tar.gz: 87587a174725ecd3d79a68abd1a38163ae1d3fc69a9b6e11d2dfa17e348340a5cbf9a713f0dc8000bddfd65f43a3f6e62cecc0584cd2adc359fdd7457836cc69

data/VERSION

@@ -1 +1 @@
-0.6.1
+0.6.2

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.1 ruby lib
+# stub: delineate 0.6.2 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "delineate"
-  s.version = "0.6.1"
+  s.version = "0.6.2"
 
   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-23"
+  s.date = "2014-02-28"
   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 = [
@@ -34,6 +34,7 @@ Gem::Specification.new do |s|
     "lib/delineate/attribute_map.rb",
     "lib/delineate/map_attributes.rb",
     "lib/delineate/map_serializer.rb",
+    "lib/delineate/resolve.rb",
     "lib/delineate/schema.rb",
     "lib/delineate/serialization.rb",
     "lib/delineate/serializers/csv_serializer.rb",

data/lib/delineate/attribute_map.rb

@@ -1,5 +1,6 @@
 require 'active_support/core_ext/hash/deep_dup.rb'
 
+require 'delineate/resolve'
 require 'delineate/serialization'
 require 'delineate/schema'
 
@@ -222,12 +223,10 @@ module Delineate
           @attributes[name] = options
 
           model_attr = (options[:model_attr] || name).to_sym
-          model_attr = define_attr_methods(name, model_attr, options) unless is_model_attr?(model_attr)
+          model_attr = define_attr_methods(name, model_attr, options)
 
           if options[:access] != :ro
-            if model_attr.to_s != klass.primary_key && !klass.accessible_attributes.detect { |a| a == model_attr.to_s }
-              raise "Expected 'attr_accessible :#{model_attr}' in #{@klass_name}"
-            end
+            validate_attr_writable(model_attr)
             @write_attributes[name] = model_attr
           end
         end
@@ -246,12 +245,7 @@ module Delineate
 
       attr_map.instance_eval(&blk) if block_given?
 
-      if !merge_option?(options) && attr_map.empty?
-        raise ArgumentError, "Map association '#{name}' in class #{@klass_name} specifies :replace but has empty block"
-      end
-      if options[:access] != :ro and !klass.accessible_attributes.include?(model_attr.to_s+'_attributes')
-        raise "Expected attr_accessible and/or accepts_nested_attributes_for :#{model_attr} in #{@klass_name} model"
-      end
+      validate_assoc_map(name, model_attr, attr_map, options)
 
       @associations[name] = {:klass_name => reflection.class_name, :options => options,
                              :attr_map => attr_map.empty? ? nil : attr_map,
@@ -263,7 +257,7 @@ module Delineate
       return if other_attr_map.nil?
 
       @attributes = @attributes.deep_merge(other_attr_map.attributes)
-      @associations.deep_merge!(other_attr_map.associations)
+      @associations = @associations.deep_merge(other_attr_map.associations)
 
       @write_attributes = {:_destroy => :_destroy}
       @attributes.each {|k, v| @write_attributes[k] = (v[:model_attr] || k) unless v[:access] == :ro}
@@ -297,31 +291,6 @@ 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
 
@@ -354,8 +323,10 @@ module Delineate
           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}'"
+          rescue => e
+            msg = "Cannot resolve association class '#{reflection.class_name}' from model '#{@klass_name}'"
+            msg += "\n#{e.message}"
+            raise NameError, msg
           end
         end
       end
@@ -384,7 +355,7 @@ module Delineate
         validate_access_option(options[:access])
         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, 'Cannot specify :override or provide block with :polymorphic' if options[:polymorphic] && (blk or options[:override])
         raise ArgumentError, 'Option :override must = :replace or :merge' unless !options.key?(:override) || [:merge, :replace].include?(options[:override])
       end
 
@@ -411,70 +382,37 @@ module Delineate
         raise ArgumentError, 'Invalid value for :access option' if opt and !VALID_ACCESS_OPTIONS.include?(opt)
       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
-
-      def resolve_associations(must_resolve, resolving)
-        result = true
-
-        @associations.each do |assoc_name, assoc|
-          if detect_circular_merge(assoc)
-            raise "Detected attribute map circular merge references: class=#{@klass_name}, association=#{assoc_name}"
-          end
-
-          assoc_map = assoc[:attr_map] || assoc[:klass_name].constantize.attribute_maps.try(:fetch, @name, nil)
-          if assoc_map && !assoc_map.resolved?
-            if assoc_map.resolve(must_resolve, resolving) && merge_option?(assoc[:options]) && assoc[:attr_map]
-              merge_map = assoc[:klass_name].constantize.attribute_maps[@name]
-              assoc_map = merge_map.dup.merge!(assoc_map, :with_options => true, :with_state => true)
-            end
-          end
-          assoc[:attr_map] = assoc_map
-
-          if assoc_map.nil? or !assoc_map.resolve(false, resolving)
-            result = false
-            raise "Cannot resolve map for association :#{assoc_name} in #{@klass_name}:#{@name} map" if must_resolve
-          end
+      def validate_attr_writable(attr_name)
+        if attr_name.to_s != klass.primary_key && !klass.accessible_attributes.detect { |a| a == attr_name.to_s }
+          raise "Expected 'attr_accessible :#{attr_name}' in #{@klass_name}"
         end
-
-        result
       end
 
-      # If this is the map of an STI subclass, inherit/merge the map from the base class
-      def resolve_sti_baseclass(must_resolve, resolving)
-        result = true
-
-        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))
-          else
-            result = false
-            raise "Can't resolve base class map for #{@klass_name}:#{@name} map" if must_resolve
-          end
+      def validate_assoc_map(name, model_attr, attr_map, options)
+        if !merge_option?(options) && attr_map.empty?
+          raise ArgumentError, "Map association '#{name}' in class #{@klass_name} specifies :replace but has empty block"
+        end
+        if options[:access] != :ro and !klass.accessible_attributes.include?(model_attr.to_s+'_attributes')
+          raise "Expected attr_accessible and/or accepts_nested_attributes_for :#{model_attr} in #{@klass_name} model"
         end
-
-        result
       end
 
-      # 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])
-        return unless (map = assoc[:klass_name].constantize.attribute_maps.try(:fetch, @name, nil))
-
-        map.associations.each_value do |a|
-          return true if a[:klass_name] == @klass_name && merge_option?(a[:options]) && a[:attr_map]
-        end
+      def validate_attr_accessor(read_or_write, options)
+        return unless (accessor = options[read_or_write])
+        raise ArgumentError, "Invalid parameter for #{read_or_write}" unless (accessor.is_a?(Symbol) || accessor.is_a?(Proc))
+        accessor
+      end
 
-        false
+      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
 
       # Defines custom read/write attribute methods
       def define_attr_methods(name, model_attr, options)
+        return model_attr if is_model_attr?(model_attr)
+
         read_model_attr  = define_attr_reader_method(name, model_attr, options)
         write_model_attr = define_attr_writer_method(name, model_attr, options)
 
@@ -486,10 +424,9 @@ module Delineate
       end
 
       def define_attr_reader_method(name, model_attr, options)
-        return unless (reader = options[:read])
-        raise ArgumentError, 'Invalid parameter for :read' unless (reader.is_a?(Symbol) || reader.is_a?(Proc))
+        return unless (reader = validate_attr_accessor(:read, options))
 
-        returning(model_attr == name ? "#{name}_#{@name}" : model_attr) do |method_name|
+        returning accessor_method_name(name, model_attr) do |method_name|
           if reader.is_a?(Symbol)
             klass.class_eval %(
               def #{method_name}
@@ -511,10 +448,9 @@ module Delineate
       end
 
       def define_attr_writer_method(name, model_attr, options)
-        return unless (writer = options[:write])
-        raise ArgumentError, 'Invalid parameter for :write' unless (writer.is_a?(Symbol) || writer.is_a?(Proc))
+        return unless (writer = validate_attr_accessor(:write, options))
 
-        returning(model_attr == name ? "#{name}_#{@name}" : model_attr) do |method_name|
+        returning accessor_method_name(name, model_attr) do |method_name|
           if writer.is_a?(Symbol)
             klass.class_eval %(
               def #{method_name}=(value)
@@ -537,6 +473,12 @@ module Delineate
         end
       end
 
+      def accessor_method_name(name, model_attr)
+        model_attr == name ? "#{name}_#{@name}" : model_attr
+      end
+
+
+    include Resolve
     include Serialization
     include Schema
 

data/lib/delineate/map_attributes.rb

@@ -8,6 +8,7 @@ module ActiveRecord
 
     # Collection of declared attribute maps for the model class
     class_inheritable_accessor :attribute_maps
+    #class_attribute :attribute_maps
     self.attribute_maps = {}
 
     # The map_attributes method lets an ActiveRecord model class define a set
@@ -112,7 +113,7 @@ module ActiveRecord
     end
 
     def attribute_map(map_name)
-      self.class.attribute_maps[map_name]
+      self.class.attribute_map(map_name)
     end
 
     # Returns the attributes as specified in the attribut map. The +format+ paramater
@@ -179,6 +180,7 @@ module ActiveRecord
         raise "Base class for CTI subclass #{self.name} must specify attribute map #{map.name}" unless base_class_map
 
         map.copy(base_class_map)
+        map.associations.delete_if {|k, a| a[:klass_name] == self.name}
         map.instance_variable_set(:@resolved, false)
       end
 

data/lib/delineate/resolve.rb

@@ -0,0 +1,97 @@
+module Delineate
+  module Resolve
+    extend ActiveSupport::Concern
+
+    # Returns true if this map is fully resolved
+    def resolved?
+      @resolved
+    end
+
+    # Attempts to resolve this map and the maps it depends on, including declared associations.
+    # Will raise an exception if the map cannot be fully resolved.
+    def resolve!
+      resolve(:must_resolve)
+      self
+    end
+
+    # Attempts to resolve this map and the maps it depends on, including declared associations,
+    # and returns success status as a boolean. If the +must_resolve+ parameter is truthy, raises
+    # raise an exception if the map cannot be fully 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
+
+    private
+
+      # Resolves association maps, and handles map merges as necessary
+      def resolve_associations(must_resolve, resolving)
+        result = true
+
+        @associations.each do |assoc_name, assoc|
+          detect_circular_merge!(assoc_name, assoc)
+
+          assoc_map = assoc[:attr_map] || assoc[:klass_name].constantize.attribute_maps.try(:fetch, @name, nil)
+          if assoc_map && assoc_map.resolve(must_resolve, resolving)
+            assoc_map = merge_assoc_map(assoc, assoc_map) if merge_option?(assoc[:options])
+          end
+
+          assoc[:attr_map] = assoc_map
+
+          if assoc_map.nil? or !assoc_map.resolve(false, resolving)
+            result = false
+            raise "Cannot resolve map for association :#{assoc_name} in #{@klass_name}:#{@name} map" if must_resolve
+          end
+        end
+
+        result
+      end
+
+      # If this is the map of an STI subclass, inherit/merge the map from the base class
+      def resolve_sti_baseclass(must_resolve, resolving)
+        result = true
+
+        if merge_option?(@options) && klass_sti_subclass? && !@sti_baseclass_merged
+          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))
+          else
+            result = false
+            raise "Can't resolve base class map for #{@klass_name}:#{@name} map" if must_resolve
+          end
+        end
+
+        result
+      end
+
+      # Raises exception 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_name, assoc)
+        return if assoc.nil? || assoc[:attr_map].nil? || !merge_option?(assoc[:options])
+        return unless (map = assoc[:klass_name].constantize.attribute_maps.try(:fetch, @name, nil))
+
+        map.associations.each_value do |a|
+          if a[:klass_name] == @klass_name && merge_option?(a[:options]) && a[:attr_map]
+            raise "Detected attribute map circular merge references: class=#{@klass_name}, association=#{assoc_name}"
+          end
+        end
+      end
+
+      def merge_assoc_map(assoc, assoc_map)
+        if merge_option?(assoc[:options]) && assoc[:attr_map]
+          merge_map = assoc[:klass_name].constantize.attribute_maps[@name]
+          assoc_map = merge_map.dup.merge!(assoc_map, :with_options => true, :with_state => true)
+        end
+        assoc_map
+      end
+
+  end
+end

data/lib/delineate/serializers/csv_serializer.rb

@@ -14,8 +14,8 @@ module Delineate
       # of the attributes.
       def serialize(options = {})
         opts = options[:include_header] ?
-          {:write_headers => true, :headers => serializable_header, :encoding => "UTF-8"} :
-          {:encoding => "UTF-8"}
+          {:write_headers => true, :headers => serializable_header, :encoding => 'UTF-8'} :
+          {:encoding => 'UTF-8'}
 
         opts = remove_serializer_class_options(options).merge(opts)
         opts.delete(:include_header)
@@ -27,18 +27,18 @@ module Delineate
 
       # Returns the header row as a CSV string.
       def serialize_header(options = {})
-        opts = {:encoding => "UTF-8"}.merge(remove_serializer_class_options(options))
+        opts = {:encoding => 'UTF-8'}.merge(remove_serializer_class_options(options))
         CSV.generate_line(serializable_header, opts)
       end
 
       # Not implemented yet.
       def serialize_in(csv_string, options = {})
-        raise "Serializing from CSV is not supported at this time. You can inherit a class from CsvSerializer to write a custom importer."
+        raise 'Serializing from CSV is not supported. You can inherit a class from CsvSerializer to write a custom importer.'
       end
 
       # Returns the record's mapped attributes in the serializer's "internal"
       # format. For this class the representation is an array of one or more
-      # rows, one row for each item in teh record's has_many collections. Each
+      # rows, one row for each item in the record's has_many collections. Each
       # row is an array of values ordered as follows:
       #
       #   1. All the record's mapped attributes in map order.
@@ -70,7 +70,7 @@ module Delineate
       end
 
       # Returns the header row as an array of strings, one for each
-      # mapped attribute, including nested assoications. The items
+      # mapped attribute, including nested associations. The items
       # appear in the array in the same order as their corresponding
       # attribute values.
       def serializable_header(prefix = '')
@@ -93,7 +93,7 @@ module Delineate
 
       private
 
-        # The diff here is that if the associaton record(s) is empty, we have to generate
+        # The diff here is that if the association record(s) is empty, we have to generate
         # a new empty record: @record.class.new.build_xxx or @record.class.new.xxx.build
         def add_includes(assoc_type)
           includes = @options.delete(:include)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delineate
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Tom Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-23 00:00:00.000000000 Z
+date: 2014-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
@@ -147,6 +147,7 @@ files:
 - lib/delineate/attribute_map.rb
 - lib/delineate/map_attributes.rb
 - lib/delineate/map_serializer.rb
+- lib/delineate/resolve.rb
 - lib/delineate/schema.rb
 - lib/delineate/serialization.rb
 - lib/delineate/serializers/csv_serializer.rb