rom-repository 1.4.0 → 2.0.0.beta1

data/lib/rom/repository/changeset/associated.rb

@@ -1,100 +0,0 @@
-require 'rom/initializer'
-
-module ROM
-  class Changeset
-    # Associated changesets automatically set up FKs
-    #
-    # @api public
-    class Associated
-      extend Initializer
-
-      # @!attribute [r] left
-      #   @return [Changeset::Create] Child changeset
-      param :left
-
-      # @!attribute [r] associations
-      #   @return [Array] List of association identifiers from relation schema
-      option :associations
-
-      # Infer association name from an object with a schema
-      #
-      # This expects other to be an object with a schema that includes a primary key
-      # attribute with :source meta information. This makes it work with both structs
-      # and relations
-      #
-      # @see Stateful#associate
-      #
-      # @api private
-      def self.infer_assoc_name(other)
-        schema = other.class.schema
-        attrs = schema.is_a?(Hash) ? schema.values : schema
-        pk = attrs.detect { |attr| attr.meta[:primary_key] }
-
-        if pk
-          pk.meta[:source].relation
-        else
-          raise ArgumentError, "can't infer association name for #{other}"
-        end
-      end
-
-      # Commit changeset's composite command
-      #
-      # @example
-      #   task_changeset = task_repo.
-      #     changeset(title: 'Task One').
-      #     associate(user, :user).
-      #     commit
-      #   # {:id => 1, :user_id => 1, title: 'Task One'}
-      #
-      # @return [Array<Hash>, Hash]
-      #
-      # @api public
-      def commit
-        command.call
-      end
-
-      # @api public
-      def associate(other, name = Associated.infer_assoc_name(other))
-        self.class.new(left, associations: associations.merge(name => other))
-      end
-
-      # Create a composed command
-      #
-      # @example using existing parent data
-      #   user_changeset = user_repo.changeset(name: 'Jane')
-      #   task_changeset = task_repo.changeset(title: 'Task One')
-      #
-      #   user = user_repo.create(user_changeset)
-      #   task = task_repo.create(task_changeset.associate(user, :user))
-      #
-      # @example saving both parent and child in one go
-      #   user_changeset = user_repo.changeset(name: 'Jane')
-      #   task_changeset = task_repo.changeset(title: 'Task One')
-      #
-      #   task = task_repo.create(task_changeset.associate(user, :user))
-      #
-      # This works *only* with parent => child(ren) changeset hierarchy
-      #
-      # @return [ROM::Command::Composite]
-      #
-      # @api public
-      def command
-        associations.reduce(left.command.curry(left)) do |a, (assoc, other)|
-          case other
-          when Changeset
-            a >> other.command.with_association(assoc).curry(other)
-          when Associated
-            a >> other.command.with_association(assoc)
-          else
-            a.with_association(assoc, parent: other)
-          end
-        end
-      end
-
-      # @api private
-      def relation
-        left.relation
-      end
-    end
-  end
-end

data/lib/rom/repository/changeset/create.rb

@@ -1,16 +0,0 @@
-module ROM
-  class Changeset
-    # Changeset specialization for create commands
-    #
-    # @see Changeset::Stateful
-    #
-    # @api public
-    class Create < Stateful
-      command_type :create
-
-      def command
-        super.new(relation)
-      end
-    end
-  end
-end

data/lib/rom/repository/changeset/delete.rb

@@ -1,17 +0,0 @@
-require 'rom/repository/changeset/restricted'
-
-module ROM
-  class Changeset
-    # Changeset specialization for delete commands
-    #
-    # Delete changesets will execute delete command for its relation, which
-    # means proper restricted relations should be used with this changeset.
-    #
-    # @api public
-    class Delete < Changeset
-      include Restricted
-
-      command_type :delete
-    end
-  end
-end

data/lib/rom/repository/changeset/pipe.rb

