rom 5.4.1 → 6.0.0.alpha1

data/lib/rom/mapper.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "rom/core"
+require "rom/plugins/class_methods"
+
+require_relative "mapper/dsl"
+require_relative "components/provider"
+
+module ROM
+  # Mapper is a simple object that uses transformers to load relations
+  #
+  # @private
+  class Mapper
+    extend ROM::Provider(type: :mapper)
+    extend Plugins::ClassMethods
+
+    include Dry::Equalizer(:transformers, :header)
+    include DSL
+
+    setting :inherit_header, default: true
+    setting :reject_keys, default: false
+    setting :prefix_separator, default: "_"
+    setting :symbolize_keys
+    setting :copy_keys
+    setting :prefix
+
+    # @return [Object] transformers object built by a processor
+    #
+    # @api private
+    attr_reader :transformers
+
+    # @return [Header] header that was used to build the transformers
+    #
+    # @api private
+    attr_reader :header
+
+    # @return [Hash] registered processors
+    #
+    # @api private
+    def self.processors
+      @_processors ||= {}
+    end
+
+    # Register a processor class
+    #
+    # @return [Hash]
+    #
+    # @api private
+    def self.register_processor(processor)
+      name = processor.name.split("::").last.downcase.to_sym
+      processors.update(name => processor)
+    end
+    require "rom/processor/transformer"
+
+    # Prepares an array of headers for a potentially multistep mapper
+    #
+    # @return [Array<Header>]
+    #
+    # @api private
+    def self.headers(header)
+      return [header] if steps.empty?
+      return steps.map(&:header) if attributes.empty?
+
+      raise(MapperMisconfiguredError, "cannot mix outer attributes and steps")
+    end
+
+    # Build a mapper using provided processor type
+    #
+    # @return [Mapper]
+    #
+    # @api private
+    def self.build(header = self.header, processor = :transformer)
+      new(header, processor)
+    end
+
+    # @api private
+    def initialize(header, processor = :transformer)
+      processor = Mapper.processors.fetch(processor)
+      @transformers = self.class.headers(header).map do |hdr|
+        processor.build(self, hdr)
+      end
+      @header = header
+    end
+
+    # @return [Class] optional model that is instantiated by a mapper
+    #
+    # @api private
+    def model
+      header.model
+    end
+
+    # Process a relation using the transformers
+    #
+    # @api private
+    def call(relation)
+      transformers.reduce(relation.to_a) { |a, e| e.call(a) }
+    end
+  end
+end

data/lib/rom/mapper_compiler.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "dry/core/class_attributes"
+
+require "rom/constants"
+require "rom/initializer"
+require "rom/struct"
+require "rom/struct_compiler"
+require "rom/cache"
+
+module ROM
+  # @api private
+  class MapperCompiler
+    extend Dry::Core::ClassAttributes
+    extend Initializer
+
+    defines :mapper_options
+
+    mapper_options(EMPTY_HASH)
+
+    option :cache, default: -> { Cache.new }
+
+    attr_reader :struct_compiler
+
+    attr_reader :mapper_options
+
+    def initialize(*)
+      super
+      @struct_compiler = StructCompiler.new(cache: cache)
+      @cache = cache.namespaced(:mappers)
+      @mapper_options = self.class.mapper_options
+    end
+    ruby2_keywords(:initialize) if respond_to?(:ruby2_keywords, true)
+
+    def call(ast)
+      cache.fetch_or_store(ast.hash) { Mapper.build(Header.coerce(*visit(ast))) }
+    end
+    alias_method :[], :call
+
+    private
+
+    def visit(node)
+      name, node = node
+      __send__("visit_#{name}", node)
+    end
+
+    def visit_relation(node)
+      rel_name, header, meta_options = node
+      name = meta_options[:combine_name] || meta_options[:alias] || rel_name
+      namespace = meta_options.fetch(:struct_namespace)
+
+      model = meta_options.fetch(:model) do
+        if meta_options[:combine_name]
+          false
+        else
+          struct_compiler[name, header, namespace]
+        end
+      end
+
+      options = [header.map(&method(:visit)), mapper_options.merge(model: model)]
+
+      if meta_options[:combine_type]
+        type = meta_options[:combine_type] == :many ? :array : :hash
+        keys = meta_options.fetch(:keys)
+
+        [name, {combine: true, type: type, keys: keys, header: Header.coerce(*options)}]
+      elsif meta_options[:wrap]
+        [name, {wrap: true, type: :hash, header: Header.coerce(*options)}]
+      else
+        options
+      end
+    end
+
+    def visit_attribute(node)
+      name, _, meta_options = node
+
+      if meta_options[:alias]
+        [meta_options[:alias], {from: name}]
+      else
+        [name]
+      end
+    end
+  end
+end

