rom 5.4.1 → 6.0.0.alpha1

data/lib/rom/global.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "rom/components"
+
+module ROM
+  # Globally accessible public interface exposed via ROM module
+  #
+  # @api public
+  module Global
+    # Set base global registries in ROM constant
+    #
+    # @api private
+    def self.extended(rom)
+      super
+
+      rom.instance_variable_set("@adapters", {})
+    end
+
+    # An internal adapter identifier => adapter module map used by setup
+    #
+    # @return [Hash<Symbol=>Module>]
+    #
+    # @api private
+    attr_reader :adapters
+
+    # An internal component handler registry
+    #
+    # @return [Plugins]
+    #
+    # @api private
+    attr_reader :handlers
+
+    # @api public
+    def setup(*args, &block)
+      case args.first
+      when Setup
+        args.first
+      else
+        Setup.new(*args, &block)
+      end.finalize
+    end
+
+    # Register adapter namespace under a specified identifier
+    #
+    # @param [Symbol] identifier
+    # @param [Class,Module] adapter
+    #
+    # @return [self]
+    #
+    # @api private
+    def register_adapter(identifier, adapter)
+      adapters[identifier] = adapter
+      self
+    end
+  end
+end

data/lib/rom/header/attribute.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+
+module ROM
+  class Header
+    # An attribute provides information about a specific attribute in a tuple
+    #
+    # This may include information about how an attribute should be renamed,
+    # or how its value should coerced.
+    #
+    # More complex attributes describe how an attribute should be transformed.
+    #
+    # @private
+    class Attribute
+      include Dry::Equalizer(:name, :key, :type)
+
+      # @return [Symbol] name of an attribute
+      #
+      # @api private
+      attr_reader :name
+
+      # @return [Symbol] key of an attribute that corresponds to tuple attribute
+      #
+      # @api private
+      attr_reader :key
+
+      # @return [Symbol] type identifier (defaults to :object)
+      #
+      # @api private
+      attr_reader :type
+
+      # @return [Hash] additional meta information
+      #
+      # @api private
+      attr_reader :meta
+
+      # Return attribute class for a given meta hash
+      #
+      # @param [Hash] meta hash with type information and optional transformation info
+      #
+      # @return [Class]
+      #
+      # @api private
+      def self.[](meta)
+        key = (meta.keys & TYPE_MAP.keys).first
+        TYPE_MAP.fetch(key || meta[:type], self)
+      end
+
+      # Coerce an array with attribute meta-data into an attribute object
+      #
+      # @param [Array<Symbol,Hash>] input attribute name/options pair
+      #
+      # @return [Attribute]
+      #
+      # @api private
+      def self.coerce(input)
+        name = input[0]
+        meta = (input[1] || {}).dup
+
+        meta[:type] ||= :object
+
+        meta[:header] = Header.coerce(meta[:header], model: meta[:model]) if meta.key?(:header)
+
+        self[meta].new(name, meta)
+      end
+
+      # @api private
+      def initialize(name, meta)
+        @name = name
+        @meta = meta
+        @key = meta.fetch(:from) { name }
+        @type = meta.fetch(:type)
+      end
+
+      # Return if an attribute has a specific type identifier
+      #
+      # @api private
+      def typed?
+        type != :object
+      end
+
+      # Return if an attribute should be aliased
+      #
+      # @api private
+      def aliased?
+        key != name
+      end
+
+      # Return :key-to-:name mapping hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def mapping
+        {key => name}
+      end
+
+      def union?
+        key.is_a? ::Array
+      end
+    end
+
+    # Embedded attribute is a special attribute type that has a header
+    #
+    # This is the base of complex attributes like Hash or Group
+    #
+    # @private
+    class Embedded < Attribute
+      include Dry::Equalizer(:name, :key, :type, :header)
+
+      # return [Header] header of an attribute
+      #
+      # @api private
+      attr_reader :header
+
+      # @api private
+      def initialize(*)
+        super
+        @header = meta.fetch(:header)
+      end
+
+      # Return tuple keys from the header
+      #
+      # @return [Array<Symbol>]
+      #
+      # @api private
+      def tuple_keys
+        header.tuple_keys
+      end
+
+      def pop_keys
+        header.pop_keys
+      end
+    end
+
+    # Array is an embedded attribute type
+    Array = Class.new(Embedded)
+
+    # Hash is an embedded attribute type
+    Hash = Class.new(Embedded)
+
+    # Combined is an embedded attribute type describing combination of multiple
+    # relations
+    Combined = Class.new(Embedded)
+
+    # Wrap is a special type of Hash attribute that requires wrapping
+    # transformation
+    Wrap = Class.new(Hash)
+
+    # Unwrap is a special type of Hash attribute that requires unwrapping
+    # transformation
+    Unwrap = Class.new(Hash)
+
+    # Group is a special type of Array attribute that requires grouping
+    # transformation
+    Group = Class.new(Array)
+
+    # Ungroup is a special type of Array attribute that requires ungrouping
+    # transformation
+    Ungroup = Class.new(Array)
+
+    # Fold is a special type of Array attribute that requires folding
+    # transformation
+    Fold = Class.new(Array)
+
+    # Unfold is a special type of Array attribute that requires unfolding
+    # transformation
+    Unfold = Class.new(Array)
+
+    # Exclude is a special type of Attribute to be removed
+    Exclude = Class.new(Attribute)
+
+    # TYPE_MAP is a (hash) map of ROM::Header identifiers to ROM::Header types
+    #
+    # @private
+    TYPE_MAP = {
+      combine: Combined,
+      wrap: Wrap,
+      unwrap: Unwrap,
+      group: Group,
+      ungroup: Ungroup,
+      fold: Fold,
+      unfold: Unfold,
+      hash: Hash,
+      array: Array,
+      exclude: Exclude
+    }.freeze
+  end
+end

