clowne 0.2.0 → 1.0.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

@@ -6,12 +6,14 @@ 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/operation'
 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/resolvers/association'
+require 'clowne/adapters/sequel/resolvers/after_persist'

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

@@ -9,13 +9,17 @@ module Clowne
         class Base < Base::Association
           private
 
-          def clone_record(record)
-            Clowne::Adapters::Sequel::Copier.call(record)
-          end
-
           def init_scope
             @_init_scope ||= source.__send__([association_name, 'dataset'].join('_'))
           end
+
+          def record_wrapper(record)
+            operation.record_wrapper(record)
+          end
+
+          def operation
+            @_operation ||= adapter.class.operation_class.current
+          end
         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,32 @@
+# 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 = @records[key(@clone)].to_model
+        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.to_s}_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

@@ -2,7 +2,9 @@
 
 require 'clowne/planner'
 require 'clowne/dsl'
-require 'clowne/params'
+require 'clowne/utils/options'
+require 'clowne/utils/params'
+require 'clowne/utils/operation'
 
 module Clowne # :nodoc: all
   class UnprocessableSourceError < StandardError; end
@@ -25,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
 
@@ -40,50 +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?
-
-        traits = options.delete(:traits)
-
-        only = options.delete(:clowne_only_actions)
+        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.filter_declarations(plan, only)
+        plan = Clowne::Planner.filter_declarations(plan, options.only)
 
-        adapter.clone(object, plan, params: options)
+        call_operation(current_adapter, object, plan, options)
       end
+      # rubocop: enable Metrics/AbcSize, Metrics/MethodLength
 
       def partial_apply(only, *args, **hargs)
         call(*args, **hargs, clowne_only_actions: prepare_only(only))
       end
 
-      # rubocop: enable Metrics/AbcSize, Metrics/MethodLength
-      # rubocop: enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-      def default_plan
+      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(':')
         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
 
@@ -93,8 +93,15 @@ 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
 

data/lib/clowne/declarations.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'clowne/dsl'
-require 'clowne/plan'
+require 'clowne/utils/plan'
 
 module Clowne
   module Declarations # :nodoc:
@@ -30,3 +30,4 @@ require 'clowne/declarations/finalize'
 require 'clowne/declarations/include_association'
 require 'clowne/declarations/nullify'
 require 'clowne/declarations/trait'
+require 'clowne/declarations/after_persist'

data/lib/clowne/declarations/after_persist.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Declarations
+    class AfterPersist < Base # :nodoc: all
+      attr_reader :block
+
+      def initialize
+        raise ArgumentError, 'Block is required for after_persist' unless block_given?
+
+        @block = Proc.new
+      end
+
+      def compile(plan)
+        plan.add(:after_persist, self)
+      end
+    end
+  end
+end
+
+Clowne::Declarations.add :after_persist, Clowne::Declarations::AfterPersist