clowne 0.1.0.pre1 → 1.2.0

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Clowne
-  module Adapters # :nodoc: all
-    class ActiveRecord
-      class UnknownAssociation < StandardError; end
-
-      class Association
-        class << self
-          def call(source, record, declaration, params:)
-            reflection = source.class.reflections[declaration.name.to_s]
-
-            if reflection.nil?
-              raise UnknownAssociation,
-                    "Association #{declaration.name} couldn't be found for #{source.class}"
-            end
-
-            cloner_class = Associations.cloner_for(reflection)
-
-            cloner_class.new(reflection, source, declaration, params).call(record)
-
-            record
-          end
-        end
-      end
-    end
-  end
-end
-
-Clowne::Adapters::ActiveRecord.register_resolver(
-  :association,
-  Clowne::Adapters::ActiveRecord::Association,
-  before: :nullify
-)

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Clowne
-  module Adapters
-    class Base
-      module Finalize # :nodoc: all
-        def self.call(source, record, declaration, params:)
-          declaration.block.call(source, record, params)
-          record
-        end
-      end
-    end
-  end
-end
-
-Clowne::Adapters::Base.register_resolver(
-  :finalize, Clowne::Adapters::Base::Finalize,
-  after: :nullify
-)

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Clowne
-  module Adapters
-    class Base
-      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
-end
-
-Clowne::Adapters::Base.register_resolver(:nullify, Clowne::Adapters::Base::Nullify)

data/lib/clowne/plan.rb

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