data/lib/rom/header.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "rom/header/attribute"
+
+module ROM
+  # Header provides information about data mapping of a specific relation
+  #
+  # Processors use headers to build objects that process raw relations that go
+  # through mappers.
+  #
+  # @private
+  class Header
+    include Enumerable
+    include Dry::Equalizer(:attributes, :model)
+
+    # @return [Class] optional model associated with a header
+    #
+    # @api private
+    attr_reader :model
+
+    # @api private
+    attr_reader :reject_keys
+
+    # @api private
+    attr_reader :copy_keys
+
+    # @api private
+    attr_reader :attributes
+
+    # @return [Hash] attribute key/name mapping for all primitive attributes
+    #
+    # @api private
+    attr_reader :mapping
+
+    # @return [Array] all attribute keys that are in a tuple
+    #
+    # @api private
+    attr_reader :tuple_keys
+
+    # @return [Array] all attribute names that are popping from a tuple
+    #
+    # @api private
+    attr_reader :pop_keys
+
+    # Coerce array with attribute definitions into a header object
+    #
+    # @param [Array<Array>] input attribute name/option pairs
+    # @param [Hash] options
+    #
+    # @return [Header]
+    #
+    # @api private
+    def self.coerce(input, options = {})
+      if input.instance_of?(self)
+        input
+      else
+        attributes = input.each_with_object({}) { |pair, h|
+          h[pair.first] = Attribute.coerce(pair)
+        }
+
+        new(attributes, options)
+      end
+    end
+
+    # @api private
+    def initialize(attributes, options = {})
+      @options = options
+      @model = options[:model]
+      @copy_keys = options.fetch(:copy_keys, false)
+      @reject_keys = options.fetch(:reject_keys, false)
+
+      @attributes = attributes
+      initialize_mapping
+      initialize_tuple_keys
+      initialize_pop_keys
+    end
+
+    # Iterate over attributes
+    #
+    # @yield [Attribute]
+    #
+    # @api private
+    def each(&block)
+      attributes.each_value(&block)
+    end
+
+    # Return if there are any aliased attributes
+    #
+    # @api private
+    def aliased?
+      any?(&:aliased?)
+    end
+
+    # Return attribute keys
+    #
+    # An attribute key corresponds to tuple attribute names
+    #
+    # @api private
+    def keys
+      attributes.keys
+    end
+
+    # Return attribute identified by its name
+    #
+    # @return [Attribute]
+    #
+    # @api private
+    def [](name)
+      attributes.fetch(name)
+    end
+
+    # Return all Combined attributes
+    #
+    # @return [Array<Combined>]
+    #
+    # @api private
+    def combined
+      by_type(Combined)
+    end
+
+    # Returns all attributes that require preprocessing
+    #
+    # @return [Array<Group,Fold>]
+    #
+    # @api private
+    def preprocessed
+      by_type(Group, Fold)
+    end
+
+    # Returns all attributes that require postprocessing
+    #
+    # @return [Array<Ungroup,Unfold>]
+    #
+    # @api private
+    def postprocessed
+      by_type(Ungroup, Unfold)
+    end
+
+    # Return all Wrap attributes
+    #
+    # @return [Array<Wrap>]
+    #
+    # @api private
+    def wraps
+      by_type(Wrap)
+    end
+
+    # Return all non-primitive attributes that don't require mapping
+    #
+    # @return [Array<Group,Fold,Ungroup,Unfold,Wrap,Unwrap>]
+    #
+    # @api private
+    def non_primitives
+      preprocessed + wraps
+    end
+
+    # Return all primitive attributes that require mapping
+    #
+    # @return [Array<Attribute>]
+    #
+    # @api private
+    def primitives
+      to_a - non_primitives
+    end
+
+    private
+
+    # Find all attribute matching specific attribute class (not kind)
+    #
+    # @return [Array<Attribute>]
+    #
+    # @api private
+    def by_type(*types)
+      select { |attribute| types.include?(attribute.class) }
+    end
+
+    # Set mapping hash from primitive attributes
+    #
+    # @api private
+    def initialize_mapping
+      @mapping = primitives.map(&:mapping).reduce(:merge) || {}
+    end
+
+    # Set all tuple keys from all attributes going deep into Wrap and Group too
+    #
+    # @api private
+    def initialize_tuple_keys
+      @tuple_keys = mapping.keys.flatten + non_primitives.flat_map(&:tuple_keys)
+    end
+
+    # Set all tuple keys from all attributes popping from Unwrap and Ungroup
+    #
+    # @api private
+    def initialize_pop_keys
+      @pop_keys = mapping.values + non_primitives.flat_map(&:tuple_keys)
+    end
+  end
+end

