nested_record 0.1.1 → 1.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4736181e42c531aad96202018bb79f79ec46aa69a0cf03a0a991abead29f4af
-  data.tar.gz: 7aa80b14123c4c8b1e8175d9ff5d187b6918d31ff0f1521a394ebd061d7b14cf
+  metadata.gz: 6708f834d18f3aeb71c1c05238bd610d63d25cd04aa2019a7e08c78bc122e6cc
+  data.tar.gz: 41aa9e91f4b29e186331e5a242901c7f860fc10b1fdb42cf1cb0b00cebf17483
 SHA512:
-  metadata.gz: f02b179664dc676bd35d4e6087194f714d58d56cf88058ea7d739be48e34ec330a1df0a2dd197eb2ed58579757331af7d13b6133ceae5a768f6b07773be0c32b
-  data.tar.gz: cffc632808753b0ecc39e2400328c42776f7a503e77f7373085438003c4efc3907d5d4a426737660875a611b22c0ce860f8eeb41b79edb1dd921dbafb7b11538
+  metadata.gz: 36d195b559a3d9c0e4cdc24234dffadc9fcc7e0decfab35e98e153d3a427b1a85c1a48d4803ff0f8fa6e1c94ea81178fe6c163625276bcaeb72b187aabe05687
+  data.tar.gz: 628ca798a9e9a704ac8d4c340d4124cba83013ac721c229a46b758452109e775f2a485971a6c0c80f9cf63eb3eff670869a0b35c60d3c2a3dac400c440facf89

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nested_record (0.1.1)
+    nested_record (1.0.0.beta)
       rails (~> 5.2)
 
 GEM
@@ -53,14 +53,14 @@ GEM
     byebug (11.0.1)
     coderay (1.1.2)
     concurrent-ruby (1.1.5)
-    crass (1.0.4)
+    crass (1.0.5)
     diff-lcs (1.3)
-    erubi (1.8.0)
+    erubi (1.9.0)
     globalid (0.4.2)
       activesupport (>= 4.2.0)
-    i18n (1.6.0)
+    i18n (1.7.0)
       concurrent-ruby (~> 1.0)
-    loofah (2.2.3)
+    loofah (2.3.1)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     mail (2.7.1)
@@ -69,11 +69,11 @@ GEM
       mimemagic (~> 0.3.2)
     method_source (0.9.2)
     mimemagic (0.3.3)
-    mini_mime (1.0.1)
+    mini_mime (1.0.2)
     mini_portile2 (2.4.0)
-    minitest (5.11.3)
-    nio4r (2.3.1)
-    nokogiri (1.10.3)
+    minitest (5.13.0)
+    nio4r (2.5.2)
+    nokogiri (1.10.4)
       mini_portile2 (~> 2.4.0)
     pry (0.12.2)
       coderay (~> 1.1.0)
@@ -100,8 +100,8 @@ GEM
     rails-dom-testing (2.0.3)
       activesupport (>= 4.2.0)
       nokogiri (>= 1.6)
-    rails-html-sanitizer (1.0.4)
-      loofah (~> 2.2, >= 2.2.2)
+    rails-html-sanitizer (1.3.0)
+      loofah (~> 2.3)
     railties (5.2.3)
       actionpack (= 5.2.3)
       activesupport (= 5.2.3)
@@ -122,7 +122,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-support (3.8.2)
-    sprockets (3.7.2)
+    sprockets (4.0.0)
       concurrent-ruby (~> 1.0)
       rack (> 1, < 3)
     sprockets-rails (3.2.1)

data/lib/nested_record.rb

@@ -9,6 +9,7 @@ module NestedRecord
   require 'nested_record/base'
   require 'nested_record/collection'
   require 'nested_record/setup'
+  require 'nested_record/methods'
   require 'nested_record/type'
   require 'nested_record/errors'
   require 'nested_record/lookup_const'

data/lib/nested_record/base.rb

@@ -7,6 +7,8 @@ class NestedRecord::Base
   include NestedRecord::Macro
 
   class << self
+    include ActiveModel::Callbacks
+
     def attributes_builder # :nodoc:
       unless defined?(@attributes_builder) && @attributes_builder
         @attributes_builder = ActiveModel::AttributeSet::Builder.new(attribute_types, _default_attributes)
@@ -15,9 +17,10 @@ class NestedRecord::Base
     end
 
     def inherited(klass)
-      if self < NestedRecord::Base
+      parent = self
+      if parent < NestedRecord::Base
         klass.class_eval do
-          attribute :type, :string
+          attribute :type, :string unless parent.has_attribute? :type
           @deep_inherted = true
         end
       end
@@ -29,31 +32,31 @@ class NestedRecord::Base
     end
 
     def new(attributes = nil)
-      if attributes
-        attributes = attributes.stringify_keys
-        klass = find_instance_class(attributes['type'])
+      if local_subtype?
+        return super
       else
-        klass = self
+        if attributes
+          attributes = attributes.stringify_keys
+          klass = find_subtype(attributes['type'])
+        else
+          klass = self
+        end
       end
       if self == klass
