rom 0.5.0 → 0.6.0.beta1

data/lib/rom/mapper/dsl.rb

@@ -0,0 +1,100 @@
+require 'rom/mapper/attribute_dsl'
+
+module ROM
+  class Mapper
+    # Mapper class-level DSL including Attribute DSL and Model DSL
+    module DSL
+      # Extend mapper class with macros and DSL methods
+      #
+      # @api private
+      def self.included(klass)
+        klass.extend(ClassMacros)
+        klass.extend(ClassMethods)
+      end
+
+      # Class methods for all mappers
+      #
+      # @private
+      module ClassMethods
+        # Set base ivars for the mapper class
+        #
+        # @api private
+        def inherited(klass)
+          super
+
+          klass.instance_variable_set('@attributes', nil)
+          klass.instance_variable_set('@header', nil)
+          klass.instance_variable_set('@dsl', nil)
+        end
+
+        # Return base_relation used for creating mapper registry
+        #
+        # This is used to "gather" mappers under same root name
+        #
+        # @api private
+        def base_relation
+          if superclass.relation
+            superclass.relation
+          else
+            relation
+          end
+        end
+
+        # Return header of the mapper
+        #
+        # This is memoized so mutating mapper class won't have an effect wrt
+        # header after it was initialized for the first time.
+        #
+        # TODO: freezing mapper class here is probably a good idea
+        #
+        # @api private
+        def header
+          @header ||= dsl.header
+        end
+
+        private
+
+        # Return default Attribute DSL options based on settings of the mapper
+        # class
+        #
+        # @api private
+        def options
+          { prefix: prefix,
+            prefix_separator: prefix_separator,
+            symbolize_keys: symbolize_keys }
+        end
+
+        # Return default attributes that might have been inherited from the
+        # superclass
+        #
+        # @api private
+        def attributes
+          @attributes ||=
+            if superclass.respond_to?(:attributes, true) && inherit_header
+              superclass.attributes.dup
+            else
+              []
+            end
+        end
+
+        # Create the attribute DSL instance used by the mapper class
+        #
+        # @api private
+        def dsl
+          @dsl ||= AttributeDSL.new(attributes, options)
+        end
+
+        # Delegate Attribute DSL method to the dsl instance
+        #
+        # @api private
+        def method_missing(name, *args, &block)
+          if dsl.respond_to?(name)
+            dsl.public_send(name, *args, &block)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/mapper/model_dsl.rb

@@ -0,0 +1,55 @@
+require 'rom/model_builder'
+
+module ROM
+  class Mapper
+    # Model DSL allows setting a model class
+    #
+    # @private
+    module ModelDSL
+      attr_reader :attributes, :builder, :klass
+
+      DEFAULT_TYPE = :poro
+
+      # Set or generate a model
+      #
+      # @example
+      #   class MyDefinition
+      #     include ROM::Mapper::ModelDSL
+      #
+      #     def initialize
+      #       @attributes = [[:name], [:title]]
+      #     end
+      #   end
+      #
+      #   definition = MyDefinition.new
+      #
+      #   # just set a model constant
+      #   definition.model(User)
+      #
+      #   # generate model class for the attributes
+      #   definition.model(name: 'User')
+      #
+      # @api public
+      def model(options = nil)
+        if options.is_a?(Class)
+          @klass = options
+        elsif options
+          type = options.fetch(:type) { DEFAULT_TYPE }
+          @builder = ModelBuilder[type].new(options)
+        end
+
+        build_class unless options
+      end
+
+      private
+
+      # Build a model class using a specialized builder
+      #
+      # @api private
+      def build_class
+        return klass if klass
+        return builder.call(attributes.map(&:first)) if builder
+      end
+    end
+  end
+end

data/lib/rom/mapper_registry.rb

@@ -6,9 +6,16 @@ module ROM
       elements[name] = mapper
     end
 
+    # @api private
+    def [](name)
+      elements.fetch(name) { raise(MapperMissingError, name) }
+    end
+
     # @api private
     def by_path(path)
-      elements[paths(path).detect { |name| elements.key?(name) }]
+      elements.fetch(paths(path).detect { |name| elements.key?(name) }) {
+        raise(MapperMissingError, path)
+      }
     end
 
     private

data/lib/rom/memory.rb

@@ -0,0 +1,4 @@
+require 'rom/memory/relation'
+require 'rom/memory/repository'
+
+ROM.register_adapter(:memory, ROM::Memory)

data/lib/rom/memory/commands.rb

@@ -0,0 +1,46 @@
+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
+        # @see ROM::Commands::Create#execute
+        def execute(tuple)
+          attributes = input[tuple]
+          validator.call(attributes)
+          [relation.insert(attributes.to_h).to_a.last]
+        end
+      end
+
+      # In-memory update command
+      #
+      # @api public
+      class Update < ROM::Commands::Update
+        # @see ROM::Commands::Update#execute
+        def execute(params)
+          attributes = input[params]
+          validator.call(attributes)
+          relation.map { |tuple| tuple.update(attributes.to_h) }
+        end
+      end
+
+      # In-memory delete command
+      #
+      # @api public
+      class Delete < ROM::Commands::Delete
+        # @see ROM::Commands::Delete#execute
+        def execute
+          tuples = target.to_a
+          tuples.each { |tuple| relation.delete(tuple) }
+          tuples
+        end
+      end
+    end
+  end
+end

data/lib/rom/memory/dataset.rb

@@ -0,0 +1,72 @@
+require 'rom/support/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, row_proc)
+      end
+
+      # Restrict a dataset
+      #
+      # @api public
+      def restrict(criteria = nil)
+        if criteria
+          find_all { |tuple| criteria.all? { |k, v| tuple[k].eql?(v) } }
+        else
+          find_all { |tuple| yield(tuple) }
+        end
+      end
+
+      # Project a dataset
+      #
+      # @api public
+      def project(*names)
+        map { |tuple| tuple.reject { |key| !names.include?(key) } }
+      end
+
+      # Sort a dataset
+      #
+      # @api public
+      def order(*names)
+        sort_by { |tuple| tuple.values_at(*names) }
+      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
+    end
+  end
+end

data/lib/rom/memory/relation.rb

@@ -0,0 +1,44 @@
+module ROM
+  module Memory
+    # Relation subclass for memory adapter
+    #
+    # @example
+    #   class Users < ROM::Relation[:memory]
+    #   end
+    #
+    # @api public
+    class Relation < ROM::Relation
+      include Enumerable
+
+      forward :join, :project, :restrict, :order
+
+      # 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/repository.rb

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

data/lib/rom/memory/storage.rb

@@ -0,0 +1,57 @@
+require 'thread_safe'
+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 = ThreadSafe::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(ThreadSafe::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