data/lib/rom/memory/associations/many_to_many.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rom/associations/many_to_many"
+
+module ROM
+  module Memory
+    module Associations
+      class ManyToMany < ROM::Associations::ManyToMany
+      end
+    end
+  end
+end

data/lib/rom/memory/associations/many_to_one.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rom/associations/many_to_one"
+
+module ROM
+  module Memory
+    module Associations
+      class ManyToOne < ROM::Associations::ManyToOne
+      end
+    end
+  end
+end

data/lib/rom/memory/associations/one_to_many.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rom/associations/one_to_many"
+
+module ROM
+  module Memory
+    module Associations
+      class OneToMany < ROM::Associations::OneToMany
+      end
+    end
+  end
+end

data/lib/rom/memory/associations/one_to_one.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rom/memory/associations/one_to_many"
+
+module ROM
+  module Memory
+    module Associations
+      class OneToOne < OneToMany
+      end
+    end
+  end
+end

data/lib/rom/memory/associations.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "rom/memory/associations/many_to_many"
+require "rom/memory/associations/many_to_one"
+require "rom/memory/associations/one_to_many"
+require "rom/memory/associations/one_to_one"

data/lib/rom/memory/commands.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "rom/commands"
+
+module ROM
+  module Memory
+    # Memory adapter commands namespace
+    #
+    # @api public
+    module Commands
+      # In-memory create command
+      #
+      # @api public
+      class Create < ROM::Commands::Create
+        config.component.adapter = :memory
+
+        use :schema
+
+        # @see ROM::Commands::Create#execute
+        def execute(tuples)
+          Array([tuples]).flatten.map { |tuple|
+            attributes = input[tuple]
+            relation.insert(attributes.to_h)
+            attributes
+          }.to_a
+        end
+      end
+
+      # In-memory update command
+      #
+      # @api public
+      class Update < ROM::Commands::Update
+        config.component.adapter = :memory
+
+        use :schema
+
+        # @see ROM::Commands::Update#execute
+        def execute(params)
+          attributes = input[params]
+          relation.map { |tuple| tuple.update(attributes.to_h) }
+        end
+      end
+
+      # In-memory delete command
+      #
+      # @api public
+      class Delete < ROM::Commands::Delete
+        config.component.adapter = :memory
+
+        # @see ROM::Commands::Delete#execute
+        def execute
+          relation.to_a.map do |tuple|
+            source.delete(tuple)
+            tuple
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/memory/dataset.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "rom/array_dataset"
+
+module ROM
+  module Memory
+    # In-memory dataset
+    #
+    # This class can be used as a base class for other adapters.
+    #
+    # @api public
+    class Dataset
+      include ArrayDataset
+
+      # Join with other datasets
+      #
+      # @param [Array<Dataset>] args A list of dataset to join with
+      #
+      # @return [Dataset]
+      #
+      # @api public
+      def join(*args)
+        left, right = args.size > 1 ? args : [self, args.first]
+
+        join_map = left.each_with_object({}) { |tuple, h|
+          others = right.to_a.find_all { |t| (tuple.to_a & t.to_a).any? }
+          (h[tuple] ||= []).concat(others)
+        }
+
+        tuples = left.flat_map { |tuple|
+          join_map[tuple].map { |other| tuple.merge(other) }
+        }
+
+        self.class.new(tuples, **options)
+      end
+
+      # Restrict a dataset
+      #
+      # @param [Hash] criteria A hash with conditions
+      #
+      # @return [Dataset]
+      #
+      # @api public
+      def restrict(criteria = nil, &block)
+        return find_all(&block) unless criteria
+
+        find_all do |tuple|
+          criteria.all? do |k, v|
+            case v
+            when Array then v.include?(tuple[k])
+            when Regexp then tuple[k].match(v)
+            else tuple[k].eql?(v)
+            end
+          end
+        end
+      end
+
+      # Project a dataset
+      #
+      # @param [Array<Symbol>] names A list of attribute names
+      #
+      # @return [Dataset]
+      #
+      # @api public
+      def project(*names)
+        map { |tuple| tuple.select { |key| names.include?(key) } }
+      end
+
+      # Sort a dataset
+      #
+      # @param [Array<Symbol>] fields
+      #   Names of fields to order tuples by
+      #
+      # @option [Boolean] :nils_first (false)
+      #   Whether `nil` values should be placed before others
+      #
+      # @return [Dataset]
+      #
+      # @api public
+      def order(*fields)
+        nils_first = fields.pop[:nils_first] if fields.last.is_a?(Hash)
+
+        sort do |a, b|
+          fields # finds the first difference between selected fields of tuples
+            .map { |n| __compare__ a[n], b[n], nils_first }
+            .detect(-> { 0 }) { |r| r != 0 }
+        end
+      end
+
+      # Insert tuple into a dataset
+      #
+      # @param [Hash] tuple A new tuple for insertion
+      #
+      # @api public
+      #
+      # @return [Dataset]
+      def insert(tuple)
+        data << tuple
+        self
+      end
+      alias_method :<<, :insert
+
+      # Delete tuples from a dataset
+      #
+      # @param [Hash] tuple A new tuple for deletion
+      #
+      # @return [Dataset]
+      #
+      # @api public
+      def delete(tuple)
+        data.delete(tuple)
+        self
+      end
+
+      private
+
+      # Compares two values, that are either comparable, or can be nils
+      #
+      # @api private
+      def __compare__(a, b, nils_first)
+        return a <=> b unless a.nil? ^ b.nil?
+
+        nils_first ^ b.nil? ? -1 : 1
+      end
+    end
+  end
+end

