clowne 0.1.0 → 1.3.0

data/lib/clowne/adapters/registry.rb

@@ -3,6 +3,55 @@
 module Clowne
   module Adapters
     class Registry # :nodoc: all
+      module Container
+        def self.included(base)
+          base.extend ClassMethods
+
+          base.class_eval do
+            self.registry = Registry.new
+
+            def registry
+              self.class.registry
+            end
+
+            def resolver_for(type)
+              self.class.resolver_for(type)
+            end
+          end
+        end
+
+        module ClassMethods
+          attr_reader :registry
+
+          def inherited(subclass)
+            # Duplicate registry
+            subclass.registry = registry.dup
+          end
+
+          def resolver_for(type)
+            registry.mapping[type] || raise("Uknown resolver #{type} for #{self}")
+          end
+
+          def register_resolver(type, resolver, after: nil, before: nil, prepend: nil)
+            registry.mapping[type] = resolver
+
+            if prepend
+              registry.unshift type
+            elsif after
+              registry.insert_after after, type
+            elsif before
+              registry.insert_before before, type
+            else
+              registry.append type
+            end
+          end
+
+          protected
+
+          attr_writer :registry
+        end
+      end
+
       attr_reader :actions, :mapping
 
       def initialize

data/lib/clowne/adapters/sequel.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
-require 'clowne/ext/orm_ext'
+require "clowne/ext/orm_ext"
 
 module Clowne
   module Adapters
     # Cloning adapter for Sequel
     class Sequel < Base
-      def init_record(source)
-        RecordWrapper.new(source)
-      end
+      class << self
+        def dup_record(record)
+          Clowne::Adapters::Sequel::Copier.call(record)
+        end
 
-      def dup_source(source)
-        Clowne::Adapters::Sequel::Copier.call(source)
+        def operation_class
+          Clowne::Adapters::Sequel::Operation
+        end
       end
     end
   end
@@ -19,7 +21,9 @@ end
 
 ::Sequel::Model.extend Clowne::Ext::ORMExt
 
-require 'clowne/adapters/sequel/associations'
-require 'clowne/adapters/sequel/association'
-require 'clowne/adapters/sequel/copier'
-require 'clowne/adapters/sequel/record_wrapper'
+require "clowne/adapters/sequel/operation"
+require "clowne/adapters/sequel/associations"
+require "clowne/adapters/sequel/copier"
+require "clowne/adapters/sequel/record_wrapper"
+require "clowne/adapters/sequel/resolvers/association"
+require "clowne/adapters/sequel/resolvers/after_persist"

data/lib/clowne/adapters/sequel/associations.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'clowne/adapters/sequel/associations/base'
-require 'clowne/adapters/sequel/associations/noop'
-require 'clowne/adapters/sequel/associations/one_to_one'
-require 'clowne/adapters/sequel/associations/one_to_many'
-require 'clowne/adapters/sequel/associations/many_to_many'
+require "clowne/adapters/sequel/associations/base"
+require "clowne/adapters/sequel/associations/noop"
+require "clowne/adapters/sequel/associations/one_to_one"
+require "clowne/adapters/sequel/associations/one_to_many"
+require "clowne/adapters/sequel/associations/many_to_many"
 
 module Clowne
   module Adapters # :nodoc: all
@@ -13,7 +13,7 @@ module Clowne
         SEQUEL_2_CLONER = {
           one_to_one: OneToOne,
           one_to_many: OneToMany,
-          many_to_many: ManyToMany
+          many_to_many: ManyToMany,
         }.freeze
 
         # Returns an association cloner class for reflection

data/lib/clowne/adapters/sequel/associations/base.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'clowne/adapters/base/association'
+require "clowne/adapters/base/association"
 
 module Clowne
   module Adapters # :nodoc: all
@@ -9,12 +9,16 @@ module Clowne
         class Base < Base::Association
           private
 
-          def clone_record(record)
-            Clowne::Adapters::Sequel::Copier.call(record)
+          def init_scope
+            @_init_scope ||= source.__send__([association_name, "dataset"].join("_"))
           end
 
-          def init_scope
-            @_init_scope ||= source.__send__([association_name, 'dataset'].join('_'))
+          def record_wrapper(record)
+            operation.record_wrapper(record)
+          end
+
+          def operation
+            @_operation ||= adapter.class.operation_class.current
           end
         end
       end

data/lib/clowne/adapters/sequel/associations/many_to_many.rb

@@ -6,9 +6,13 @@ module Clowne
       module Associations
         class ManyToMany < Base
           def call(record)