@@ -1,97 +0,0 @@
-require 'transproc/registry'
-require 'transproc/transformer'
-
-module ROM
-  class Changeset
-    # Transproc Registry useful for pipe
-    #
-    # @api private
-    module PipeRegistry
-      extend Transproc::Registry
-
-      import Transproc::HashTransformations
-
-      def self.add_timestamps(data)
-        now = Time.now
-        data.merge(created_at: now, updated_at: now)
-      end
-
-      def self.touch(data)
-        data.merge(updated_at: Time.now)
-      end
-    end
-
-    # Composable data transformation pipe used by default in changesets
-    #
-    # @api private
-    class Pipe < Transproc::Transformer[PipeRegistry]
-      extend Initializer
-
-      param :processor, default: -> { self.class.transproc }
-      option :use_for_diff, optional: true, default: -> { true }
-      option :diff_processor, optional: true, default: -> { use_for_diff ? processor : nil }
-
-      def self.[](name)
-        container[name]
-      end
-
-      def [](name)
-        self.class[name]
-      end
-
-      def bind(context)
-        return self unless processor.is_a?(Proc) || diff_processor.is_a?(Proc)
-
-        new(bind_processor(processor, context), diff_processor: bind_processor(diff_processor, context))
-      end
-
-      def compose(other, use_for_diff: other.is_a?(Pipe) ? other.use_for_diff : false)
-        new_proc = processor ? processor >> other : other
-
-        if use_for_diff
-          diff_proc = diff_processor ? diff_processor >> other : other
-          new(new_proc, diff_processor: diff_proc)
-        else
-          new(new_proc)
-        end
-      end
-      alias_method :>>, :compose
-
-      def call(data)
-        if processor
-          processor.call(data)
-        else
-          data
-        end
-      end
-
-      def for_diff(data)
-        if diff_processor
-          diff_processor.call(data)
-        else
-          data
-        end
-      end
-
-      def with(opts)
-        if opts.empty?
-          self
-        else
-          Pipe.new(processor, options.merge(opts))
-        end
-      end
-
-      def new(processor, opts = EMPTY_HASH)
-        Pipe.new(processor, options.merge(opts))
-      end
-
-      def bind_processor(processor, context)
-        if processor.is_a?(Proc)
-          self[-> *args { context.instance_exec(*args, &processor) }]
-        else
-          processor
-        end
-      end
-    end
-  end
-end

data/lib/rom/repository/changeset/restricted.rb

@@ -1,28 +0,0 @@
-module ROM
-  class Changeset
-    module Restricted
-      # Return a command restricted by the changeset's relation
-      #
-      # @see Changeset#command
-      #
-      # @api private
-      def command
-        super.new(relation)
-      end
-
-      # Restrict changeset's relation by its PK
-      #
-      # @example
-      #   repo.changeset(UpdateUser).by_pk(1).data(name: "Jane")
-      #
-      # @param [Object] pk
-      #
-      # @return [Changeset]
-      #
-      # @api public
-      def by_pk(pk, data = EMPTY_HASH)
-        new(relation.by_pk(pk), __data__: data)
-      end
-    end
-  end
-end

data/lib/rom/repository/changeset/stateful.rb

