rom-repository 1.4.0 → 2.0.0.beta1

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

@@ -1,82 +0,0 @@
-require 'rom/repository/changeset/restricted'
-
-module ROM
-  class Changeset
-    # Changeset specialization for update commands
-    #
-    # Update changesets will only execute their commands when
-    # the data is different from the original tuple. Original tuple
-    # is fetched from changeset's relation using `by_pk` relation view.
-    # This means the underlying adapter must provide this view, or you
-    # you need to implement it yourself in your relations if you want to
-    # use Update changesets.
-    #
-    # @see Changeset::Stateful
-    #
-    # @api public
-    class Update < Stateful
-      include Restricted
-
-      command_type :update
-
-      # Commit update changeset if there's a diff
-      #
-      # This returns original tuple if there's no diff
-      #
-      # @return [Hash]
-      #
-      # @see Changeset#commit
-      #
-      # @api public
-      def commit
-        diff? ? super : original
-      end
-
-      # Return original tuple that this changeset may update
-      #
-      # @return [Hash]
-      #
-      # @api public
-      def original
-        @original ||= Hash(relation.one)
-      end
-
-      # Return true if there's a diff between original and changeset data
-      #
-      # @return [TrueClass, FalseClass]
-      #
-      # @api public
-      def diff?
-        ! diff.empty?
-      end
-
-      # Return if there's no diff between the original and changeset data
-      #
-      # @return [TrueClass, FalseClass]
-      #
-      # @api public
-      def clean?
-        diff.empty?
-      end
-
-      # Calculate the diff between the original and changeset data
-      #
-      # @return [Hash]
-      #
-      # @api public
-      def diff
-        @diff ||=
-          begin
-            data = pipe.for_diff(__data__)
-            data_tuple = data.to_a
-            data_keys = data.keys & original.keys
-
-            new_tuple = data_tuple.to_a.select { |(k, _)| data_keys.include?(k) }
-            ori_tuple = original.to_a.select { |(k, _)| data_keys.include?(k) }
-
-            Hash[new_tuple - (new_tuple & ori_tuple)]
-          end
-      end
-    end
-  end
-end

data/lib/rom/repository/command_compiler.rb