-            clones = with_scope.map { |child| clone_one(child) }
+            clones = with_scope
+              .lazy
+              .map(&method(:clone_one))
+              .map(&method(:record_wrapper))
+              .to_a
 
-            record.remember_assoc(:"#{association_name}_attributes", clones)
+            record_wrapper(record).remember_assoc(:"#{association_name}_attributes", clones)
 
             record
           end

data/lib/clowne/adapters/sequel/associations/one_to_many.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "clowne/ext/yield_self_then"
+
+using Clowne::Ext::YieldSelfThen
+
 module Clowne
   module Adapters # :nodoc: all
     class Sequel
@@ -10,9 +14,10 @@ module Clowne
               with_scope.map do |child|
                 clone_one(child).tap do |child_clone|
                   child_clone[:"#{reflection[:key]}"] = nil
-                end
+                end.then(&method(:record_wrapper))
               end
-            record.remember_assoc(:"#{association_name}_attributes", clones)
+
+            record_wrapper(record).remember_assoc(:"#{association_name}_attributes", clones)
 
             record
           end

data/lib/clowne/adapters/sequel/associations/one_to_one.rb

@@ -8,11 +8,16 @@ module Clowne
           def call(record)
             child = association
             return record unless child
-            warn '[Clowne] Has one association does not support scopes' unless scope.nil?
+
+            warn "[Clowne] Has one association does not support scope" unless declaration.scope.nil?
 
             child_clone = clone_one(child)
             child_clone[:"#{reflection[:key]}"] = nil
-            record.remember_assoc(:"#{association_name}_attributes", child_clone)
+
+            record_wrapper(record).remember_assoc(
+              :"#{association_name}_attributes",
+              record_wrapper(child_clone)
+            )
 
             record
           end

data/lib/clowne/adapters/sequel/operation.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "clowne/ext/record_key"
+
+module Clowne
+  module Adapters
+    class Sequel # :nodoc: all
+      class Operation < Clowne::Utils::Operation
+        include Clowne::Ext::RecordKey
+        def initialize(mapper)
+          super
+          @records = {}
+        end
+
+        def record_wrapper(record)
+          @records[key(record)] ||= RecordWrapper.new(record)
+        end
+
+        def hash
+          @records[key(@clone)]
+        end
+
+        def to_record
+          return @_record if defined?(@_record)
+
+          record_wrapper(@clone)
+
+          @_record = @records[key(@clone)].to_model.tap do
+            run_after_clone
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clowne/adapters/sequel/record_wrapper.rb

@@ -15,10 +15,6 @@ module Clowne
           @association_store[association] = value
         end
 
-        def save
-          to_model.save
-        end
-
         def to_model
           association_store.each_with_object(record) do |(name, value), acc|
             acc.send("#{name}=", association_to_model(value))
@@ -32,18 +28,6 @@ module Clowne
           end
         end
 
-        def respond_to_missing?(method_name, include_private = false)
-          record.respond_to?(method_name) || super
-        end
-
-        def method_missing(method_name, *args, &block)
-          if record.respond_to?(method_name)
-            record.public_send(method_name, *args, &block)
-          else
-            super
-          end
-        end
-
         private
 
         def association_to_model(assoc)

data/lib/clowne/adapters/sequel/resolvers/after_persist.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "clowne/adapters/sequel/specifications/after_persist_does_not_support"
+
+module Clowne
+  module Adapters # :nodoc: all
+    class Sequel
+      module Resolvers
+        class AfterPersist
+          def self.call(_source, _record, _declaration, **)
+            raise Specifications::AfterPersistDoesNotSupportException
+          end
+        end
+      end
+    end
+  end
+end
+
+Clowne::Adapters::Sequel.register_resolver(
+  :after_persist,
+  Clowne::Adapters::Sequel::Resolvers::AfterPersist
+)

data/lib/clowne/adapters/sequel/resolvers/association.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class Sequel
+      module Resolvers
+        class Association
+          class << self
+            # rubocop: disable Metrics/ParameterLists
+            def call(source, record, declaration, adapter:, params:, **_options)
+              with_clonable(source, record, declaration) do
+                reflection = source.class.association_reflections[declaration.name.to_sym]
+
+                cloner_class = Associations.cloner_for(reflection)
+
+                cloner_class.new(reflection, source, declaration, adapter, params).call(record)
+
+                record
+              end
+            end
+            # rubocop: enable Metrics/ParameterLists
+
+            private
+
+            def with_clonable(source, record, declaration)
+              if clonable_assoc?(source, declaration)
+                yield(record)
+              else
+                warn <<-WARN
+                  Relation #{declaration.name} of #{source.class.name} does not configure for Sequel::Plugins::NestedAttributes
+                WARN
+              end
+
+              record
+            end
+
+            def clonable_assoc?(source, declaration)
+              source.class.plugins.include?(::Sequel::Plugins::NestedAttributes) &&
+                source.respond_to?(:"#{declaration.name}_attributes=")
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Clowne::Adapters::Sequel.register_resolver(
+  :association,
+  Clowne::Adapters::Sequel::Resolvers::Association
+)

