rom 0.6.2 → 0.7.0

data/lib/rom/relation/graph.rb

@@ -0,0 +1,76 @@
+require 'rom/relation/loaded'
+require 'rom/relation/materializable'
+require 'rom/pipeline'
+
+module ROM
+  class Relation
+    # Load a relation with its associations
+    #
+    # @example
+    #   ROM.setup(:memory)
+    #
+    #   class Users < ROM::Relation[:memory]
+    #   end
+    #
+    #   class Tasks < ROM::Relation[:memory]
+    #     def for_users(users)
+    #       restrict(user: users.map { |user| user[:name] })
+    #     end
+    #   end
+    #
+    #   rom = ROM.finalize.env
+    #
+    #   rom.relations[:users] << { name: 'Jane' }
+    #   rom.relations[:tasks] << { user: 'Jane', title: 'Do something' }
+    #
+    #   rom.relation(:users).combine(rom.relation(:tasks).for_users)
+    #
+    # @api public
+    class Graph
+      include Materializable
+      include Pipeline
+      include Pipeline::Proxy
+
+      # Root aka parent relation
+      #
+      # @return [Relation::Lazy]
+      #
+      # @api private
+      attr_reader :root
+
+      # Child relation nodes
+      #
+      # @return [Array<Relation::Lazy>]
+      #
+      # @api private
+      attr_reader :nodes
+
+      alias_method :left, :root
+      alias_method :right, :nodes
+
+      # @api private
+      def initialize(root, nodes)
+        @root = root
+        @nodes = nodes
+      end
+
+      # Materialize this relation graph
+      #
+      # @return [Loaded]
+      #
+      # @api public
+      def call(*args)
+        left = root.call(*args)
+
+        right =
+          if left.count > 0
+            nodes.map { |node| node.call(left) }
+          else
+            nodes.map { |node| Loaded.new(node, []) }
+          end
+
+        Loaded.new(self, [left, right])
+      end
+    end
+  end
+end

data/lib/rom/relation/lazy.rb

@@ -1,5 +1,8 @@
 require 'rom/relation/loaded'
 require 'rom/relation/composite'
+require 'rom/relation/graph'
+require 'rom/relation/materializable'
+require 'rom/pipeline'
 
 module ROM
   class Relation
@@ -28,6 +31,8 @@ module ROM
     class Lazy
       include Equalizer.new(:relation, :options)
       include Options
+      include Materializable
+      include Pipeline
 
       option :mappers, reader: true, default: EMPTY_HASH
 
@@ -41,27 +46,24 @@ module ROM
       # @return [Hash<Symbol=>TrueClass>]
       #
       # @api private
-      attr_reader :methods
+      attr_reader :exposed_relations
 
       # @api private
       def initialize(relation, options = {})
         super
         @relation = relation
-        @methods = @relation.exposed_relations
+        @exposed_relations = @relation.exposed_relations
       end
 
-      # Compose two relation with a left-to-right composition
+      # Eager load other relation(s) for this relation
       #
-      # @example
-      #   users.by_name('Jane') >> tasks.for_users
-      #
-      # @param [Relation] other The right relation
+      # @param [Array<Relation>] others The other relation(s) to eager load
       #
-      # @return [Relation::Composite]
+      # @return [Relation::Graph]
       #
       # @api public
-      def >>(other)
-        Composite.new(self, other)
+      def combine(*others)
+        Graph.new(self, others)
       end
 
       # Build a relation pipeline using registered mappers
@@ -78,16 +80,6 @@ module ROM
       end
       alias_method :as, :map_with
 
-      # Coerce lazy relation to an array
-      #
-      # @return [Array]
-      #
-      # @api public
-      def to_a
-        call.to_a
-      end
-      alias_method :to_ary, :to_a
-
       # Load relation
       #
       # @return [Relation::Loaded]
@@ -97,50 +89,9 @@ module ROM
         Loaded.new(relation)
       end
 