data/lib/rom/inferrer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "dry/core/memoizable"
+require "dry/effects"
+
+require "rom/constants"
+require "rom/cache"
+require "rom/command_compiler"
+require "rom/mapper_compiler"
+
+module ROM
+  # @api private
+  class Inferrer
+    include Dry::Core::Memoizable
+    include Dry::Effects::Reader(:registry)
+
+    attr_reader :cache, :config
+
+    # @api private
+    def initialize
+      @cache = Cache.new
+    end
+
+    # @api private
+    def call(ast, type, **opts)
+      compiler(type, **opts).then do |compiler|
+        case type
+        when :mappers
+          compiler.(ast)
+        when :commands
+          compiler.(*ast) # TODO: unify this
+        end
+      end
+    end
+
+    # @api private
+    memoize def compiler(type, adapter:)
+      case type
+      when :mappers
+        # TODO: move this to config
+        adapter_ns = ROM.adapters[adapter] || ROM
+
+        klass = if adapter_ns.const_defined?(:MapperCompiler)
+                  adapter_ns::MapperCompiler
+                else
+                  MapperCompiler
+                end
+
+        klass.new(cache: cache)
+      when :commands
+        CommandCompiler.new(cache: cache.namespaced(:commands), registry: registry)
+      end
+    end
+  end
+end

data/lib/rom/initializer.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "dry-initializer"
+
+module ROM
+  # @api private
+  module Initializer
+    # @api private
+    module DefineWithHook
+      # @api private
+      def param(*)
+        super.tap { __define_with__ }
+      end
+      ruby2_keywords(:param) if respond_to?(:ruby2_keywords, true)
+
+      # @api private
+      def option(*)
+        super.tap do
+          __define_with__ unless method_defined?(:with)
+        end
+      end
+      ruby2_keywords(:option) if respond_to?(:ruby2_keywords, true)
+
+      # @api private
+      def __define_with__
+        seq_names = dry_initializer
+          .definitions
+          .reject { |_, d| d.option }
+          .keys
+          .join(", ")
+
+        seq_names << ", " unless seq_names.empty?
+
+        undef_method(:with) if method_defined?(:with)
+
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def with(**new_options)
+            if new_options.empty?
+              self
+            else
+              self.class.new(#{seq_names}**options, **new_options)
+            end
+          end
+        RUBY
+      end
+    end
+
+    # @api private
+    def self.extended(base)
+      base.extend(Dry::Initializer[undefined: false])
+      base.extend(DefineWithHook)
+      base.include(InstanceMethods)
+    end
+
+    # @api private
+    module InstanceMethods
+      # Instance options
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def options
+        @__options__ ||= self.class.dry_initializer.definitions.values.each_with_object({}) do |item, obj|
+          obj[item.target] = instance_variable_get(item.ivar)
+        end
+      end
+
+      define_method(:class, Kernel.instance_method(:class))
+      define_method(:instance_variable_get, Kernel.instance_method(:instance_variable_get))
+
+      # This makes sure we memoize options before an object becomes frozen
+      #
+      # @api public
+      def freeze
+        options
+        super
+      end
+    end
+  end
+end

data/lib/rom/lint/enumerable_dataset.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "rom/lint/linter"
+
+module ROM
+  module Lint
+    # Ensures that a [ROM::EnumerableDataset] extension correctly yields
+    # arrays and tuples
+    #
+    # @api public
+    class EnumerableDataset < ROM::Lint::Linter
+      # The linted subject
+      #
+      # @api public
+      attr_reader :dataset
+
+      # The expected data
+      #
+      # @api public
+      attr_reader :data
+
+      # Create a linter for EnumerableDataset
+      #
+      # @param [EnumerableDataset] dataset the linted subject
+      # @param [Object] data the expected data
+      #
+      # @api public
+      def initialize(dataset, data)
+        @dataset = dataset
+        @data = data
+      end
+
+      # Lint: Ensure that +dataset+ yield tuples via +each+
+      #
+      # @api public
+      def lint_each
+        result = []
+        dataset.each do |tuple|
+          result << tuple
+        end
+        return if result == data
+
+        complain "#{dataset.class}#each must yield tuples"
+      end
+
+      # Lint: Ensure that +dataset+'s array equals to expected +data+
+      #
+      # @api public
+      def lint_to_a
+        return if dataset.to_a == data
+
+        complain "#{dataset.class}#to_a must cast dataset to an array"
+      end
+    end
+  end
+end