@@ -1,257 +0,0 @@
-require 'dry/core/inflector'
-require 'dry/core/cache'
-
-require 'rom/commands'
-require 'rom/repository/command_proxy'
-
-module ROM
-  class Repository
-    # Builds commands for relations.
-    #
-    # This class is used by repositories to automatically create commands for
-    # their relations. This is used both by `Repository#command` method and
-    # `commands` repository class macros.
-    #
-    # @api private
-    class CommandCompiler
-      extend Dry::Core::Cache
-
-      # Return a specific command type for a given adapter and relation AST
-      #
-      # This class holds its own registry where all generated commands are being
-      # stored
-      #
-      # CommandProxy is returned for complex command graphs as they expect root
-      # relation name to be present in the input, which we don't want to have
-      # in repositories. It might be worth looking into removing this requirement
-      # from rom core Command::Graph API.
-      #
-      # @overload [](container, type, adapter, ast, plugins, options)
-      #
-      #   @param container [ROM::Container] container where relations are stored
-      #   @param type [Symbol] The type of command
-      #   @param adapter [Symbol] The adapter identifier
-      #   @param ast [Array] The AST representation of a relation
-      #   @param plugins [Array<Symbol>] A list of optional command plugins that should be used
-      #
-      #   @return [Command, CommandProxy]
-      #
-      # @api private
-      def self.[](*args)
-        fetch_or_store(args.hash) do
-          container, type, adapter, ast, plugins, options = args
-
-          graph_opts = new(type, adapter, container, registry, plugins, options).visit(ast)
-
-          command = ROM::Commands::Graph.build(registry, graph_opts)
-
-          if command.graph?
-            CommandProxy.new(command)
-          elsif command.lazy?
-            command.unwrap
-          else
-            command
-          end
-        end
-      end
-
-      # @api private
-      def self.registry
-        @__registry__ ||= Hash.new { |h, k| h[k] = {} }
-      end
-
-      # @!attribute [r] id
-      #   @return [Symbol] The command type registry identifier
-      attr_reader :id
-
-      # @!attribute [r] adapter
-      #   @return [Symbol] The adapter identifier ie :sql or :http
-      attr_reader :adapter
-
-      # @!attribute [r] container
-      #   @return [ROM::Container] rom container with relations and gateways
-      attr_reader :container
-
-      # @!attribute [r] registry
-      #   @return [Hash] local registry where commands will be stored during compilation
-      attr_reader :registry
-
-      # @!attribute [r] plugins
-      #   @return [Array<Symbol>] a list of optional plugins that will be enabled for commands
-      attr_reader :plugins
-
-      # @!attribute [r] options
-      #   @return [Hash] Additional command options
-      attr_reader :options
-
-      # @api private
-      def initialize(id, adapter, container, registry, plugins, options)
-        @id = id
-        @adapter = adapter
-        @registry = registry
-        @container = container
-        @plugins = Array(plugins)
-        @options = options
-      end
-
-      # @api private
-      def type
-        @_type ||= Commands.const_get(Dry::Core::Inflector.classify(id))[adapter]
-      rescue NameError
-        nil
-      end
-
-      # @api private
-      def visit(ast, *args)
-        name, node = ast
-        __send__(:"visit_#{name}", node, *args)
-      end
-
-      private
-
-      # @api private
-      def visit_relation(node, parent_relation = nil)
-        name, meta, header = node
-        other = visit(header, name)
-
-        if type
-          register_command(name, type, meta, parent_relation)
-
-          default_mapping =
-            if meta[:combine_type] == :many
-              name
-            else meta[:combine_type] == :one
-              { Dry::Core::Inflector.singularize(name).to_sym => name }
-            end
-
-          mapping =
-            if parent_relation
-              associations = container.relations[parent_relation].associations
-
-              assoc =
-                if associations.key?(meta[:combine_name])
-                  associations[meta[:combine_name]]
-                elsif associations.key?(name)
-                  associations[name]
-                end
-
-              if assoc
-                { assoc.target.key => assoc.target.dataset }
-              else
-                default_mapping
-              end
-            else
-              default_mapping
-            end
-
-          if other.size > 0
-            [mapping, [type, other]]
-          else
-            [mapping, type]
-          end
-        else
-          registry[name][id] = container.commands[name][id]
-          [name, id]
-        end
-      end
-
-      # @api private
-      def visit_header(node, *args)
-        node.map { |n| visit(n, *args) }.compact
-      end
-
-      # @api private
-      def visit_attribute(*args)
-        nil
-      end
-
-      # Build a command object for a specific relation
-      #
-      # The command will be prepared for handling associations if it's a combined
-      # relation. Additional plugins will be enabled if they are configured for
-      # this compiler.
-      #
-      # @param [Symbol] rel_name A relation identifier from the container registry
-      # @param [Symbol] type The command type
-      # @param [Hash] meta Meta information from relation AST
-      # @param [Symbol] parent_relation Optional parent relation identifier
-      #
-      # @return [ROM::Command]
-      #
-      # @api private
-      def register_command(rel_name, type, meta, parent_relation = nil)
-        relation = container.relations[rel_name]
-
-        type.create_class(rel_name, type) do |klass|
-          klass.result(meta.fetch(:combine_type, result))
-
-          if meta[:combine_type]
-            setup_associates(klass, relation, meta, parent_relation)
-          end
-
-          finalize_command_class(klass, relation)
-
-          registry[rel_name][type] = klass.build(relation, input: relation.input_schema)
-        end
-      end
-
-      # Return default result type
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      def result
-        options.fetch(:result, :one)
-      end
-
-      # Sets up `associates` plugin for a given command class and relation
-      #
-      # @param [Class] klass The command class
-      # @param [Relation] relation The relation for the command
-      #
-      # @api private
-      def setup_associates(klass, relation, meta, parent_relation)
-        assoc_name =
-          if relation.associations.key?(parent_relation)
-            parent_relation
-          else
-            singular_name = Dry::Core::Inflector.singularize(parent_relation).to_sym
-            singular_name if relation.associations.key?(singular_name)
-          end
-
-        if assoc_name
-          klass.associates(assoc_name)
-        else
-          keys = meta[:keys].invert.to_a.flatten
-          klass.associates(parent_relation, key: keys)
-        end
-      end
-
-      # Setup a command class for a specific relation
-      #
-      # Every gateway may provide custom command extensions via
-      # `Gateway#extend_command_class`. Furthermore, restrictible commands like
-      # `Update` or `Delete` will be extended with relation view methods, so things
-      # like `delete_user.by_id(1).call` becomes available.
-      #
-      # @param [Class] klass The command class
-      # @param [Relation] relation The command relation
-      #
-      # @return [Class]
-      #
-      # @api private
-      def finalize_command_class(klass, relation)
-        # TODO: this is a copy-paste from rom's FinalizeCommands, we are missing
-        #       an interface!
-        gateway = container.gateways[relation.class.gateway]
-        gateway.extend_command_class(klass, relation.dataset)
-
-        klass.extend_for_relation(relation) if klass.restrictable
-
-        plugins.each do |plugin|
-          klass.use(plugin)
-        end
-      end
-    end
-  end
-end

