clowne 0.2.0 → 1.0.0

data/lib/clowne/declarations/finalize.rb

@@ -7,6 +7,7 @@ module Clowne
 
       def initialize
         raise ArgumentError, 'Block is required for finalize' unless block_given?
+
         @block = Proc.new
       end
 

data/lib/clowne/declarations/include_association.rb

@@ -25,7 +25,7 @@ module Clowne
       end
 
       def params_proxy
-        @_params_proxy ||= Clowne::Params.proxy(options[:params])
+        @_params_proxy ||= Clowne::Utils::Params.proxy(options[:params])
       end
 
       def params
@@ -34,6 +34,7 @@ module Clowne
 
       def clone_with
         return @clone_with if instance_variable_defined?(:@clone_with)
+
         @clone_with =
           case options[:clone_with]
           when String, Symbol

data/lib/clowne/declarations/init_as.rb

@@ -7,6 +7,7 @@ module Clowne
 
       def initialize
         raise ArgumentError, 'Block is required for init_as' unless block_given?
+
         @block = Proc.new
       end
 

data/lib/clowne/declarations/nullify.rb

@@ -7,6 +7,7 @@ module Clowne
 
       def initialize(*attributes)
         raise ArgumentError, 'At least one attribute required' if attributes.empty?
+
         @attributes = attributes
       end
 

data/lib/clowne/declarations/trait.rb

@@ -13,6 +13,7 @@ module Clowne
 
       def compiled
         return @compiled if instance_variable_defined?(:@compiled)
+
         @compiled = compile
       end
 

data/lib/clowne/dsl.rb

@@ -5,10 +5,19 @@ module Clowne
     def adapter(adapter = nil)
       if adapter.nil?
         return @_adapter if instance_variable_defined?(:@_adapter)
+
         @_adapter = Clowne.default_adapter
       else
         @_adapter = Clowne.resolve_adapter(adapter)
       end
     end
+
+    private
+
+    def current_adapter(user_adapter)
+      return adapter if user_adapter.nil?
+
+      Clowne.resolve_adapter(user_adapter)
+    end
   end
 end

data/lib/clowne/ext/lambda_as_proc.rb

@@ -7,6 +7,7 @@ module Clowne
       refine Proc do
         def to_proc
           return self unless lambda?
+
           this = self
           proc { |*args| this.call(*args.take(this.arity)) }
         end

data/lib/clowne/ext/record_key.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Ext
+    module RecordKey # :nodoc: all
+      def key(record)
+        id = record.respond_to?(:id) && record.id ? record.id : record.__id__
+        [record.class.name, id].join('#')
+      end
+    end
+  end
+end

data/lib/clowne/ext/yield_self_then.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Ext # :nodoc: all
+    # Add yield_self and then if missing
+    module YieldSelfThen
+      module Ext
+        unless nil.respond_to?(:yield_self)
+          def yield_self
+            yield self
+          end
+        end
+
+        alias then yield_self
+      end
+
+      # See https://github.com/jruby/jruby/issues/5220
+      ::Object.include(Ext) if RUBY_PLATFORM =~ /java/i
+
+      refine Object do
+        include Ext
+      end
+    end
+  end
+end

data/lib/clowne/planner.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
-require 'clowne/plan'
+require 'clowne/utils/plan'
 
 module Clowne
   class Planner # :nodoc: all
     class << self
       # Compile plan for cloner with traits
-      def compile(cloner, traits: nil)
+      def compile(adapter, cloner, traits: nil)
         declarations = cloner.declarations.dup
 
         declarations += compile_traits(cloner, traits) unless traits.nil?
 
-        declarations.each_with_object(Plan.new(cloner.adapter.registry)) do |declaration, plan|
+        declarations.each_with_object(
+          Utils::Plan.new(adapter.registry)
+        ) do |declaration, plan|
           declaration.compile(plan)
         end
       end
@@ -42,6 +44,7 @@ module Clowne
         traits.map do |id|
           trait = cloner.traits[id]
           raise ConfigurationError, "Trait not found: #{id}" if trait.nil?
+
           trait.compiled
         end.flatten
       end

data/lib/clowne/resolvers/after_persist.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Clowne
+  class Resolvers
+    module AfterPersist # :nodoc: all
+      def self.call(source, record, declaration, params:, **_options)
+        operation = Clowne::Utils::Operation.current
+        params ||= {}
+        operation.add_after_persist(
+          proc do
+            declaration.block.call(source, record, params.merge(mapper: operation.mapper))
+          end
+        )
+        record
+      end
+    end
+  end
+end

data/lib/clowne/resolvers/finalize.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Clowne
+  class Resolvers
+    module Finalize # :nodoc: all
+      def self.call(source, record, declaration, params:, **_options)
+        declaration.block.call(source, record, params)
+        record
+      end
+    end
+  end
+end

data/lib/clowne/resolvers/init_as.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Clowne
+  class Resolvers
+    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

data/lib/clowne/resolvers/nullify.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Clowne
+  class Resolvers
+    module Nullify # :nodoc: all
+      def self.call(_source, record, declaration, **_options)
+        declaration.attributes.each do |attr|
+          record.__send__("#{attr}=", nil)
+        end
+
+        record
+      end
+    end
+  end
+end

data/lib/clowne/rspec/helpers.rb

@@ -12,6 +12,7 @@ module Clowne
 
       def matches?(actual)
         raise ArgumentError, non_cloner_message unless actual <= ::Clowne::Cloner
+
         @cloner = actual
         super
       end

data/lib/clowne/utils/clone_mapper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'clowne/ext/record_key'
+
+module Clowne
+  module Utils
+    class CloneMapper # :nodoc: all
+      def initialize
+        @store = {}
+      end
+
+      def add(origin, clone)
+        @store[origin] ||= clone
+      end
+
+      def clone_of(origin)
+        @store[origin]
+      end
+
+      def origin_of(clone)
+        origin, _clone = @store.rassoc(clone)
+        origin
+      end
+    end
+  end
+end