@@ -1,282 +0,0 @@
-require 'rom/repository/changeset/pipe'
-
-module ROM
-  class Changeset
-    # Stateful changesets carry data and can transform it into
-    # a different structure compatible with a persistence backend
-    #
-    # @abstract
-    class Stateful < Changeset
-      # Default no-op pipe
-      EMPTY_PIPE = Pipe.new.freeze
-
-      # @!attribute [r] __data__
-      #   @return [Hash] The relation data
-      #   @api private
-      option :__data__, optional: true
-
-      # @!attribute [r] pipe
-      #   @return [Changeset::Pipe] data transformation pipe
-      #   @api private
-      option :pipe, reader: false, optional: true
-
-      # Define a changeset mapping
-      #
-      # Subsequent mapping definitions will be composed together
-      # and applied in the order they way defined
-      #
-      # @example Transformation DSL
-      #   class NewUser < ROM::Changeset::Create
-      #     map do
-      #       unwrap :address, prefix: true
-      #     end
-      #   end
-      #
-      # @example Using custom block
-      #   class NewUser < ROM::Changeset::Create
-      #     map do |tuple|
-      #       tuple.merge(created_at: Time.now)
-      #     end
-      #   end
-      #
-      # @example Multiple mappings (executed in the order of definition)
-      #   class NewUser < ROM::Changeset::Create
-      #     map do
-      #       unwrap :address, prefix: true
-      #     end
-      #
-      #     map do |tuple|
-      #       tuple.merge(created_at: Time.now)
-      #     end
-      #   end
-      #
-      # @return [Array<Pipe>, Transproc::Function>]
-      #
-      # @see https://github.com/solnic/transproc Transproc
-      #
-      # @api public
-      def self.map(options = EMPTY_HASH, &block)
-        if block.parameters.empty?
-          pipes << Class.new(Pipe, &block).new(options)
-        else
-          pipes << Pipe.new(block, options)
-        end
-      end
-
-      # Define a changeset mapping excluded from diffs
-      #
-      # @see Changeset::Stateful.map
-      # @see Changeset::Stateful#extend
-      #
-      # @return [Array<Pipe>, Transproc::Function>]
-      #
-      # @api public
-      def self.extend(*, &block)
-        if block
-          map(use_for_diff: false, &block)
-        else
-          super
-        end
-      end
-
-      # Build default pipe object
-      #
-      # This can be overridden in a custom changeset subclass
-      #
-      # @return [Pipe]
-      def self.default_pipe(context)
-        pipes.size > 0 ? pipes.map { |p| p.bind(context) }.reduce(:>>) : EMPTY_PIPE
-      end
-
-      # @api private
-      def self.inherited(klass)
-        return if klass == ROM::Changeset
-        super
-        klass.instance_variable_set(:@__pipes__, pipes ? pipes.dup : EMPTY_ARRAY)
-      end
-
-      # @api private
-      def self.pipes
-        @__pipes__
-      end
-
-      # Pipe changeset's data using custom steps define on the pipe
-      #
-      # @overload map(*steps)
-      #   Apply mapping using built-in transformations
-      #
-      #   @example
-      #     changeset.map(:add_timestamps)
-      #
-      #   @param [Array<Symbol>] steps A list of mapping steps
-      #
-      # @overload map(&block)
-      #   Apply mapping using a custom block
-      #
-      #   @example
-      #     changeset.map { |tuple| tuple.merge(created_at: Time.now) }
-      #
-      # @overload map(*steps, &block)
-      #   Apply mapping using built-in transformations and a custom block
-      #
-      #   @example
-      #     changeset.map(:add_timestamps) { |tuple| tuple.merge(status: 'published') }
-      #
-      #   @param [Array<Symbol>] steps A list of mapping steps
-      #
-      # @return [Changeset]
-      #
-      # @api public
-      def map(*steps, &block)
-        extend(*steps, use_for_diff: true, &block)
-      end
-
-      # Pipe changeset's data using custom steps define on the pipe.
-      # You should use #map instead except updating timestamp fields.
-      # Calling changeset.extend builds a pipe that excludes certain
-      # steps for generating the diff. Currently the only place where
-      # it is used is update changesets with the `:touch` step, i.e.
-      # `changeset.extend(:touch).diff` will exclude `:updated_at`
-      # from the diff.
-      #
-      # @see Changeset::Stateful#map
-      #
-      # @return [Changeset]
-      #
-      # @api public
-      def extend(*steps, use_for_diff: false, **opts, &block)
-        options = { use_for_diff: use_for_diff, **opts }
-
-        if block
-          if steps.size > 0
-            extend(*steps, options).extend(options, &block)
-          else
-            with(pipe: pipe.compose(Pipe.new(block).bind(self), options))
-          end
-        else
-          with(pipe: steps.reduce(pipe.with(options)) { |a, e| a.compose(pipe[e], options) })
-        end
-      end
-
-      # Return changeset with data
-      #
-      # @param [Hash] data
-      #
-      # @return [Changeset]
-      #
-      # @api public
-      def data(data)
-        with(__data__: data)
-      end
-
-      # Coerce changeset to a hash
-      #
-      # This will send the data through the pipe
-      #
-      # @return [Hash]
-      #
-      # @api public
-      def to_h
-        pipe.call(__data__)
-      end
-      alias_method :to_hash, :to_h
-
-      # Coerce changeset to an array
-      #
-      # This will send the data through the pipe
-      #
-      # @return [Array]
-      #
-      # @api public
-      def to_a
-        result == :one ? [to_h] : __data__.map { |element| pipe.call(element) }
-      end
-      alias_method :to_ary, :to_a
-
-      # Commit stateful changeset
-      #
-      # @see Changeset#commit
-      #
-      # @api public
-      def commit
-        command.call(self)
-      end
-
-      # Associate a changeset with another changeset or hash-like object
-      #
-      # @example with another changeset
-      #   new_user = user_repo.changeset(name: 'Jane')
-      #   new_task = user_repo.changeset(:tasks, title: 'A task')
-      #
-      #   new_task.associate(new_user, :users)
-      #
-      # @example with a hash-like object
-      #   user = user_repo.users.by_pk(1).one
-      #   new_task = user_repo.changeset(:tasks, title: 'A task')
-      #
-      #   new_task.associate(user, :users)
-      #
-      # @param [#to_hash, Changeset] other Other changeset or hash-like object
-      # @param [Symbol] assoc The association identifier from schema
-      #
-      # @api public
-      def associate(other, name = Associated.infer_assoc_name(other))
-        Associated.new(self, associations: { name => other })
-      end
-
-      # Return command result type
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      def result
-        __data__.is_a?(Array) ? :many : :one
-      end
-
-      # @api public
-      def command
-        command_compiler.(command_type, relation_identifier, DEFAULT_COMMAND_OPTS.merge(result: result))
-      end
-
-      # Return string representation of the changeset
-      #
-      # @return [String]
-      #
-      # @api public
-      def inspect
-        %(#<#{self.class} relation=#{relation.name.inspect} data=#{__data__}>)
-      end
-
-      # Data transformation pipe
-      #
-      # @return [Changeset::Pipe]
-      #
-      # @api private
-      def pipe
-        @pipe ||= self.class.default_pipe(self)
-      end
-
-      private
-
-      # @api private
-      def respond_to_missing?(meth, include_private = false)
-        super || __data__.respond_to?(meth)
-      end
-
-      # @api private
-      def method_missing(meth, *args, &block)
-        if __data__.respond_to?(meth)
-          response = __data__.__send__(meth, *args, &block)
-
-          if response.is_a?(__data__.class)
-            with(__data__: response)
-          else
-            response
-          end
-        else
-          super
-        end
-      end
-    end
-  end
-end