data/lib/rom/repository/command_proxy.rb

@@ -1,26 +0,0 @@
-require 'dry/core/inflector'
-
-module ROM
-  class Repository
-    # TODO: look into making command graphs work without the root key in the input
-    #       so that we can get rid of this wrapper
-    #
-    # @api private
-    class CommandProxy
-      attr_reader :command, :root
-
-      def initialize(command)
-        @command = command
-        @root = Dry::Core::Inflector.singularize(command.name.relation).to_sym
-      end
-
-      def call(input)
-        command.call(root => input)
-      end
-
-      def >>(other)
-        self.class.new(command >> other)
-      end
-    end
-  end
-end

data/lib/rom/repository/header_builder.rb

@@ -1,65 +0,0 @@
-require 'rom/header'
-require 'rom/repository/struct_builder'
-
-module ROM
-  class Repository
-    # @api private
-    class HeaderBuilder
-      attr_reader :struct_builder
-
-      def initialize(struct_namespace: nil, **options)
-        @struct_builder = StructBuilder.new(struct_namespace)
-      end
-
-      def call(ast)
-        Header.coerce(*visit(ast))
-      end
-      alias_method :[], :call
-
-      private
-
-      def visit(node)
-        name, node = node
-        __send__("visit_#{name}", node)
-      end
-
-      def visit_relation(node)
-        relation_name, meta, header = node
-        name = meta[:combine_name] || relation_name
-
-        model = meta.fetch(:model) do
-          if meta[:combine_name]
-            false
-          else
-            struct_builder[name, header]
-          end
-        end
-
-        options = [visit(header), model: model]
-
-        if meta[:combine_type]
-          type = meta[:combine_type] == :many ? :array : :hash
-          keys = meta.fetch(:keys)
-
-          [name, combine: true, type: type, keys: keys, header: Header.coerce(*options)]
-        elsif meta[:wrap]
-          [name, wrap: true, type: :hash, header: Header.coerce(*options)]
-        else
-          options
-        end
-      end
-
-      def visit_header(node)
-        node.map { |attribute| visit(attribute) }
-      end
-
-      def visit_attribute(attr)
-        if attr.wrapped?
-          [attr.name, from: attr.alias]
-        else
-          [attr.name]
-        end
-      end
-    end
-  end
-end

data/lib/rom/repository/mapper_builder.rb

@@ -1,23 +0,0 @@
-require 'dry/core/cache'
-require 'rom/mapper'
-require 'rom/repository/header_builder'
-
-module ROM
-  class Repository
-    # @api private
-    class MapperBuilder
-      extend Dry::Core::Cache
-
-      attr_reader :header_builder
-
-      def initialize(options = EMPTY_HASH)
-        @header_builder = HeaderBuilder.new(options)
-      end
-
-      def call(ast)
-        fetch_or_store(ast) { Mapper.build(header_builder[ast]) }
-      end
-      alias_method :[], :call
-    end
-  end
-end