clowne 0.1.0.pre1 → 0.1.0

data/gemfiles/activerecord42.gemfile

@@ -1,6 +1,7 @@
 source 'https://rubygems.org'
 
 gem 'activerecord', '~> 4.2'
+gem 'sequel', '>= 5.0'
 gem 'sqlite3'
 
 gemspec path: '..'

data/gemfiles/jruby.gemfile

@@ -1,6 +1,8 @@
 source 'https://rubygems.org'
 
 gem 'activerecord-jdbcsqlite3-adapter', '~> 50.0'
+gem 'jdbc-sqlite3'
 gem 'activerecord', '~> 5.0.0'
+gem 'sequel', '>= 5.0'
 
 gemspec path: '..'

data/gemfiles/railsmaster.gemfile

@@ -2,6 +2,7 @@ source 'https://rubygems.org'
 
 gem 'arel', github: 'rails/arel'
 gem 'rails', github: 'rails/rails'
+gem 'sequel', github: 'jeremyevans/sequel'
 gem 'sqlite3'
 
 gemspec path: '..'

data/lib/clowne.rb

@@ -11,7 +11,8 @@ module Clowne
   # List of built-in adapters
   ADAPTERS = {
     base:          'Base',
-    active_record: 'ActiveRecord'
+    active_record: 'ActiveRecord',
+    sequel:        'Sequel'
   }.freeze
 
   class << self
@@ -37,3 +38,4 @@ module Clowne
 end
 
 require 'clowne/adapters/active_record' if defined?(::ActiveRecord)
+require 'clowne/adapters/sequel' if defined?(::Sequel)

data/lib/clowne/adapters/active_record.rb

@@ -1,26 +1,17 @@
 # frozen_string_literal: true
 
+require 'clowne/ext/orm_ext'
+
 module Clowne
   module Adapters
     # Cloning adapter for ActiveRecord
     class ActiveRecord < Base
-      # Adds #cloner_class method to ActiveRecord::Base
-      module ActiveRecordExt
-        def cloner_class
-          return @_clowne_cloner if instance_variable_defined?(:@_clowne_cloner)
-
-          cloner = "#{name}Cloner".safe_constantize
-          return @_clowne_cloner = cloner if cloner && cloner <= Clowne::Cloner
-
-          @_clowne_cloner = superclass.cloner_class if superclass.respond_to?(:cloner_class)
-        end
-      end
     end
   end
 end
 
 ActiveSupport.on_load(:active_record) do
-  ::ActiveRecord::Base.extend Clowne::Adapters::ActiveRecord::ActiveRecordExt
+  ::ActiveRecord::Base.extend Clowne::Ext::ORMExt
 end
 
 require 'clowne/adapters/active_record/associations'

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

@@ -7,7 +7,7 @@ module Clowne
 
       class Association
         class << self
-          def call(source, record, declaration, params:)
+          def call(source, record, declaration, params:, **_options)
             reflection = source.class.reflections[declaration.name.to_s]
 
             if reflection.nil?

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

@@ -1,61 +1,21 @@
 # frozen_string_literal: true
 
+require 'clowne/adapters/base/association'
+
 module Clowne
   module Adapters # :nodoc: all
     class ActiveRecord
       module Associations
-        class Base
-          # Params:
-          # +reflection+:: Association eflection object
-          # +source+:: Instance of cloned object (ex: User.new(posts: posts))
-          # +declaration+:: = Relation description
-          #                   (ex: Clowne::Declarations::IncludeAssociation.new(:posts))
-          # +params+:: = Instance of Clowne::Params
-          def initialize(reflection, source, declaration, params)
-            @source = source
-            @scope = declaration.scope
-            @clone_with = declaration.clone_with
-            @params = params
-            @association_name = declaration.name.to_s
-            @reflection = reflection
-            @cloner_options = params
-            @cloner_options.merge!(traits: declaration.traits) if declaration.traits
-          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) : child.dup
-          end
-
-          def with_scope
-            base_scope = association
-            if scope.is_a?(Symbol)
-              base_scope.__send__(scope)
-            elsif scope.is_a?(Proc)
-              base_scope.instance_exec(params, &scope) || base_scope
-            else
-              base_scope
-            end
-          end
-
+        class Base < Base::Association
           private
 
-          def cloner_for(child)
-            return clone_with if clone_with
-
-            return child.class.cloner_class if child.class.respond_to?(:cloner_class)
+          def clone_record(record)
+            record.dup
           end
 
-          attr_reader :source, :scope, :clone_with, :params, :association_name,
-                      :reflection, :cloner_options
+          def init_scope
+            association
+          end
         end
       end
     end

data/lib/clowne/adapters/active_record/associations/has_one.rb

@@ -5,10 +5,16 @@ module Clowne
     class ActiveRecord
       module Associations
         class HasOne < Base
+          # rubocop: disable Metrics/MethodLength
           def call(record)
             child = association
             return record unless child
-            warn '[Clowne] Has one association does not support scopes' unless scope.nil?
+            unless scope.nil?
+              warn(
+                '[Clowne] Has one association does not support scopes ' \
+                "(#{@association_name} for #{@source.class})"
+              )
+            end
 
             child_clone = clone_one(child)
             child_clone[:"#{reflection.foreign_key}"] = nil
@@ -16,6 +22,7 @@ module Clowne
 
             record
           end
+          # rubocop: enable Metrics/MethodLength
         end
       end
     end

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

@@ -6,7 +6,10 @@ module Clowne
       module Associations
         class Noop < Base
           def call(record)