data/lib/clowne/utils/operation.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'clowne/utils/clone_mapper'
+
+module Clowne
+  module Utils
+    class Operation # :nodoc: all
+      THREAD_KEY = :"#{name}.clowne_operation"
+      DEFAULT_MAPPER = Utils::CloneMapper
+
+      private_constant :THREAD_KEY
+
+      class << self
+        def current
+          Thread.current[THREAD_KEY]
+        end
+
+        def wrap(mapper: nil)
+          return yield if current
+
+          Thread.current[THREAD_KEY] = new(mapper || DEFAULT_MAPPER.new)
+
+          current.tap do |operation|
+            operation.clone = yield
+            clear!
+          end
+        end
+
+        def clear!
+          Thread.current[THREAD_KEY] = nil
+        end
+      end
+
+      attr_writer :clone
+      attr_reader :mapper
+
+      def initialize(mapper)
+        @blocks = []
+        @mapper = mapper
+      end
+
+      def add_after_persist(block)
+        @blocks.unshift(block)
+      end
+
+      def add_mapping(origin, clone)
+        @mapper.add(origin, clone)
+      end
+
+      def to_record
+        @clone
+      end
+
+      def persist!
+        to_record.save!.tap do
+          run_after_persist
+        end
+      end
+
+      def persist
+        to_record.save.tap do |result|
+          next unless result
+
+          run_after_persist
+        end
+      end
+
+      def save
+        warn '[DEPRECATION] `save` is deprecated.  Please use `persist` instead.'
+        @clone.save
+      end
+
+      def save!
+        warn '[DEPRECATION] `save!` is deprecated.  Please use `persist!` instead.'
+        @clone.save!
+      end
+
+      def run_after_persist
+        @blocks.each(&:call)
+      end
+    end
+  end
+end

data/lib/clowne/utils/options.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Utils # :nodoc: all
+    class Options
+      INTERNAL_KEYS = %i[adapter traits clowne_only_actions mapping only].freeze
+
+      def initialize(options)
+        @options = options
+      end
+
+      def traits
+        @_traits ||= Array(options[:traits])
+      end
+
+      def only
+        options[:clowne_only_actions]
+      end
+
+      def mapper
+        options[:mapper]
+      end
+
+      def adapter
+        options[:adapter]
+      end
+
+      def params
+        options.dup.tap do |o|
+          INTERNAL_KEYS.each { |key| o.delete(key) }
+        end
+      end
+
+      private
+
+      attr_reader :options
+    end
+  end
+end

data/lib/clowne/utils/params.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'clowne/ext/lambda_as_proc'
+
+module Clowne
+  module Utils
+    class Params # :nodoc: all
+      class BaseProxy
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def permit(_params)
+          raise NotImplementedError
+        end
+      end
+
+      class PassProxy < BaseProxy
+        def permit(params:, **)
+          params
+        end
+      end
+
+      class NullProxy < BaseProxy
+        def permit(_params)
+          {}
+        end
+      end
+
+      class BlockProxy < BaseProxy
+        using Clowne::Ext::LambdaAsProc
+
+        def permit(params:, parent:)
+          value.to_proc.call(params, parent)
+        end
+      end
+
+      class KeyProxy < BaseProxy
+        def permit(params:, **)
+          nested_params = params.fetch(value)
+          return nested_params if nested_params.is_a?(Hash)
+
+          raise KeyError, "value by key '#{value}' must be a Hash"
+        end
+      end
+
+      class << self
+        def proxy(value)
+          if value == true
+            PassProxy
+          elsif value.nil? || value == false
+            NullProxy
+          elsif value.is_a?(Proc)
+            BlockProxy
+          else
+            KeyProxy
+          end.new(value)
+        end
+      end
+    end
+  end
+end

data/lib/clowne/utils/plan.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Clowne
+  module Utils
+    class Plan # :nodoc: all
+      class TwoPhaseSet
+        def initialize
+          @added = {}
+          @removed = []
+        end
+
+        def []=(k, v)
+          return if @removed.include?(k)
+
+          @added[k] = v
+        end
+
+        def delete(k)
+          return if @removed.include?(k)
+
+          @removed << k
+          @added.delete(k)
+        end
+
+        def values
+          @added.values
+        end
+      end
+
+      def initialize(registry)
+        @registry = registry
+        @data = {}
+      end
+
+      def add(type, declaration)
+        data[type] = [] unless data.key?(type)
+        data[type] << declaration
+      end
+
+      def add_to(type, id, declaration)
+        data[type] = TwoPhaseSet.new unless data.key?(type)
+        data[type][id] = declaration
+      end
+
+      def set(type, declaration)
+        data[type] = declaration
+      end
+
+      def get(type)
+        data[type]
+      end
+
+      def remove(type)
+        data.delete(type)
+      end
+
+      def remove_from(type, id)
+        return unless data[type]
+
+        data[type].delete(id)
+      end
+
+      def declarations(reload = false)
+        return @declarations if !reload && instance_variable_defined?(:@declarations)
+
+        @declarations =
+          registry.actions.flat_map do |type|
+            value = data[type]
+            next if value.nil?
+
+            value = value.values if value.is_a?(TwoPhaseSet)
+            value = Array(value)
+            value.map { |v| [type, v] }
+          end.compact
+      end
+
+      def dup
+        self.class.new(registry).tap do |duped|
+          data.each do |k, v|
+            duped.set(k, v.dup)
+          end
+        end
+      end
+
+      private
+
+      attr_reader :data, :registry
+    end
+  end
+end