nested_record 0.1.1 → 1.0.0.beta

data/lib/nested_record/methods/many.rb

@@ -0,0 +1,113 @@
+class NestedRecord::Methods
+  class Many < self
+    def initialize(setup)
+      super
+      define :writer
+      define :rewrite_attributes
+      define :upsert_attributes
+      define :validation
+      define_attributes_writer_method
+    end
+
+    def validation_method_name
+      :"validate_associated_records_for_#{@setup.name}"
+    end
+
+    def writer_method_body
+      setup = @setup
+      proc do |records|
+        collection_class = setup.collection_class
+        return super(records.dup) if records.is_a? collection_class
+        collection = collection_class.new
+        records.each { |obj| collection << obj }
+        super(collection)
+      end
+    end
+
+    def upsert_attributes_method_body
+      setup = @setup
+      name = @setup.name
+      proc do |data|
+        attributes_collection =
+          if data.is_a? Hash
+            data.values
+          else
+            data
+          end
+        collection = public_send(name)
+        attributes_collection.each do |attributes|
+          attributes = attributes.stringify_keys
+          next if setup.reject_if_proc&.call(attributes)
+
+          if (pkey_attributes = setup.primary_key)
+            klass = setup.record_class
+          else
+            klass = setup.record_class.find_subtype(attributes['type'])
+            while !(pkey_attributes = klass.primary_key) && (klass < NestedRecord::Base)
+              klass = klass.superclass
+            end
+            unless pkey_attributes
+              raise NestedRecord::ConfigurationError, 'You should specify a primary_key when using :upsert strategy'
+            end
+          end
+          key = { _is_a?: klass }
+          pkey_attributes.each do |name|
+            value = attributes[name]
+            if (type = klass.type_for_attribute(name))
+              value = type.cast(value)
+            end
+            key[name] = value
+          end
+          if (record = collection.find_by(key))
+            record.assign_attributes(attributes)
+          else
+            collection.build(attributes)
+          end
+        end
+      end
+    end
+
+    def rewrite_attributes_method_body
+      setup = @setup
+      writer_method_name = self.writer_method_name
+      proc do |data|
+        attributes_collection =
+          if data.is_a? Hash
+            data.values
+          else
+            data
+          end
+        collection = setup.collection_class.new
+        attributes_collection.each do |attributes|
+          attributes = attributes.stringify_keys
+          next if setup.reject_if_proc&.call(attributes)
+          collection.build(attributes)
+        end
+        public_send(writer_method_name, collection)
+      end
+    end
+
+    def validation_method_body
+      name = @setup.name
+      proc do
+        collection = public_send(name)
+        collection.map.with_index do |record, index|
+          next true if record.valid?
+          record.errors.each do |attribute, message|
+            error_attribute = "#{name}[#{index}].#{attribute}"
+            errors[error_attribute] << message
+            errors[error_attribute].uniq!
+          end
+          record.errors.details.each_key do |attribute|
+            error_attribute = "#{name}[#{index}].#{attribute}"
+            record.errors.details[attribute].each do |error|
+              errors.details[error_attribute] << error
+              errors.details[error_attribute].uniq!
+            end
+          end
+          false
+        end.all?
+      end
+    end
+  end
+end

data/lib/nested_record/methods/one.rb

@@ -0,0 +1,86 @@
+class NestedRecord::Methods
+  class One < self
+    def initialize(setup)
+      super
+      define :writer
+      define :build
+      alias_method rewrite_attributes_method_name, build_method_name
+      define :bang
+      define :upsert_attributes
+      define :validation
+      define_attributes_writer_method
+    end
+
+    def writer_method_body
+      setup = @setup
+      proc do |record|
+        unless record.nil? || record.kind_of?(setup.record_class)
+          raise NestedRecord::TypeMismatchError, "#{record.inspect} should be a #{setup.record_class}"
+        end
+        super(record)
+      end
+    end
+
+    def build_method_name
+      :"build_#{@setup.name}"
+    end
+
+    def build_method_body
+      setup = @setup
+      writer_method_name = self.writer_method_name
+      proc do |attributes = {}|
+        record = setup.record_class.new(attributes)
+        public_send(writer_method_name, record)
+      end
+    end
+
+    def bang_method_name
+      :"#{@setup.name}!"
+    end
+
+    def bang_method_body
+      <<~RUBY
+        #{@setup.name} || #{build_method_name}
+      RUBY
+    end
+
+    def upsert_attributes_method_body
+      build_method_name = self.build_method_name
+      name = @setup.name
+      proc do |attributes|
+        if (record = public_send(name))
+          record.assign_attributes(attributes)
+        else
+          public_send(build_method_name, attributes)
+        end
+      end
+    end
+
+    def validation_method_name
+      :"validate_associated_record_for_#{@setup.name}"
+    end
+
+    def validation_method_body
+      name = @setup.name
+      proc do
+        record = public_send(name)
+        return true unless record
+        return true if record.valid?
+
+        record.errors.each do |attribute, message|
+          error_attribute = "#{name}.#{attribute}"
+          errors[error_attribute] << message
+          errors[error_attribute].uniq!
+        end
+        record.errors.details.each_key do |attribute|
+          error_attribute = "#{name}.#{attribute}"
+          record.errors.details[attribute].each do |error|
+            errors.details[error_attribute] << error
+            errors.details[error_attribute].uniq!
+          end
+        end
+        false
+      end
+    end
+  end
+end