-      # Yield relation tuples
-      #
-      # @yield [Object]
-      #
-      # @api public
-      def each(&block)
-        return to_enum unless block
-        to_a.each { |tuple| yield(tuple) }
-      end
-
-      # Delegate to loaded relation and return one object
-      #
-      # @return [Object]
-      #
-      # @see Loaded#one
-      #
-      # @api public
-      def one
-        call.one
-      end
-
-      # Delegate to loaded relation and return one object
-      #
-      # @return [Object]
-      #
-      # @see Loaded#one
-      #
-      # @api public
-      def one!
-        call.one!
-      end
-
-      # Return first tuple from a relation coerced to an array
-      #
-      # @return [Object]
-      #
-      # @api public
-      def first
-        to_a.first
-      end
-
       # @api private
       def respond_to_missing?(name, include_private = false)
-        methods.include?(name) || super
+        exposed_relations.include?(name) || super
       end
 
       # Return if this lazy relation is curried
@@ -162,13 +113,14 @@ module ROM
       #
       # @api private
       def method_missing(meth, *args, &block)
-        if !methods.include?(meth) || (curried? && name != meth)
+        if !exposed_relations.include?(meth) || (curried? && name != meth)
           super
         else
           arity = relation.method(meth).arity
 
           if arity < 0 || arity == args.size
             response = relation.__send__(meth, *args, &block)
+
             if response.is_a?(Relation)
               __new__(response)
             else

data/lib/rom/relation/materializable.rb

@@ -0,0 +1,66 @@
+module ROM
+  class Relation
+    # Interface for objects that can be materialized into a loaded relation
+    #
+    # @api public
+    module Materializable
+      # @abstract
+      #
+      # @api public
+      def call(*)
+        raise NotImplementedError, "#{self.class}#call must be implemented"
+      end
+
+      # Coerce the relation to an array
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_a
+        call.to_a
+      end
+      alias_method :to_ary, :to_a
+
+      # Yield relation tuples
+      #
+      # @yield [Hash,Object]
+      #
+      # @api public
+      def each(&block)
+        return to_enum unless block
+        to_a.each { |tuple| yield(tuple) }
+      end
+
+      # Delegate to loaded relation and return one object
+      #
+      # @return [Object]
+      #
+      # @see Loaded#one
+      #
+      # @api public
+      def one
+        call.one
+      end
+
+      # Delegate to loaded relation and return one object
+      #
+      # @return [Object]
+      #
+      # @see Loaded#one
+      #
+      # @api public
+      def one!
+        call.one!
+      end
+
+      # Return first tuple from a relation coerced to an array
+      #
+      # @return [Object]
+      #
+      # @api public
+      def first
+        to_a.first
+      end
+    end
+  end
+end

data/lib/rom/setup/finalize.rb

@@ -17,14 +17,15 @@ module ROM
     # @private
     class Finalize
       attr_reader :repositories, :repo_adapter, :datasets,
-        :relation_classes, :mapper_classes, :command_classes
+        :relation_classes, :mapper_classes, :mappers, :command_classes
 
       # @api private
-      def initialize(repositories, relation_classes, mapper_classes, command_classes)
+      def initialize(repositories, relation_classes, mappers, command_classes)
         @repositories = repositories
         @repo_adapter_map = ROM.repositories
         @relation_classes = relation_classes
-        @mapper_classes = mapper_classes
+        @mapper_classes = mappers.select { |mapper| mapper.is_a?(Class) }
+        @mappers = (mappers - @mapper_classes).reduce(:merge) || {}
         @command_classes = command_classes
         initialize_datasets
       end
@@ -83,9 +84,19 @@ module ROM
       # @api private
       def load_mappers
         mapper_registry = Mapper.registry(mapper_classes).each_with_object({})
-        registry_hash = mapper_registry.each do |(name, mappers), h|
-          h[name] = MapperRegistry.new(mappers)
+
+        registry_hash = mapper_registry.each { |(relation, mappers), h|
+          h[relation] = MapperRegistry.new(mappers)
+        }
+
+        mappers.each do |relation, mappers|
+          if registry_hash.key?(relation)
+            mappers.each { |name, mapper| registry[name] = mapper }
+          else
+            registry_hash[relation] = MapperRegistry.new(mappers)
+          end
         end
+
         Registry.new(registry_hash)
       end
 

data/lib/rom/setup_dsl/mapper_dsl.rb

@@ -6,10 +6,11 @@ module ROM
     #
     # @private
     class MapperDSL
-      attr_reader :mappers
+      attr_reader :registry
 
       # @api private