-        super(attributes)
+        super
       else
         klass.new(attributes)
       end
     end
 
     def instantiate(attributes)
-      klass = find_instance_class(attributes['type'])
+      klass = find_subtype(attributes['type'])
       attributes = klass.attributes_builder.build_from_database(attributes)
       klass.allocate.tap do |instance|
-        instance.instance_variable_set(:@attributes, attributes)
+        instance.init_with_attributes(attributes)
       end
     end
 
-    def collection_class_name
-      :NestedRecord_Collection
-    end
-
     def collection_class
       return const_get(collection_class_name, false) if const_defined?(collection_class_name, false)
       record_class = self
@@ -67,78 +70,83 @@ class NestedRecord::Base
     end
 
     def collection_methods(&block)
+      raise ArgumentError, 'block is required for .collection_methods' unless block
       collection_class.class_eval(&block)
     end
 
-    def inherited_types(options)
-      raise ArgumentError, '.inherited_types is supported only for base classes' if deep_inherited?
+    def subtypes(options)
+      raise NestedRecord::ConfigurationError, '.subtypes is supported only for base classes' if deep_inherited?
       if options[:full] && options[:namespace]
-        raise ArgumentError, ':full and :namespace options cannot be used at the same time'
+        raise NestedRecord::ConfigurationError, ':full and :namespace options cannot be used together'
       end
-      @inherited_types_options = options
+      @subtypes_options = options
     end
 
     def instance_type
       @instance_type ||=
-        if inherited_types_underscored?
+        if subtypes_underscored?
           type_const.underscore
         else
           type_const.dup
         end
     end
 
-    protected
-
-    def inherited_types_options
-      @inherited_types_options ||= {}
-      if deep_inherited?
-        superclass.inherited_types_options.merge(@inherited_types_options)
-      else
-        @inherited_types_options
+    def subtype(name, &block)
+      raise NotImplementedError, 'TODO: Subtyping from local subtype is not supported at the moment' if local_subtype?
+      class_name = name.to_s.camelize
+      subtype = Class.new(self) do
+        @local_subtype = true
+        @type_const = class_name
+        class_eval(&block) if block
       end
+      local_subtypes!.const_set(class_name, subtype)
     end
 