data/lib/nested_record/setup.rb

@@ -1,22 +1,60 @@
 # frozen_string_literal: true
 
 class NestedRecord::Setup
-  def initialize(owner, name, **options, &extension)
+  attr_reader :name, :primary_key, :reject_if_proc
+
+  def initialize(owner, name, **options, &block)
     @options = options
     @owner = owner
-    if options[:class_name]
-      @record_class = options[:class_name]
+    @name = name
+
+    if block
+      case (cn = options.fetch(:class_name) { false })
+      when true
+        cn = name.to_s.camelize
+        cn = cn.singularize if self.is_a?(HasMany)
+        class_name = cn
+      when false
+        class_name = nil
+      when String, Symbol
+        class_name = cn.to_s
+      else
+        raise NestedRecord::ConfigurationError, "Bad :class_name option #{cn.inspect}"
+      end
+      @record_class = Class.new(NestedRecord::Base, &block)
+      @owner.const_set(class_name, @record_class) if class_name
     else
-      @record_class = name.to_s.camelize
-      @record_class = @record_class.singularize if self.is_a?(HasMany)
+      if options.key? :class_name
+        case (cn = options.fetch(:class_name))
+        when String, Symbol
+          @record_class = cn.to_s
+        else
+          raise NestedRecord::ConfigurationError, "Bad :class_name option #{cn.inspect}"
+        end
+      else
+        cn = name.to_s.camelize
+        cn = cn.singularize if self.is_a?(HasMany)
+        @record_class = cn
+      end
     end
-    @name = name
-    @extension = extension
 
-    define_methods
+    case (aw = options.fetch(:attributes_writer) { {} })
+    when Hash
+      @attributes_writer_opts = aw
+    when true, false
+      @attributes_writer_opts = {}
+    when Symbol
+      @attributes_writer_opts = { strategy: aw }
+    else
+      raise NestedRecord::ConfigurationError, "Bad :attributes_writer option #{aw.inspect}"
+    end
+    @reject_if_proc = @attributes_writer_opts[:reject_if]
+
+    @methods_extension = build_methods_extension
 
     @owner.attribute @name, type, default: default_value
-    @owner.validate validation_method_name
+    @owner.include @methods_extension
+    @owner.validate @methods_extension.validation_method_name
   end
 
   def record_class
@@ -26,57 +64,36 @@ class NestedRecord::Setup
     @record_class
   end
 
-  private
-
-  def writer_method_name
-    @writer_method_name ||= :"#{@name}="
-  end
-
-  def attributes_writer_method_name
-    @attributes_writer_method_name ||= :"#{@name}_attributes="
+  def primary_key
+    return @primary_key if defined? @primary_key
+    @primary_key = Array(@options[:primary_key])
+    if @primary_key.empty?
+      @primary_key = nil
+    else
+      @primary_key = @primary_key.map(&:to_s)
+    end
+    @primary_key
   end
 
-  def validation_method_name
-    @validation_method_name ||= :"validate_associated_records_for_#{@name}"
+  def attributes_writer_strategy
+    return unless @options.fetch(:attributes_writer) { true }
+    case (strategy = @attributes_writer_opts.fetch(:strategy) { :upsert })
+    when :rewrite, :upsert
+      return strategy
+    else
+      raise NestedRecord::ConfigurationError, "Unknown strategy #{strategy.inspect}"
+    end
   end
 
-  def define_methods
-    define_writer_method
-    define_attributes_writer_method
-    define_validation_method
-  end
+  private
 
   class HasMany < self
-    def initialize(*)
-      super
-      if (attributes_writer_opts = @options[:attributes_writer]).is_a? Hash
-        @reject_if_proc = attributes_writer_opts[:reject_if]
-      end
-    end
-
     def type
-      @type ||= NestedRecord::Type::HasMany.new(self)
-    end
-
-    def collection_class_name
-      @collection_class_name ||= :"NestedRecord_Many#{@name.to_s.camelize}"
+      @type ||= NestedRecord::Type::Many.new(self)
     end
 
     def collection_class