data/lib/clowne/adapters/sequel/specifications/after_persist_does_not_support.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters
+    class Sequel
+      module Specifications # :nodoc: all
+        class AfterPersistDoesNotSupportException < StandardError
+          def message
+            "Sequel adapter does not support after_persist callback"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clowne/cloner.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
-require 'clowne/planner'
-require 'clowne/dsl'
+require "clowne/planner"
+require "clowne/dsl"
+require "clowne/utils/options"
+require "clowne/utils/params"
+require "clowne/utils/operation"
 
 module Clowne # :nodoc: all
   class UnprocessableSourceError < StandardError; end
@@ -24,11 +27,13 @@ module Clowne # :nodoc: all
 
       def declarations
         return @declarations if instance_variable_defined?(:@declarations)
+
         @declarations = []
       end
 
       def traits
         return @traits if instance_variable_defined?(:@traits)
+
         @traits = {}
       end
 
@@ -39,42 +44,46 @@ module Clowne # :nodoc: all
       end
 
       # rubocop: disable Metrics/AbcSize, Metrics/MethodLength
-      # rubocop: disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      def call(object, **options)
-        raise(UnprocessableSourceError, 'Nil is not cloneable object') if object.nil?
-
-        raise(ConfigurationError, 'Adapter is not defined') if adapter.nil?
+      def call(object, **options, &block)
+        raise(UnprocessableSourceError, "Nil is not cloneable object") if object.nil?
 
-        traits = options.delete(:traits)
+        options = Clowne::Utils::Options.new(options)
+        current_adapter = current_adapter(options.adapter)
 
-        traits = Array(traits) unless traits.nil?
+        raise(ConfigurationError, "Adapter is not defined") if current_adapter.nil?
 
         plan =
-          if traits.nil? || traits.empty?
-            default_plan
+          if options.traits.empty?
+            default_plan(current_adapter: current_adapter)
           else
-            plan_with_traits(traits)
+            plan_with_traits(options.traits, current_adapter: current_adapter)
           end
 
-        plan = Clowne::Planner.enhance(plan, Proc.new) if block_given?
+        plan = Clowne::Planner.enhance(plan, block) if block
 
-        adapter.clone(object, plan, params: options)
-      end
+        plan = Clowne::Planner.filter_declarations(plan, options.only)
 
+        call_operation(current_adapter, object, plan, options)
+      end
       # rubocop: enable Metrics/AbcSize, Metrics/MethodLength
-      # rubocop: enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      def default_plan
+      def partial_apply(only, *args, **hargs)
+        call(*args, **hargs, clowne_only_actions: prepare_only(only))
+      end
+
+      def default_plan(current_adapter: adapter)
         return @default_plan if instance_variable_defined?(:@default_plan)
-        @default_plan = Clowne::Planner.compile(self)
+
+        @default_plan = Clowne::Planner.compile(current_adapter, self)
       end
 
-      def plan_with_traits(ids)
+      def plan_with_traits(ids, current_adapter: adapter)
         # Cache plans for combinations of traits
-        traits_id = ids.map(&:to_s).join(':')
+        traits_id = ids.map(&:to_s).join(":")
         return traits_plans[traits_id] if traits_plans.key?(traits_id)
+
         traits_plans[traits_id] = Clowne::Planner.compile(
-          self, traits: ids
+          current_adapter, self, traits: ids
         )
       end
 
@@ -84,10 +93,29 @@ module Clowne # :nodoc: all
 
       private
 
+      def call_operation(adapter, object, plan, options)
+        adapter.class.operation_class.wrap(mapper: options.mapper) do
+          adapter.clone(object, plan, params: options.params)
+        end
+      end
+
       def traits_plans
         return @traits_plans if instance_variable_defined?(:@traits_plans)
+
         @traits_plans = {}
       end
+
+      def prepare_only(val)
+        val = Array.wrap(val)
+        val.each_with_object({}) do |type, acc|
+          # type is a Symbol or Hash
+          if type.is_a?(Hash)
+            acc.merge!(type)
+          elsif type.is_a?(Symbol)
+            acc[type] = nil
+          end
+        end
+      end
     end
   end
 end