rom 5.4.1 → 6.0.0.alpha1

data/lib/rom/memory.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "rom/memory/gateway"
+require "rom/memory/relation"
+require "rom/memory/mapper_compiler"
+
+ROM.register_adapter(:memory, ROM::Memory)

data/lib/rom/model_builder.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "rom/support/inflector"
+
+module ROM
+  # Model builders can be used to build model classes for mappers
+  #
+  # This is used when you define a mapper and setup a model using :name option.
+  #
+  # @example
+  #   # this will define User model for you
+  #   class UserMapper < ROM::Mapper
+  #     model name: 'User'
+  #     attribute :id
+  #     attribute :name
+  #   end
+  #
+  # @private
+  class ModelBuilder
+    attr_reader :name
+
+    attr_reader :const_name, :namespace, :klass
+
+    # Return model builder subclass based on type
+    #
+    # @param [Symbol] type
+    #
+    # @return [Class]
+    #
+    # @api private
+    def self.[](type)
+      case type
+      when :poro then PORO
+      else
+        raise ArgumentError, "#{type.inspect} is not a supported model type"
+      end
+    end
+
+    # Build a model class
+    #
+    # @return [Class]
+    #
+    # @api private
+    def self.call(*args)
+      new(*args).call
+    end
+
+    # @api private
+    def initialize(options = {})
+      @name = options[:name]
+
+      if name
+        parts = name.split("::")
+
+        @const_name = parts.pop
+
+        @namespace =
+          if parts.any?
+            Inflector.constantize(parts.join("::"))
+          else
+            Object
+          end
+      end
+    end
+
+    # Define a model class constant
+    #
+    # @api private
+    def define_const
+      namespace.const_set(const_name, klass)
+    end
+
+    # Build a model class supporting specific attributes
+    #
+    # @return [Class]
+    #
+    # @api private
+    def call(attrs)
+      define_class(attrs)
+      define_const if const_name
+      @klass
+    end
+
+    # PORO model class builder
+    #
+    # @private
+    class PORO < ModelBuilder
+      def define_class(attrs)
+        @klass = Class.new
+
+        @klass.send(:attr_reader, *attrs)
+
+        @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def initialize(params)
+            #{attrs.map { |name| "@#{name} = params[:#{name}]" }.join("\n")}
+          end
+        RUBY
+
+        self
+      end
+    end
+  end
+end