data/lib/rom/memory/gateway.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "rom/gateway"
+require "rom/memory/storage"
+require "rom/memory/commands"
+
+module ROM
+  module Memory
+    # In-memory gateway interface
+    #
+    # @example
+    #   gateway = ROM::Memory::Gateway.new
+    #   gateway.dataset(:users)
+    #   gateway[:users].insert(name: 'Jane')
+    #
+    # @api public
+    class Gateway < ROM::Gateway
+      adapter :memory
+
+      # @return [Object] default logger
+      #
+      # @api public
+      attr_reader :logger
+
+      # @api private
+      def initialize
+        @connection = Storage.new
+      end
+
+      # Set default logger for the gateway
+      #
+      # @param [Object] logger object
+      #
+      # @api public
+      def use_logger(logger)
+        @logger = logger
+      end
+
+      # Register a dataset in the gateway
+      #
+      # If dataset already exists it will be returned
+      #
+      # @return [Dataset]
+      #
+      # @api public
+      def dataset(name)
+        self[name] || connection.create_dataset(name)
+      end
+
+      # @see ROM::Gateway#dataset?
+      def dataset?(name)
+        connection.key?(name)
+      end
+
+      # Return dataset with the given name
+      #
+      # @param (see ROM::Gateway#[])
+      # @return [Memory::Dataset]
+      #
+      # @api public
+      def [](name)
+        connection[name]
+      end
+    end
+  end
+end

