nested_record 0.1.0

data/lib/nested_record/collection.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+class NestedRecord::Collection
+  class << self
+    attr_reader :record_class
+  end
+
+  include Enumerable
+
+  def initialize
+    @ary = []
+  end
+
+  def initialize_dup(orig)
+    @ary = orig.to_ary
+  end
+
+  def as_json
+    @ary.as_json
+  end
+
+  def each
+    return to_enum(:each) unless block_given?
+    @ary.each(&proc)
+  end
+
+  def to_ary
+    @ary.dup
+  end
+
+  def ==(other)
+    @ary == other.to_ary
+  end
+
+  def <<(obj)
+    unless obj.kind_of?(record_class)
+      raise NestedRecord::TypeMismatchError, "#{obj.inspect} should be a #{record_class}"
+    end
+    @ary << obj
+    self
+  end
+
+  def build(attributes = {})
+    record_class.new(attributes).tap do |obj|
+      self << obj
+    end
+  end
+
+  def inspect
+    @ary.inspect
+  end
+
+  def empty?
+    @ary.empty?
+  end
+
+  def clear
+    @ary.clear
+    self
+  end
+
+  def length
+    @ary.length
+  end
+
+  def select!
+    return to_enum(:select!) unless block_given?
+    @ary.select!(&proc)
+    self
+  end
+
+  def reject!
+    return to_enum(:reject!) unless block_given?
+    @ary.reject!(&proc)
+    self
+  end
+
+  def reject_by!(attrs)
+    return to_enum(:reject_by!) unless block_given?
+    attrs = attrs.stringify_keys
+    reject! { |obj| obj.match?(attrs) }
+  end
+
+  def find_by(attrs)
+    attrs = attrs.stringify_keys
+    find { |obj| obj.match?(attrs) }
+  end
+
+  def find_or_initialize_by(attrs)
+    attrs = attrs.stringify_keys
+    find_by(attrs) || build(attrs)
+  end
+
+  private
+
+  def record_class
+    self.class.record_class
+  end
+end

data/lib/nested_record/errors.rb

@@ -0,0 +1,5 @@
+module NestedRecord
+  class Error < StandardError; end
+  class TypeMismatchError < Error; end
+  class InvalidTypeError < Error; end
+end

data/lib/nested_record/lookup_const.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module NestedRecord
+  # Derived from Rails source: https://github.com/rails/rails/blob/98a57aa5f610bc66af31af409c72173cdeeb3c9e/activerecord/lib/active_record/inheritance.rb#L181-L207
+
+  def self.lookup_const(owner, type_name)
+    if type_name.start_with?('::')
+      ActiveSupport::Dependencies.constantize(type_name)
+    else
+      candidates = []
+      owner.name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
+      candidates << type_name
+
+      candidates.each do |candidate|
+        constant = ActiveSupport::Dependencies.safe_constantize(candidate)
+        return constant if candidate == constant.to_s
+      end
+
+      raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
+    end
+  end
+end

data/lib/nested_record/macro.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module NestedRecord::Macro
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def has_many_nested(name, **options, &block)
+      NestedRecord::Setup::HasMany.new(self, name, **options, &block)
+    end
+
+    def has_one_nested(name, **options)
+      NestedRecord::Setup::HasOne.new(self, name, **options)
+    end
+  end
+end

data/lib/nested_record/setup.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+class NestedRecord::Setup
+  def initialize(owner, name, **options, &extension)
+    @options = options
+    @owner = owner
+    @record_class = options[:class_name] || name.to_s.classify
+    @name = name
+    @extension = extension
+
+    define_methods
+
+    @owner.attribute @name, type, default: default_value
+    @owner.validate validation_method_name
+  end
+
+  def record_class
+    if @record_class.is_a? String
+      @record_class = NestedRecord.lookup_const(@owner, @record_class)
+    end
+    @record_class
+  end
+
+  private
+
+  def writer_method_name
+    @writer_method_name ||= :"#{@name}="
+  end
+
+  def attributes_writer_method_name
+    @attributes_writer_method_name ||= :"#{@name}_attributes="
+  end
+
+  def validation_method_name
+    @validation_method_name ||= :"validate_associated_records_for_#{@name}"
+  end
+
+  def define_methods
+    define_writer_method
+    define_attributes_writer_method
+    define_validation_method
+  end
+
+  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}"
+    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)
+    end
+
+    private
+
+    def default_value
+      []
+    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
+    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)
+    end
+
+    private
+
+    def default_value
+      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
+    end
+  end
+end

data/lib/nested_record/type.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class NestedRecord::Type < ActiveRecord::Type::Json
+  def initialize(setup)
+    @setup = setup
+  end
+
+  def cast(data)
+    cast_value(data)
+  end
+
+  def deserialize(value)
+    cast_value(super)
+  end
+
+  def serialize(obj)
+    super(obj&.as_json)
+  end
+
+  private
+
+  def record_class
+    @setup.record_class
+  end
+
+  class HasMany < self
+    private
+
+    def collection_class
+      @setup.collection_class
+    end
+
+    def cast_value(data)
+      return unless data
+      collection = collection_class.new
+      data.each do |obj|
+        if obj.is_a? Hash
+          collection << record_class.instantiate(obj)
+        elsif obj.kind_of?(record_class)
+          collection << obj
+        else
+          raise "Cannot cast #{obj.inspect}"
+        end
+      end
+      collection
+    end
+  end
+
+  class HasOne < self
+    private
+
+    def cast_value(obj)
+      return unless obj
+
+      if obj.is_a? Hash
+        record_class.instantiate(obj)
+      elsif obj.kind_of?(record_class)
+        obj
+      else
+        raise "Cannot cast #{obj.inspect}"
+      end
+    end
+  end
+end

data/lib/nested_record/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NestedRecord
+  VERSION = '0.1.0'
+end

data/nested_record.gemspec

@@ -0,0 +1,32 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "nested_record/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "nested_record"
+  spec.version       = NestedRecord::VERSION
+  spec.authors       = ["Vladimir Kochnev"]
+  spec.email         = ["hashtable@yandex.ru"]
+
+  spec.summary       = %q{ActiveModel mapper for JSON fields}
+  spec.homepage      = "https://github.com/marshall-lee/nested_record"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
+
+  spec.add_dependency "rails", "~> 5.2"
+end