data/lib/rom/open_struct.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "set"
+
+require "dry/core/equalizer"
+require_relative "constants"
+
+module ROM
+  # ROM's open structs are used for relations with empty schemas.
+  # Such relations may exist in cases like using raw SQL strings
+  # where schema was not explicitly defined using `view` DSL.
+  #
+  # @api public
+  class OpenStruct
+    include Dry::Equalizer(:__keys__, :to_h, inspect: false)
+
+    include Enumerable
+
+    IVAR = -> v { :"@#{v}" }
+    WRITER = -> v { :"#{v}=" }
+
+    # @api private
+    attr_reader :__keys__
+
+    # @api private
+    def initialize(attributes = EMPTY_HASH)
+      @__keys__ = Set.new
+      __load__(attributes)
+    end
+
+    # @api public
+    def each
+      __keys__.each { |key| yield(key, __get__(key)) }
+    end
+
+    # @api public
+    def to_h
+      map { |key, value| [key, value] }.to_h
+    end
+    alias_method :to_hash, :to_h
+
+    # @api public
+    def update(other)
+      __load__(other)
+    end
+
+    # @api public
+    def fetch(key, &block)
+      to_h.fetch(key, &block)
+    end
+
+    # @api public
+    def [](key)
+      __send__(key)
+    end
+
+    # @api public
+    def []=(key, value)
+      __set__(key, value)
+    end
+
+    # @api public
+    def key?(key)
+      __keys__.include?(key)
+    end
+
+    # @api public
+    def inspect
+      %(#<#{self.class} #{to_h}>)
+    end
+
+    # @api private
+    def respond_to_missing?(meth, include_private = false)
+      super || key?(meth)
+    end
+
+    private
+
+    # @api public
+    def method_missing(meth, *args, &block)
+      if meth.to_s.end_with?("=")
+        key = meth.to_s.tr("=", "").to_sym
+
+        if methods.include?(key)
+          super
+        else
+          __set__(key, *args)
+        end
+      elsif key?(meth)
+        __get__(meth)
+      else
+        super
+      end
+    end
+
+    # @api private
+    def __load__(attributes)
+      Hash(attributes).each { |key, value| __set__(key, value) }
+    end
+
+    # @api private
+    def __set__(key, value)
+      __keys__ << key
+      instance_variable_set(IVAR[key], value.is_a?(Hash) ? self.class.new(value) : value)
+    end
+
+    # @api private
+    def __get__(key)
+      instance_variable_get(IVAR[key])
+    end
+  end
+end

data/lib/rom/pipeline.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ROM
+  # Data pipeline common interface
+  #
+  # @api private
+  module Pipeline
+    # Common `>>` operator extension
+    #
+    # @api private
+    module Operator
+      # Compose two relation with a left-to-right composition
+      #
+      # @example
+      #   users.by_name('Jane') >> tasks.for_users
+      #
+      # @param [Relation] other The right relation
+      #
+      # @return [Relation::Composite]
+      #
+      # @api public
+      def >>(other)
+        composite_class.new(self, other)
+      end
+
+      private
+
+      # @api private
+      def composite_class
+        raise NotImplementedError
+      end
+    end
+
+    include Operator
+
+    # Send data through specified mappers
+    #
+    # @return [Relation::Composite]
+    #
+    # @api public
+    def map_with(*names)
+      [self, *names.map { |name| mappers[name] }]
+        .reduce { |a, e| composite_class.new(a, e) }
+    end
+
+    # Forwards messages to the left side of a pipeline
+    #
+    # @api private
+    module Proxy
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        left.respond_to?(name) || super
+      end
+
+      private
+
+      # Check if response from method missing should be decorated
+      #
+      # @api private
+      def decorate?(response)
+        response.is_a?(left.class)
+      end
+
+      # @api private
+      def method_missing(name, *args, &block)
+        if left.respond_to?(name)
+          response = left.__send__(name, *args, &block)
+
+          if decorate?(response)
+            self.class.new(response, right)
+          else
+            response
+          end
+        else
+          super
+        end
+      end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    end
+
+    # Base composite class with left-to-right pipeline behavior
+    #
+    # @api private
+    class Composite
+      (Kernel.private_instance_methods - %i[respond_to_missing? block_given?])
+        .each(&method(:undef_method))
+
+      include Dry::Equalizer(:left, :right)
+      include Proxy
+
+      # @api private
+      attr_reader :left
+
+      # @api private
+      attr_reader :right
+
+      # @api private
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      # Compose this composite with another object
+      #
+      # @api public
+      def >>(other)
+        self.class.new(self, other)
+      end
+    end
+  end
+end

data/lib/rom/plugin.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "rom/initializer"
+require "rom/open_struct"
+
+module ROM
+  # Plugin is a simple object used to store plugin configurations
+  #
+  # @private
+  class Plugin
+    include Dry::Equalizer(:type, :name, :mod, :adapter, :config, :dsl)
+    extend Initializer
+
+    # @!attribute [r] type
+    #   @return [Symbol] plugin type
+    # @api private
+    option :type
+
+    # @!attribute [r] name
+    #   @return [Symbol] plugin name
+    # @api private
+    option :name
+
+    # @!attribute [r] mod
+    #   @return [Module] a module representing the plugin
+    # @api private
+    option :mod
+
+    # @!attribute [r] adapter
+    #   @return [Symbol] plugin adapter
+    # @api private
+    option :adapter, optional: true
+
+    # @!attribute [r] config
+    #   @return [Symbol] Plugin optional config
+    option :config, default: -> { ROM::OpenStruct.new }
+
+    # @!attribute [r] dsl
+    #   @return [Module,nil] Optional DSL extensions
+    option :dsl, default: -> { mod.const_defined?(:DSL) ? mod.const_get(:DSL) : nil }
+
+    # These opts are excluded when passing to mod's `apply`
+    INTERNAL_OPTS = %i[enabled applied target].freeze
+
+    # Plugin registry key
+    #
+    # @return [String]
+    #
+    # @api private
+    def key
+      [adapter, type, name].compact.join(".")
+    end
+
+    # Configure plugin
+    #
+    # @api public
+    def configure(**options)
+      plugin = dup
+      plugin.config.update(options)
+      yield(plugin.config) if block_given?
+      plugin
+    end
+
+    # @api private
+    def dup
+      with(config: ROM::OpenStruct.new(config.to_h.clone))
+    end
+
+    # @api private
+    def enable(target)
+      target.extend(dsl) if dsl
+      config.enabled = true
+      config.target = target
+      self
+    end
+
+    # @api private
+    def apply
+      if enabled?
+        apply_to(config.target, **plugin_options)
+        config.applied = true
+        config.freeze
+        freeze
+        self
+      else
+        raise "Cannot apply a plugin because it was not enabled for any target"
+      end
+    end
+
+    # @api private
+    def enabled?
+      config.key?(:enabled) && config.enabled == true
+    end
+
+    # @api private
+    def applied?
+      config.key?(:applied) && config.applied == true
+    end
+
+    # @api private
+    def plugin_options
+      (opts = config.to_h).slice(*(opts.keys - INTERNAL_OPTS))
+    end
+
+    private
+
+    # Apply this plugin to the target
+    #
+    # @param [Class,Object] target
+    #
+    # @api private
+    def apply_to(target, **options)
+      if mod.respond_to?(:apply)
+        mod.apply(target, **config, **options)
+      elsif mod.respond_to?(:new)
+        target.include(mod.new(**options))
+      elsif mod.is_a?(::Module)
+        # Target can be either a component class, like a Relation class, or a DSL object
+        # If it's the former, just include the module, if it's the latter, assume it defines
+        # a component constant and include it there
+        if target.is_a?(Class)
+          target.include(mod)
+        elsif target.respond_to?(:constant)
+          target.constant.include(mod)
+        end
+      end
+      self
+    end
+  end
+end

data/lib/rom/plugins/class_methods.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ROM
+  module Plugins
+    # @api public
+    module ClassMethods
+      # Include a registered plugin in this relation class
+      #
+      # @param [Symbol] plugin
+      # @param [Hash] options
+      # @option options [Symbol] :adapter (:default) first adapter to check for plugin
+      #
+      # @api public
+      def use(name, **options)
+        plugin = plugins[name].configure(**options).enable(self).apply
+        component_config.plugins << plugin
+        self
+      end
+
+      # Return all available plugins for the component type
+      #
+      # @api public
+      def plugins
+        @plugins ||= ROM.plugins[component_config.type].adapter(component_config.adapter)
+      end
+
+      private
+
+      # Return component configuration
+      #
+      # @api private
+      def component_config
+        @component_config ||= config.key?(:component) ? config.component : config
+      end
+    end
+  end
+end

data/lib/rom/plugins/command/schema.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ROM
+  module Plugins
+    module Command
+      # Command plugin which sets input processing function via relation schema
+      #
+      # @api private
+      module Schema
+        def self.included(klass)
+          super
+          klass.extend(ClassInterface)
+        end
+
+        # @api private
+        module ClassInterface
+          # Build a command and set it input to relation's input_schema
+          #
+          # @see Command.build
+          #
+          # @return [Command]
+          #
+          # @api public
+          def build(relation, **options)
+            if relation.schema? && !options.key?(:input)
+              schema = relation.input_schema
+              input = config.input
+
+              composed_input =
+                if input.equal?(ROM::Command.config.input)
+                  schema
+                else
+                  -> tuple { schema[input[tuple]] }
+                end
+
+              super(relation, **options, input: composed_input)
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/plugins/command/timestamps.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "set"
+
+module ROM
+  module Plugins
+    module Command
+      # A plugin for automatically adding timestamp values
+      # when executing a command
+      #
+      # Set up attributes to timestamp when the command is called
+      #
+      # @example
+      #   class CreateTask < ROM::Commands::Create[:sql]
+      #     result :one
+      #     use :timestamps, timestamps: %i(created_at, updated_at), datestamps: %i(:written)
+      #   end
+      #
+      #   create_user = rom.command(:user).create.curry(name: 'Jane')
+      #
+      #   result = create_user.call
+      #   result[:created_at]  #=> Time.now.utc
+      #
+      # @api public
+      class Timestamps < Module
+        attr_reader :timestamps, :datestamps
+
+        def initialize(timestamps: [], datestamps: [])
+          @timestamps = store_attributes(timestamps)
+          @datestamps = store_attributes(datestamps)
+        end
+
+        # @api private
+        def store_attributes(attr)
+          attr.is_a?(Array) ? attr : Array[attr]
+        end
+
+        # @api private
+        def included(klass)
+          initialize_timestamp_attributes(klass)
+          klass.include(InstanceMethods)
+          klass.extend(ClassInterface)
+          super
+        end
+
+        def initialize_timestamp_attributes(klass)
+          klass.setting :timestamp_columns, default: Set.new, reader: true
+          klass.setting :datestamp_columns, default: Set.new, reader: true
+
+          klass.before :set_timestamps
+
+          klass.config.timestamp_columns = klass.timestamp_columns.merge(timestamps) if timestamps.any?
+          klass.config.datestamp_columns = klass.datestamp_columns.merge(datestamps) if datestamps.any?
+        end
+
+        module InstanceMethods
+          # @api private
+          def timestamp_columns
+            self.class.timestamp_columns
+          end
+
+          # @api private
+          def datestamp_columns
+            self.class.datestamp_columns
+          end
+
+          # Set the timestamp attributes on the given tuples
+          #
+          # @param [Array<Hash>, Hash] tuples the input tuple(s)
+          #
+          # @return [Array<Hash>, Hash]
+          #
+          # @api private
+          def set_timestamps(tuples, *)
+            timestamps = build_timestamps
+
+            map_input_tuples(tuples) { |t| timestamps.merge(t) }
+          end
+
+          private
+
+          # @api private
+          def build_timestamps
+            time        = Time.now.utc
+            date        = Date.today
+            timestamps  = {}
+
+            timestamp_columns.each do |column|
+              timestamps[column.to_sym] = time
+            end
+
+            datestamp_columns.each do |column|
+              timestamps[column.to_sym] = date
+            end
+
+            timestamps
+          end
+        end
+
+        module ClassInterface
+          # @api private
+          # Set up attributes to timestamp when the command is called
+          #
+          # @example
+          #   class CreateTask < ROM::Commands::Create[:sql]
+          #     result :one
+          #     use :timestamps
+          #     timestamps :created_at, :updated_at
+          #   end
+          #
+          #   create_user = rom.command(:user).create.curry(name: 'Jane')
+          #
+          #   result = create_user.call
+          #   result[:created_at]  #=> Time.now.utc
+          #
+          # @param [Array<Symbol>] names A list of attribute names
+          #
+          # @api public
+          def timestamps(*names)
+            config.timestamp_columns = timestamp_columns.merge(names)
+          end
+          alias_method :timestamp, :timestamps
+
+          # Set up attributes to datestamp when the command is called
+          #
+          # @example
+          #   class CreateTask < ROM::Commands::Create[:sql]
+          #     result :one
+          #     use :timestamps
+          #     datestamps :created_on, :updated_on
+          #   end
+          #
+          #   create_user = rom.command(:user).create.curry(name: 'Jane')
+          #
+          #   result = create_user.call
+          #   result[:created_at]  #=> Date.today
+          #
+          # @param [Array<Symbol>] names A list of attribute names
+          #
+          # @api public
+          def datestamps(*names)
+            config.datestamp_columns = datestamp_columns.merge(names)
+          end
+          alias_method :datestamp, :datestamps
+        end
+      end
+    end
+  end
+end