-            warn("[Clowne] Reflection #{reflection.class.name} is not supported")
+            warn(
+              "[Clowne] Reflection #{reflection.class.name} is not supported "\
+              "(#{@association_name} for #{@source.class})"
+            )
             record
           end
         end

data/lib/clowne/adapters/active_record/dsl.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters
+    # Extend ActiveRecord with Clowne DSL and methods
+    module ActiveRecordDSL
+      module InstanceMethods # :nodoc:
+        # Shortcut to call class's cloner call with self
+        def clowne(*args, &block)
+          self.class.cloner_class.call(self, *args, &block)
+        end
+      end
+
+      module ClassMethods # :nodoc:
+        def clowne_config(options = {}, &block)
+          if options.delete(:inherit) != false && superclass.respond_to?(:cloner_class)
+            parent_cloner = superclass.cloner_class
+          end
+
+          parent_cloner ||= Clowne::Cloner
+          cloner = instance_variable_set(:@_clowne_cloner, Class.new(parent_cloner))
+          cloner.adapter :active_record
+          cloner.instance_exec(&block)
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ::ActiveRecord::Base.extend Clowne::Adapters::ActiveRecordDSL::ClassMethods
+  ::ActiveRecord::Base.include Clowne::Adapters::ActiveRecordDSL::InstanceMethods
+end

data/lib/clowne/adapters/base.rb

@@ -19,10 +19,12 @@ module Clowne
           registry.mapping[type] || raise("Uknown resolver #{type} for #{self}")
         end
 
-        def register_resolver(type, resolver, after: nil, before: nil)
+        def register_resolver(type, resolver, after: nil, before: nil, prepend: nil)
           registry.mapping[type] = resolver
 
-          if after
+          if prepend
+            registry.unshift type
+          elsif after
             registry.insert_after after, type
           elsif before
             registry.insert_before before, type
@@ -48,8 +50,8 @@ module Clowne
       # +params+:: Custom params hash
       def clone(source, plan, params: {})
         declarations = plan.declarations
-        declarations.inject(clone_record(source)) do |record, (type, declaration)|
-          resolver_for(type).call(source, record, declaration, params: params)
+        declarations.inject(init_record(dup_source(source))) do |record, (type, declaration)|
+          resolver_for(type).call(source, record, declaration, params: params, adapter: self)
         end
       end
 
@@ -57,13 +59,18 @@ module Clowne
         self.class.resolver_for(type)
       end
 
-      # Return #dup if any
-      def clone_record(source)
+      def dup_source(source)
         source.dup
       end
+
+      def init_record(record)
+        # Override in custom adapters
+        record
+      end
     end
   end
 end
 
+require 'clowne/adapters/base/init_as'
 require 'clowne/adapters/base/nullify'
 require 'clowne/adapters/base/finalize'

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

@@ -0,0 +1,69 @@
+# 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))
+        # +params+:: = Instance of Hash
+        def initialize(reflection, source, declaration, params)
+          @source = source
+          @scope = declaration.scope
+          @clone_with = declaration.clone_with
+          @params = params
+          @association_name = declaration.name.to_s
+          @reflection = reflection
+          @cloner_options = params
+          @cloner_options.merge!(traits: declaration.traits) if declaration.traits
+        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) : clone_record(child)
+        end
+
+        def with_scope
+          base_scope = init_scope
+          if scope.is_a?(Symbol)
+            base_scope.__send__(scope)
+          elsif scope.is_a?(Proc)
+            base_scope.instance_exec(params, &scope) || base_scope
+          else
+            base_scope
+          end.to_a
+        end
+
+        private
+
+        def clone_record(_record)
+          raise NotImplementedError
+        end
+
+        def init_scope
+          raise NotImplementedError
+        end
+
+        def cloner_for(child)
+          return clone_with if clone_with
+
+          return child.class.cloner_class if child.class.respond_to?(:cloner_class)
+        end
+
+        attr_reader :source, :scope, :clone_with, :params, :association_name,
+                    :reflection, :cloner_options
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Clowne
   module Adapters
     class Base
       module Finalize # :nodoc: all
-        def self.call(source, record, declaration, params:)
+        def self.call(source, record, declaration, params:, **_options)
           declaration.block.call(source, record, params)
           record
         end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Adapters
+    class Base
+      module InitAs # :nodoc: all
+        # rubocop: disable Metrics/ParameterLists
+        def self.call(source, _record, declaration, params:, adapter:, **_options)
+          adapter.init_record(declaration.block.call(source, params))
+        end
+        # rubocop: enable Metrics/ParameterLists
+      end
+    end
+  end
+end
+
+Clowne::Adapters::Base.register_resolver(
+  :init_as,
+  Clowne::Adapters::Base::InitAs,
+  prepend: true
+)

data/lib/clowne/adapters/registry.rb

@@ -11,7 +11,7 @@ module Clowne
       end
 
       def insert_after(after, action)
-        validate_uniq!(action)
+        actions.delete(action)
 
         after_index = actions.find_index(after)
 
@@ -21,7 +21,7 @@ module Clowne
       end
 
       def insert_before(before, action)
-        validate_uniq!(action)
+        actions.delete(action)
 
         before_index = actions.find_index(before)
 
@@ -31,12 +31,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 +50,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,25 @@
+# frozen_string_literal: true
+
+require 'clowne/ext/orm_ext'
+
+module Clowne
+  module Adapters
+    # Cloning adapter for Sequel
+    class Sequel < Base
+      def init_record(source)
+        RecordWrapper.new(source)
+      end
+
+      def dup_source(source)
+        Clowne::Adapters::Sequel::Copier.call(source)
+      end
+    end
+  end
+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'