clowne 0.1.0 → 1.3.0

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.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "clowne/rspec/helpers"
+require "clowne/rspec/clone_associations"
+require "clowne/rspec/clone_association"

data/lib/clowne/rspec/clone_association.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Clowne
+  module RSpec
+    module Matchers # :nodoc: all
+      class CloneAssociation < ::RSpec::Matchers::BuiltIn::BaseMatcher
+        include Clowne::RSpec::Helpers
+
+        AVAILABLE_PARAMS = %i[
+          traits
+          clone_with
+          params
+          scope
+        ].freeze
+
+        attr_reader :expected_params
+
+        def initialize(name, options)
+          @expected = name
+          extract_options! options
+        end
+
+        # rubocop: disable Metrics/AbcSize
+        def match(expected, _actual)
+          @actual = plan.declarations
+            .find { |key, decl| key == :association && decl.name == expected }
+
+          return false if @actual.nil?
+
+          @actual = actual.last
+
+          AVAILABLE_PARAMS.each do |param|
+            if expected_params[param] != UNDEFINED
+              return false if expected_params[param] != actual.send(param)
+            end
+          end
+
+          true
+        end
+        # rubocop: enable Metrics/AbcSize
+
+        def does_not_match?(*)
+          raise "This matcher doesn't support negation"
+        end
+
+        def failure_message
+          if @actual.nil?
+            "expected to include association #{expected}, but none found"
+          else
+            params_failure_message
+          end
+        end
+
+        private
+
+        def extract_options!(options)
+          @expected_params = {}
+
+          AVAILABLE_PARAMS.each do |param|
+            expected_params[param] = options.fetch(param, UNDEFINED)
+          end
+
+          raise ArgumentError, "Lambda scope is not supported" if
+            expected_params[:scope].is_a?(Proc)
+
+          raise ArgumentError, "Lambda params is not supported" if
+            expected_params[:params].is_a?(Proc)
+        end
+
+        def params_failure_message
+          "expected :#{@expected} association " \
+          "to have options #{formatted_expected_params}, " \
+          "but got #{formatted_actual_params}"
+        end
+
+        def formatted_expected_params
+          ::RSpec::Support::ObjectFormatter.format(
+            expected_params.reject { |_, v| v == UNDEFINED }
+          )
+        end
+
+        def formatted_actual_params
+          actual_params = AVAILABLE_PARAMS.each_with_object({}) do |key, acc|
+            acc[key] = actual.send(key)
+          end
+          ::RSpec::Support::ObjectFormatter.format(actual_params)
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Module.new do
+    def clone_association(expected, **options)
+      Clowne::RSpec::Matchers::CloneAssociation.new(expected, options)
+    end
+  end, type: :cloner)
+end

data/lib/clowne/rspec/clone_associations.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Clowne
+  module RSpec
+    module Matchers # :nodoc: all
+      # `clone_associations` matcher is just an extension of `contain_exactly` matcher
+      class CloneAssociations < ::RSpec::Matchers::BuiltIn::ContainExactly
+        include Clowne::RSpec::Helpers
+
+        def convert_actual_to_an_array
+          @actual = plan.declarations
+            .select { |key, _| key == :association }
+            .map { |_, decl| decl.name }
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Module.new do
+    def clone_associations(*expected)
+      Clowne::RSpec::Matchers::CloneAssociations.new(expected)
+    end
+  end, type: :cloner)
+end

data/lib/clowne/rspec/helpers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Clowne
+  module RSpec
+    module Helpers # :nodoc: all
+      attr_reader :cloner
+
+      def with_traits(*traits)
+        @traits = traits
+        self
+      end
+
+      def matches?(actual)
+        raise ArgumentError, non_cloner_message unless actual <= ::Clowne::Cloner
+
+        @cloner = actual
+        super
+      end
+
+      def plan
+        @plan ||=
+          if @traits.nil?
+            cloner.default_plan
+          else
+            cloner.plan_with_traits(@traits)
+          end
+      end
+
+      def non_cloner_message
+        "expected a cloner to be passed to `expect(...)`, " \
+        "but got #{actual_formatted}"
+      end
+    end
+  end
+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,95 @@
+# 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)
+        @after_clone_blocks = []
+        @after_persist_blocks = []
+        @mapper = mapper
+      end
+
+      def add_after_persist(block)
+        @after_persist_blocks.unshift(block)
+      end
+
+      def add_after_clone(block)
+        @after_clone_blocks.unshift(block)
+      end
+
+      def add_mapping(origin, clone)
+        @mapper.add(origin, clone)
+      end
+
+      def to_record
+        return @_record if defined?(@_record)
+
+        run_after_clone
+        @_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
+        @after_persist_blocks.each(&:call)
+      end
+
+      def run_after_clone
+        @after_clone_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