-    private
-
-    def type_const
-      if inherited_types_namespace
-        name.gsub(/\A#{inherited_types_namespace}::/, '')
-      else
-        name
+    def attribute(name, *args, primary: false, **options)
+      super(name, *args, **options).tap do
+        primary_key(name) if primary
       end
     end
 
-    def inherited_types_store_full?
-      !inherited_types_namespace && inherited_types_options.fetch(:full) { true }
+    def primary_key(*attributes)
+      unless attributes.empty?
+        self.primary_key = attributes
+      end
+      @primary_key
     end
 
-    def inherited_types_namespace
-      return @inherited_types_namespace if defined?(@inherited_types_namespace)
+    def def_primary_uuid(name)
+      attribute name, :string, default: -> { SecureRandom.uuid }, primary: true
+    end
 
-      namespace = inherited_types_options.fetch(:namespace) { false }
-      return (@inherited_types_namespace = false) unless namespace
+    def primary_key=(attributes)
+      attributes = Array(attributes)
+      raise ArgumentError, 'primary_key cannot be an empty array' if attributes.empty?
+      @primary_key = attributes.map(&:to_s)
+    end
 
-      @inherited_types_namespace = NestedRecord.lookup_const(self, namespace).name
+    def type_for_attribute(attr_name)
+      attribute_types[attr_name.to_s]
     end
 
-    def inherited_types_underscored?
-      inherited_types_options.fetch(:underscored) { false }
+    def has_attribute?(attr_name)
+      attribute_types.key?(attr_name.to_s)
     end
 
-    def find_instance_class(type_name)
+    def find_subtype(type_name)
       return self unless type_name.present?
 
-      type_name = type_name.camelize
+      type_name = type_name.to_s.camelize
 
-      subclass =
+      subclass = local_subtype(type_name)
+      subclass ||=
         begin
           if type_name.start_with?('::')
             ActiveSupport::Dependencies.constantize(type_name)
-          elsif inherited_types_store_full?
+          elsif subtypes_store_full?
             ActiveSupport::Dependencies.constantize(type_name)
-          elsif inherited_types_namespace
-            ActiveSupport::Dependencies.safe_constantize("#{inherited_types_namespace}::#{type_name}") || ActiveSupport::Dependencies.constantize(type_name)
-
+          elsif subtypes_namespace
+            ActiveSupport::Dependencies.safe_constantize("#{subtypes_namespace}::#{type_name}") || ActiveSupport::Dependencies.constantize(type_name)
           else
             NestedRecord.lookup_const(self, type_name)
           end
@@ -153,11 +161,75 @@ class NestedRecord::Base
       end
       subclass
     end
+
+    protected
+
+    def subtypes_options
+      @subtypes_options ||= {}
+      if deep_inherited?
+        superclass.subtypes_options.merge(@subtypes_options)
+      else
+        @subtypes_options
+      end
+    end
+
+    private
+
+    def collection_class_name
+      :NestedRecord_Collection
+    end
+
+    def type_const
+      @type_const ||= if subtypes_namespace
+        name.gsub(/\A#{subtypes_namespace}::/, '')
+      else
+        name
+      end
+    end
+
+    def subtypes_store_full?
+      !subtypes_namespace && subtypes_options.fetch(:full) { true }
+    end
+
+    def subtypes_namespace
+      return @subtypes_namespace if defined?(@subtypes_namespace)
+
+      namespace = subtypes_options.fetch(:namespace) { false }
+      return (@subtypes_namespace = false) unless namespace
+
+      @subtypes_namespace = NestedRecord.lookup_const(self, namespace).name
+    end
+
+    def subtypes_underscored?
+      subtypes_options.fetch(:underscored) { false }
+    end
+
+    def local_subtype?
+      @local_subtype == true
+    end
+
+    def local_subtypes
+      (const_defined?(:LocalTypes, false) && const_get(:LocalTypes, false)) || nil
+    end
+
+    def local_subtypes!
+      local_subtypes || const_set(:LocalTypes, Module.new)
+    end
+
+    def local_subtype(type_name)
+      (local_subtypes&.const_defined?(type_name, false) && local_subtypes.const_get(type_name, false)) || nil
+    end
   end
 
   def initialize(attributes = nil)
     super
-    self.type = self.class.instance_type if self.class.deep_inherited?
+    self.type = self.class.instance_type if self.class.deep_inherited? && !(attributes&.key?('type') || attributes&.key?(:type))
+    _run_initialize_callbacks
+  end
+
+  def init_with_attributes(attributes)
+    @attributes = attributes
+    _run_initialize_callbacks
   end
 
   def ==(other)
@@ -179,12 +251,21 @@ class NestedRecord::Base
 
   def match?(attrs)
     attrs.all? do |attr, others|
-      ours = read_attribute(attr)
-      if others.is_a? Array
-        others.include? ours
+      case attr
+      when :_is_a?, '_is_a?'
+        is_a? others
+      when :_instance_of?, '_instance_of?'
+        instance_of? others
       else
-        others == ours
+        ours = read_attribute(attr)
+        if others.is_a? Array
+          others.include? ours
+        else
+          others == ours
+        end
       end
     end
   end
+
+  define_model_callbacks :initialize, only: :after
 end

data/lib/nested_record/collection.rb

@@ -86,11 +86,30 @@ class NestedRecord::Collection
   end
 
   def reject_by!(attrs)
-    return to_enum(:reject_by!) unless block_given?
     attrs = attrs.stringify_keys
     reject! { |obj| obj.match?(attrs) }
   end
 
+  def select
+    if block_given?
+      dup.select! { |obj| yield obj }
+    else
+      to_enum(:select)
+    end
+  end
+
+  %i[select reject sort_by].each do |meth|
+    class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def #{meth}
+        if block_given?
+          dup.#{meth}! { |obj| yield obj }
+        else
+          to_enum(:#{meth})
+        end
+      end
+    RUBY
+  end
+
   def find_by(attrs)
     attrs = attrs.stringify_keys
     find { |obj| obj.match?(attrs) }

data/lib/nested_record/errors.rb

@@ -2,4 +2,5 @@ module NestedRecord
   class Error < StandardError; end
   class TypeMismatchError < Error; end
   class InvalidTypeError < Error; end
+  class ConfigurationError < Error; end
 end

data/lib/nested_record/macro.rb

@@ -8,8 +8,8 @@ module NestedRecord::Macro
       NestedRecord::Setup::HasMany.new(self, name, **options, &block)
     end
 
-    def has_one_nested(name, **options)
-      NestedRecord::Setup::HasOne.new(self, name, **options)
+    def has_one_nested(name, **options, &block)
+      NestedRecord::Setup::HasOne.new(self, name, **options, &block)
     end
   end
 end

data/lib/nested_record/methods.rb

@@ -0,0 +1,50 @@
+class NestedRecord::Methods < Module
+  def initialize(setup)
+    @setup = setup
+  end
+
+  def define(name)
+    method_name = public_send("#{name}_method_name")
+    method_body = public_send("#{name}_method_body")
+    case method_body
+    when Proc
+      define_method(method_name, &method_body)
+    when String
+      module_eval <<~RUBY
+        def #{method_name}
+          #{method_body}
+        end
+      RUBY
+    else
+      fail
+    end
+  end
+
+  def writer_method_name
+    :"#{@setup.name}="
+  end
+
+  def upsert_attributes_method_name
+    :"upsert_#{@setup.name}_attributes"
+  end
+
+  def rewrite_attributes_method_name
+    :"rewrite_#{@setup.name}_attributes"
+  end
+
+  def attributes_writer_method_name
+    :"#{@setup.name}_attributes="
+  end
+
+  def define_attributes_writer_method
+    case @setup.attributes_writer_strategy
+    when :rewrite
+      alias_method attributes_writer_method_name, rewrite_attributes_method_name
+    when :upsert
+      alias_method attributes_writer_method_name, upsert_attributes_method_name
+    end
+  end
+
+  require 'nested_record/methods/many'
+  require 'nested_record/methods/one'
+end