clowne 0.1.0.pre1 → 1.2.0

data/lib/clowne/adapters/base/association.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class Base
+      class Association
+        # Params:
+        # +reflection+:: Association eflection object
+        # +source+:: Instance of cloned object (ex: User.new(posts: posts))
+        # +declaration+:: = Relation description
+        #                   (ex: Clowne::Declarations::IncludeAssociation.new(:posts))
+        # +adapter+:: Clowne adapter
+        # +params+:: = Instance of Hash
+        def initialize(reflection, source, declaration, adapter, params)
+          @source = source
+          @declaration = declaration
+          @adapter = adapter
+          @params = params
+          @association_name = declaration.name.to_s
+          @reflection = reflection
+        end
+
+        def call(_record)
+          raise NotImplementedError
+        end
+
+        def association
+          @_association ||= source.__send__(association_name)
+        end
+
+        def clone_one(child)
+          cloner = cloner_for(child)
+          cloner ? cloner.call(child, cloner_options) : dup_record(child)
+        end
+
+        def with_scope
+          scope = declaration.scope
+          if scope.is_a?(Symbol)
+            init_scope.__send__(scope)
+          elsif scope.is_a?(Proc)
+            init_scope.instance_exec(params, &scope) || init_scope
+          else
+            init_scope
+          end.to_a
+        end
+
+        private
+
+        def dup_record(record)
+          adapter.class.dup_record(record)
+        end
+
+        def init_scope
+          raise NotImplementedError
+        end
+
+        def cloner_for(child)
+          return declaration.clone_with if declaration.clone_with
+
+          return child.class.cloner_class if child.class.respond_to?(:cloner_class)
+        end
+
+        def cloner_options
+          return @_cloner_options if defined?(@_cloner_options)
+
+          @_cloner_options = declaration.params_proxy.permit(
+            params: params, parent: source
+          ).tap do |options|
+            options[:adapter] = adapter
+            options.merge!(traits: declaration.traits) if declaration.traits
+          end
+        end
+
+        attr_reader :source, :declaration, :adapter, :params, :association_name, :reflection
+      end
+    end
+  end
+end

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
@@ -11,7 +60,7 @@ module Clowne
       end
 
       def insert_after(after, action)
-        validate_uniq!(action)
+        actions.delete(action)
 
         after_index = actions.find_index(after)
 
@@ -21,7 +70,7 @@ module Clowne
       end
 
       def insert_before(before, action)
-        validate_uniq!(action)
+        actions.delete(action)
 
         before_index = actions.find_index(before)
 
@@ -31,12 +80,12 @@ module Clowne
       end
 
       def append(action)
-        validate_uniq!(action)
+        actions.delete(action)
         actions.push action
       end
 
-      def prepend(action)
-        validate_uniq!(action)
+      def unshift(action)
+        actions.delete(action)
         actions.unshift action
       end
 
@@ -50,12 +99,6 @@ module Clowne
       protected
 
       attr_writer :mapping
-
-      private
-
-      def validate_uniq!(action)
-        raise "Plan action already registered: #{action}" if actions.include?(action)
-      end
     end
   end
 end

data/lib/clowne/adapters/sequel.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "clowne/ext/orm_ext"
+
+module Clowne
+  module Adapters
+    # Cloning adapter for Sequel
+    class Sequel < Base
+      class << self
+        def dup_record(record)
+          Clowne::Adapters::Sequel::Copier.call(record)
+        end
+
+        def operation_class
+          Clowne::Adapters::Sequel::Operation
+        end
+      end
+    end
+  end
+end
+
+::Sequel::Model.extend Clowne::Ext::ORMExt
+
+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

@@ -0,0 +1,26 @@
+# 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"
+
+module Clowne
+  module Adapters # :nodoc: all
+    class Sequel
+      module Associations
+        SEQUEL_2_CLONER = {
+          one_to_one: OneToOne,
+          one_to_many: OneToMany,
+          many_to_many: ManyToMany,
+        }.freeze
+
+        # Returns an association cloner class for reflection
+        def self.cloner_for(reflection)
+          SEQUEL_2_CLONER.fetch(reflection[:type], Noop)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "clowne/adapters/base/association"
+
+module Clowne
+  module Adapters # :nodoc: all
+    class Sequel
+      module Associations
+        class Base < Base::Association
+          private
+
+          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
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class Sequel
+      module Associations
+        class ManyToMany < Base
+          def call(record)
+            clones = with_scope
+              .lazy
+              .map(&method(:clone_one))
+              .map(&method(:record_wrapper))
+              .to_a
+
+            record_wrapper(record).remember_assoc(:"#{association_name}_attributes", clones)
+
+            record
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class Sequel
+      module Associations
+        class Noop < Base
+          def call(record)
+            warn("[Clowne] Reflection #{reflection.class.name} is not supported")
+            record
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class Sequel
+      module Associations
+        class OneToOne < Base
+          def call(record)
+            child = association
+            return record unless child
+
+            warn "[Clowne] Has one association does not support scope" unless declaration.scope.nil?
+
+            child_clone = clone_one(child)
+            child_clone[:"#{reflection[:key]}"] = nil
+
+            record_wrapper(record).remember_assoc(
+              :"#{association_name}_attributes",
+              record_wrapper(child_clone)
+            )
+
+            record
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class Sequel
+      class Copier
+        class << self
+          def call(source)
+            nullify_attrs = [:create_timestamp_field, :update_timestamp_field].map do |timestamp|
+              source.class.instance_variable_get("@#{timestamp}")
+            end + [:id]
+
+            dup_hash = source.dup.to_hash.tap do |hash|
+              nullify_attrs.each { |field| hash.delete(field) }
+            end
+
+            source.class.new(dup_hash)
+          end
+        end
+      end
+    end
+  end
+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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters # :nodoc: all
+    class Sequel
+      class RecordWrapper
+        attr_reader :record, :association_store
+
+        def initialize(record)
+          @record = record
+          @association_store = {}
+        end
+
+        def remember_assoc(association, value)
+          @association_store[association] = value
+        end
+
+        def to_model
+          association_store.each_with_object(record) do |(name, value), acc|
+            acc.send("#{name}=", association_to_model(value))
+          end
+        end
+
+        def to_hash
+          init_hash = record.to_hash
+          association_store.each_with_object(init_hash) do |(name, value), acc|
+            acc[name] = association_to_model(value)
+          end
+        end
+
+        private
+
+        def association_to_model(assoc)
+          if assoc.is_a?(Array)
+            assoc.map(&:to_hash)
+          else
+            assoc.to_hash
+          end
+        end
+      end
+    end
+  end
+end