-      return @owner.const_get(collection_class_name, false) if @owner.const_defined?(collection_class_name, false)
-      extension = @extension
-      collection_superclass = record_class.collection_class
-      @owner.const_set(
-        collection_class_name,
-        Class.new(collection_superclass) do
-          @record_class = collection_superclass.record_class
-          include Module.new(&extension) if extension
-        end
-      )
-    end
-
-    def reject?(attributes)
-      @reject_if_proc&.call(attributes)
+      record_class.collection_class
     end
 
     private
@@ -85,76 +102,14 @@ class NestedRecord::Setup
       []
     end
 
-    def define_writer_method
-      setup = self
-      @owner.define_method(writer_method_name) do |records|
-        collection_class = setup.collection_class
-        return super(records.dup) if records.is_a? collection_class
-        collection = collection_class.new
-        records.each do |obj|
-          collection << obj
-        end
-        super(collection)
-      end
-    end
-
-    def define_attributes_writer_method
-      return unless @options.fetch(:attributes_writer) { true }
-      setup = self
-      writer_method = writer_method_name
-      @owner.define_method(attributes_writer_method_name) do |data|
-        attributes_collection =
-          if data.is_a? Hash
-            data.values
-          else
-            data
-          end
-        collection = setup.collection_class.new
-        attributes_collection.each do |attributes|
-          attributes = attributes.stringify_keys
-          next if setup.reject?(attributes)
-          collection.build(attributes)
-        end
-        public_send(writer_method, collection)
-      end
-    end
-
-    def define_validation_method
-      setup = self
-      name = @name
-      @owner.define_method(validation_method_name) do
-        collection = public_send(name)
-        collection.map do |record|
-          next true if record.valid?
-          record.errors.each do |attribute, message|
-            error_attribute = "#{name}.#{attribute}"
-            errors[error_attribute] << message
-            errors[error_attribute].uniq!
-          end
-          record.errors.details.each_key do |attribute|
-            error_attribute = "#{name}.#{attribute}"
-            record.errors.details[attribute].each do |error|
-              errors.details[error_attribute] << error
-              errors.details[error_attribute].uniq!
-            end
-          end
-          false
-        end.all?
-      end
+    def build_methods_extension
+      NestedRecord::Methods::Many.new(self)
     end
   end
 
   class HasOne < self
-    def define_methods
-      define_writer_method
-      define_build_method
-      define_attributes_writer_method
-      define_validation_method
-      define_bang_method
-    end
-
     def type
-      @type ||= NestedRecord::Type::HasOne.new(self)
+      @type ||= NestedRecord::Type::One.new(self)
     end
 
     private
@@ -163,68 +118,8 @@ class NestedRecord::Setup
       nil
     end
 
-    def build_method_name
-      :"build_#{@name}"
-    end
-
-    def bang_method_name
-      :"#{@name}!"
-    end
-
-    def define_writer_method
-      setup = self
-      @owner.define_method(writer_method_name) do |record|
-        unless record.nil? || record.kind_of?(setup.record_class)
-          raise NestedRecord::TypeMismatchError, "#{record.inspect} should be a #{setup.record_class}"
-        end
-        super(record)
-      end
-    end
-
-    def define_attributes_writer_method
-      return unless @options.fetch(:attributes_writer) { true }
-      @owner.alias_method attributes_writer_method_name, build_method_name
-    end
-
-    def define_validation_method
-      setup = self
-      name = @name
-      @owner.define_method(validation_method_name) do
-        record = public_send(name)
-        return true unless record
-        return true if record.valid?
-
-        record.errors.each do |attribute, message|
-          error_attribute = "#{name}.#{attribute}"
-          errors.details[error_attribute] << message
-          errors.details[error_attribute].uniq!
-        end
-        record.errors.details.each_key do |attribute|
-          error_attribute = "#{name}.#{attribute}"
-          record.errors.details[attribute].each do |error|
-            errors.details[error_attribute] << error
-            errors.details[error_attribute].uniq!
-          end
-        end
-        false
-      end
-    end
-
-    def define_build_method
-      setup = self
-      writer_method = writer_method_name
-      @owner.define_method(build_method_name) do |attributes = {}|
-        record = setup.record_class.new(attributes)
-        public_send(writer_method, record)
-      end
-    end
-
-    def define_bang_method
-      @owner.class_eval <<~RUBY
-        def #{bang_method_name}
-          #{@name} || #{build_method_name}
-        end
-      RUBY
+    def build_methods_extension
+      NestedRecord::Methods::One.new(self)
     end
   end
 end