rom-core 4.0.0.beta1

data/lib/rom/memory/dataset.rb

@@ -0,0 +1,97 @@
+require 'rom/array_dataset'
+
+module ROM
+  module Memory
+    # In-memory dataset
+    #
+    # @api public
+    class Dataset
+      include ArrayDataset
+
+      # Join two datasets
+      #
+      # @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
+      #
+      # @api public
+      def restrict(criteria = nil)
+        return find_all { |tuple| yield(tuple) } 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
+      #
+      # @api public
+      def project(*names)
+        map { |tuple| tuple.reject { |key| !names.include?(key) } }
+      end
+
+      # Sort a dataset
+      #
+      # @param [Array<Symbol>] names
+      #   Names of fields to order tuples by
+      #
+      # @option [Boolean] :nils_first (false)
+      #   Whether `nil` values should be placed before others
+      #
+      # @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
+      #
+      # @api public
+      def insert(tuple)
+        data << tuple
+        self
+      end
+      alias_method :<<, :insert
+
+      # Delete tuples from a dataset
+      #
+      # @api public
+      def delete(tuple)
+        data.delete(tuple)
+        self
+      end
+
+      private
+
+      # Compares two values, that are either comparable, or can be nils
+      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,64 @@
+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/relation.rb

@@ -0,0 +1,62 @@
+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
+
+      adapter :memory
+      schema_class Memory::Schema
+
+      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
+
+      # 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,23 @@
+require 'rom/schema'
+require 'rom/memory/associations'
+
+module ROM
+  module Memory
+    class Schema < ROM::Schema
+      # @see Schema#call
+      # @api public
+      def call(relation)
+        relation.new(relation.dataset.project(*map(&:name)), schema: self)
+      end
+
+      # @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,59 @@
+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,9 @@
+require 'rom/types'
+
+module ROM
+  module Memory
+    module Types
+      include ROM::Types
+    end
+  end
+end

data/lib/rom/pipeline.rb

@@ -0,0 +1,105 @@
+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
+    end
+
+    # Base composite class with left-to-right pipeline behavior
+    #
+    # @api private
+    class Composite
+      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,25 @@
+require 'rom/constants'
+require 'rom/plugin_base'
+require 'rom/support/configurable'
+
+module ROM
+  # Plugin is a simple object used to store plugin configurations
+  #
+  # @private
+  class Plugin < PluginBase
+    include Configurable
+
+    # Apply this plugin to the provided class
+    #
+    # @param [Class] klass
+    #
+    # @api private
+    def apply_to(klass, options = EMPTY_HASH)
+      if options.any?
+        klass.send(:include, mod.new(options))
+      else
+        klass.send(:include, mod)
+      end
+    end
+  end
+end