data/lib/rom/memory/mapper_compiler.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "rom/mapper_compiler"
+
+module ROM
+  module Memory
+    class MapperCompiler < ROM::MapperCompiler
+    end
+  end
+end

data/lib/rom/memory/relation.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "rom/relation"
+require "rom/memory/types"
+require "rom/memory/schema"
+
+module ROM
+  module Memory
+    # Relation subclass for memory adapter
+    #
+    # @example
+    #   class Users < ROM::Relation[:memory]
+    #   end
+    #
+    # @api public
+    class Relation < ROM::Relation
+      include Enumerable
+      include Memory
+
+      config.component.adapter = :memory
+      config.schema.constant = Memory::Schema
+
+      # @!method take(amount)
+      #   @param (see Dataset#take)
+      #   @return [Relation]
+      #   @see Dataset#take
+      #
+      # @!method join(*args)
+      #   @param (see Dataset#take)
+      #   @return [Relation]
+      #   @see Dataset#join
+      #
+      # @!method restrict(criteria = nil)
+      #   @param (see Dataset#restrict)
+      #   @return [Relation]
+      #   @see Dataset#restrict
+      #
+      # @!method order(*fields)
+      #   @param (see Dataset#order)
+      #   @return [Relation]
+      #   @see Dataset#order
+      forward :take, :join, :restrict, :order
+
+      # Project a relation with provided attribute names
+      #
+      # @param [*Array] names A list with attribute names
+      #
+      # @return [Memory::Relation]
+      #
+      # @api public
+      def project(*names)
+        schema.project(*names).(self)
+      end
+
+      # Rename attributes in a relation
+      #
+      # @api public
+      def rename(mapping)
+        schema.rename(mapping).(self)
+      end
+
+      # Insert tuples into the relation
+      #
+      # @example
+      #   users.insert(name: 'Jane')
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def insert(*args)
+        dataset.insert(*args)
+        self
+      end
+      alias_method :<<, :insert
+
+      # Delete tuples from the relation
+      #
+      # @example
+      #   users.insert(name: 'Jane')
+      #   users.delete(name: 'Jane')
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def delete(*args)
+        dataset.delete(*args)
+        self
+      end
+    end
+  end
+end

data/lib/rom/memory/schema.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rom/schema"
+require "rom/memory/associations"
+
+module ROM
+  module Memory
+    # Specialized schema for memory adapter
+    #
+    # @api public
+    class Schema < ROM::Schema
+      # @see Schema#call
+      # @api public
+      def call(relation)
+        relation.new(relation.dataset.project(*map(&:name)), schema: self)
+      end
+
+      # Internal hook used during setup process
+      #
+      # @see Schema#finalize_associations!
+      #
+      # @api private
+      def finalize_associations!(relations:)
+        super do
+          associations.map do |definition|
+            Memory::Associations.const_get(definition.type).new(definition, relations)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/memory/storage.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "concurrent/hash"
+require "concurrent/array"
+
+require "rom/memory/dataset"
+
+module ROM
+  module Memory
+    # In-memory thread-safe data storage
+    #
+    # @private
+    class Storage
+      # Dataset registry
+      #
+      # @return [ThreadSafe::Hash]
+      #
+      # @api private
+      attr_reader :data
+
+      # @api private
+      def initialize
+        @data = Concurrent::Hash.new
+      end
+
+      # @return [Dataset]
+      #
+      # @api private
+      def [](name)
+        data[name]
+      end
+
+      # Register a new dataset
+      #
+      # @return [Dataset]
+      #
+      # @api private
+      def create_dataset(name)
+        data[name] = Dataset.new(Concurrent::Array.new)
+      end
+
+      # Check if there's dataset under specified key
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def key?(name)
+        data.key?(name)
+      end
+
+      # Return registered datasets count
+      #
+      # @return [Integer]
+      #
+      # @api private
+      def size
+        data.size
+      end
+    end
+  end
+end

data/lib/rom/memory/types.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rom/types"
+
+module ROM
+  module Memory
+    module Types
+      include ROM::Types
+    end
+  end
+end