-      def initialize(&block)
+      def initialize(registry, &block)
+        @registry = registry
         instance_exec(&block)
       end
 
@@ -25,6 +26,13 @@ module ROM
         Mapper.build_class(name, options, &block)
         self
       end
+
+      # TODO
+      #
+      # @api public
+      def register(relation, mappers)
+        registry.register_mapper(relation => mappers)
+      end
     end
   end
 end

data/lib/rom/setup_dsl/setup.rb

@@ -42,7 +42,7 @@ module ROM
     #
     # @api public
     def mappers(&block)
-      MapperDSL.new(&block)
+      MapperDSL.new(self, &block)
     end
 
     # Command definition DSL

data/lib/rom/support/array_dataset.rb

@@ -14,13 +14,16 @@ module ROM
     #
     # @api private
     def self.included(klass)
-      klass.send(:include, DataProxy)
+      klass.class_eval do
+        include Options
+        include DataProxy
+      end
     end
 
     forward(
       :*, :+, :-, :compact, :compact!, :flatten, :flatten!, :length, :pop,
-      :reverse, :reverse!, :sample, :select!, :size, :shift, :shuffle, :shuffle!,
-      :slice, :slice!, :sort!, :sort_by!, :uniq, :uniq!, :unshift, :values_at
+      :reverse, :reverse!, :sample, :size, :shift, :shuffle, :shuffle!,
+      :slice, :slice!, :sort!, :uniq, :uniq!, :unshift, :values_at
     )
 
     [
@@ -30,7 +33,7 @@ module ROM
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{method}(*args, &block)
           return to_enum unless block
-          self.class.new(data.send(:#{method}, *args, &block))
+          self.class.new(data.send(:#{method}, *args, &block), options)
         end
       RUBY
     end

data/lib/rom/support/data_proxy.rb

@@ -12,6 +12,8 @@ module ROM
       :each, :to_a, :to_ary, :kind_of?, :instance_of?, :is_a?
     ].freeze
 
+    # Wrapped data array
+    #
     # @return [Object] Data object for the iterator
     #
     # @api private
@@ -30,19 +32,17 @@ module ROM
     def self.included(klass)
       klass.class_eval do
         extend ClassMethods
+
         include Equalizer.new(:data)
+
+        option :row_proc, reader: true, default: proc { |obj| obj.class.row_proc }
       end
     end
 
-    # Constructor for dataset objects
-    #
-    # @param [Object] data
-    # @param [Proc] row_proc processing proc
-    #
     # @api private
-    def initialize(data, row_proc = self.class.row_proc)
+    def initialize(data, options = {})
       @data = data
-      @row_proc = row_proc
+      super(data, options)
     end
 
     # Iterate over data using row_proc

data/lib/rom/support/deprecations.rb

@@ -0,0 +1,17 @@
+module ROM
+  module Deprecations
+    # @api private
+    def deprecate(old_name, new_name, msg = nil)
+      class_eval do
+        define_method(old_name) do |*args, &block|
+          warn <<-MSG.gsub(/^\s+/, '')
+            #{self.class}##{old_name} is deprecated and will be removed in 1.0.0.
+            Please use #{self.class}##{new_name} instead."
+            #{msg}
+          MSG
+          __send__(new_name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rom/support/enumerable_dataset.rb

@@ -23,6 +23,7 @@ module ROM
   #
   # @api public
   module EnumerableDataset
+    extend DataProxy::ClassMethods
     include Enumerable
 
     # Coerce a dataset to an array
@@ -40,17 +41,23 @@ module ROM
     # @api private
     def self.included(klass)
       return unless klass.is_a?(Class)
-      klass.send(:include, DataProxy)
+
+      klass.class_eval do
+        include Options
+        include DataProxy
+      end
     end
 
+    forward :take
+
     [
       :chunk, :collect, :collect_concat, :drop_while, :find_all, :flat_map,
-      :grep, :map, :reject, :select, :sort, :sort_by, :take, :take_while
+      :grep, :map, :reject, :select, :sort, :sort_by, :take_while
     ].each do |method|
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{method}(*args, &block)
           return to_enum unless block
-          self.class.new(super(*args, &block))
+          self.class.new(super(*args, &block), options)
         end
       RUBY
     end