rom 0.2.0 → 0.3.0

data/lib/rom/reader_builder.rb

@@ -0,0 +1,28 @@
+module ROM
+
+  # @api private
+  class ReaderBuilder
+    attr_reader :relations, :readers
+
+    # @api private
+    def initialize(relations)
+      @relations = relations
+      @readers = {}
+    end
+
+    # @api private
+    def call(name, options = {}, &block)
+      parent = relations[options.fetch(:parent) { name }]
+
+      builder = MapperBuilder.new(name, parent, options)
+      builder.instance_exec(&block)
+      mapper = builder.call
+
+      mappers = options[:parent] ? readers.fetch(parent.name).mappers : {}
+
+      mappers[name] = mapper
+      readers[name] = Reader.new(name, parent, mappers) unless options[:parent]
+    end
+
+  end
+end

data/lib/rom/relation.rb

@@ -1,375 +1,66 @@
-# encoding: utf-8
-
-require 'rom/constants'
+require 'rom/ra'
 
 module ROM
 
-  # Enhanced ROM relation wrapping axiom relation and using injected mapper to
-  # load/dump tuples/objects
-  #
-  # @example
-  #
-  #   # set up an axiom relation
-  #   header = [[:id, Integer], [:name, String]]
-  #   data   = [[1, 'John'], [2, 'Jane']]
-  #   axiom  = Axiom::Relation.new(header, data)
-  #
-  #   # provide a simple mapper
-  #   class Mapper < Struct.new(:header)
-  #     def load(tuple)
-  #       data = header.map { |attribute|
-  #         [attribute.name, tuple[attribute.name]]
-  #       }
-  #       Hash[data]
-  #     end
-  #
-  #     def dump(hash)
-  #       header.each_with_object([]) { |attribute, tuple|
-  #         tuple << hash[attribute.name]
-  #       }
-  #     end
-  #   end
-  #
-  #   # wrap axiom relation with ROM relation
-  #   mapper   = Mapper.new(axiom.header)
-  #   relation = ROM::Relation.new(axiom, mapper)
+  # Base relation class
   #
-  #   # relation is an enumerable and it uses mapper to load/dump tuples/objects
-  #   relation.to_a
-  #   # => [{:id=>1, :name=>'John'}, {:id=>2, :name=>'Jane'}]
+  # Relation is a proxy for the dataset object provided by the adapter, it
+  # forwards every method to the dataset that's why "native" interface of the
+  # underlying adapter is available in the relation. This interface, however, is
+  # considered to private and should not be used outside of the relation instance.
   #
-  #   # you can insert/update/delete objects
-  #   relation.insert(id: 3, name: 'Piotr').to_a
-  #   # => [{:id=>1, :name=>"John"}, {:id=>2, :name=>"Jane"}, {:id=>3, :name=>"Piotr"}]
+  # ROM builds sub-classes of this class for every relation defined in the env
+  # for easy inspection and extensibility - every adapter can provide extensions
+  # for those sub-classes but there is always a vanilla relation instance stored
+  # in the schema registry.
   #
-  #   relation.delete(id: 1, name: 'John').to_a
-  #   # => [{:id=>2, :name=>"Jane"}]
+  # Relation instances also have access to the experimental ROM::RA interface
+  # giving in-memory relational operations that are very handy, especially when
+  # dealing with joined relations or data coming from different sources.
   #
+  # @api public
   class Relation
-    include Enumerable
-    include Equalizer.new(:mapper)
-    include Charlatan.new(:relation, :kind => Axiom::Relation)
-
-    undef_method :sort_by
-
-    attr_reader :mapper
-
-    def initialize(relation, mapper)
-      super(relation, mapper)
-      @mapper = mapper
-    end
-
-    # Iterate over tuples yielded by the wrapped relation
-    #
-    # @example
-    #   mapper = Class.new {
-    #     def load(value)
-    #       value.to_s
-    #     end
-    #
-    #     def dump(value)
-    #       value.to_i
-    #     end
-    #   }.new
-    #
-    #   relation = ROM::Relation.new([1, 2, 3], mapper)
-    #
-    #   relation.each do |value|
-    #     puts value # => '1'
-    #   end
-    #
-    # @yieldparam [Object]
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def each
-      return to_enum unless block_given?
-      relation.each { |tuple| yield(mapper.load(tuple)) }
-      self
-    end
-
-    # Insert an object into relation
-    #
-    # @example
-    #   axiom    = Axiom::Relation.new([[:id, Integer]], [[1], [2]])
-    #   relation = ROM::Relation.new(axiom, mapper)
-    #
-    #   relation.insert(id: 3)
-    #   relation.to_a # => [[1], [2], [3]]
-    #
-    # @param [Object]
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def insert(object)
-      new(relation.insert([mapper.dump(object)]))
-    end
-    alias_method :<<, :insert
-
-    # Update an object
-    #
-    # @example
-    #   data     = [[1, 'John'], [2, 'Jane']]
-    #   axiom    = Axiom::Relation.new([[:id, Integer], [:name, String]], data)
-    #   relation = ROM::Relation.new(axiom, mapper)
-    #
-    #   relation.update({id: 2, name: 'Jane Doe'}, {id:2, name: 'Jane'})
-    #   relation.to_a # => [[1, 'John'], [2, 'Jane Doe']]
-    #
-    # @param [Object]
-    # @param [Hash] original attributes
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def update(object, original_tuple)
-      new(relation.delete([original_tuple]).insert([mapper.dump(object)]))
-    end
-
-    # Delete an object from the relation
-    #
-    # @example
-    #   axiom    = Axiom::Relation.new([[:id, Integer]], [[1], [2]])
-    #   relation = ROM::Relation.new(axiom, mapper)
-    #
-    #   relation.delete(id: 1)
-    #   relation.to_a # => [[2]]
-    #
-    # @param [Object]
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def delete(object)
-      new(relation.delete([mapper.dump(object)]))
-    end
-
-    # Replace all objects in the relation with new ones
-    #
-    # @example
-    #   axiom    = Axiom::Relation.new([[:id, Integer]], [[1], [2]])
-    #   relation = ROM::Relation.new(axiom, mapper)
-    #
-    #   relation.replace([{id: 3}, {id: 4}])
-    #   relation.to_a # => [[3], [4]]
-    #
-    # @param [Array<Object>]
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def replace(objects)
-      new(relation.replace(objects.map(&mapper.method(:dump))))
-    end
-
-    # Take objects form the relation with provided limit
-    #
-    # @example
-    #   axiom    = Axiom::Relation.new([[:id, Integer]], [[1], [2]])
-    #   relation = ROM::Relation.new(axiom, mapper)
-    #
-    #   relation.take(2).to_a # => [[2]]
-    #
-    # @param [Integer] limit
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def take(limit)
-      new(sorted.take(limit))
-    end
-
-    # Take first n-objects from the relation
-    #
-    # @example
-    #   axiom    = Axiom::Relation.new([[:id, Integer]], [[1], [2]])
-    #   relation = ROM::Relation.new(axiom, mapper)
-    #
-    #   relation.first.to_a # => [[1]]
-    #   relation.first(2).to_a # => [[1], [2]]
-    #
-    # @param [Integer]
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def first(limit = 1)
-      new(sorted.first(limit))
-    end
-
-    # Take last n-objects from the relation
-    #
-    # @example
-    #   axiom    = Axiom::Relation.new([[:id, Integer]], [[1], [2]])
-    #   relation = ROM::Relation.new(axiom, mapper)
-    #
-    #   relation.last.to_a # => [[2]]
-    #   relation.last(2).to_a # => [[1], [2]]
-    #
-    # @param [Integer] limit
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def last(limit = 1)
-      new(sorted.last(limit))
-    end
-
-    # Drop objects from the relation by the given offset
-    #
-    # @example
-    #   axiom    = Axiom::Relation.new([[:id, Integer]], [[1], [2]])
-    #   relation = ROM::Relation.new(axiom, mapper)
-    #
-    #   relation.drop(1).to_a # => [[2]]
-    #
-    # @param [Integer]
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def drop(offset)
-      new(sorted.drop(offset))
-    end
-
-    # Return exactly one object matching criteria or raise an error
-    #
-    # @example
-    #   axiom    = Axiom::Relation.new([[:id, Integer]], [1]])
-    #   relation = ROM::Relation.new(axiom, mapper)
-    #
-    #   relation.one.to_a # => {id: 1}
-    #
-    # @param [Proc] block
-    #   optional block to call in case no tuple is returned
-    #
-    # @return [Object]
-    #
-    # @raise NoTuplesError
-    #   if no tuples were returned
-    #
-    # @raise ManyTuplesError
-    #   if more than one tuple was returned
-    #
-    # @api public
-    def one(&block)
-      block  ||= ->() { raise NoTuplesError }
-      tuples   = take(2).to_a
-
-      if tuples.count > 1
-        raise ManyTuplesError
-      else
-        tuples.first || block.call
-      end
-    end
-
-    # Inject a new mapper into this relation
-    #
-    # @example
-    #
-    #   relation = ROM::Relation.new([], mapper)
-    #   relation.inject_mapper(new_mapper)
-    #
-    # @param [Object] a mapper object
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def inject_mapper(mapper)
-      new(relation, mapper)
-    end
-
-    # Join two relations
-    #
-    # @example
-    #
-    #   users.join(tasks)
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def join(other)
-      new(relation.join(other.relation), mapper.join(other.mapper))
-    end
+    include Charlatan.new(:dataset)
+    include Equalizer.new(:header, :dataset)
+    include RA
 
-    # Wrap one or more relation
-    #
-    # @example
-    #
-    #   tasks.join(users).wrap(user: tasks)
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def wrap(other)
-      relation_wrap = other.each_with_object({}) { |(name, relation), o| o[name] = relation.header }
-      mapper_wrap = other.each_with_object({}) { |(name, relation), o| o[name] = relation.mapper }
+    attr_reader :header
 
-      new(relation.wrap(relation_wrap), mapper.wrap(mapper_wrap))
+    # @api private
+    def self.finalize(env, relation)
+      # noop
     end
 
-    # Group one or more relation
-    #
-    # @example
-    #
-    #   users.join(tasks).group(tasks: tasks)
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def group(other)
-      relation_group = other.each_with_object({}) { |(name, relation), o| o[name] = relation.header }
-      mapper_group = other.each_with_object({}) { |(name, relation), o| o[name] = relation.mapper }
-
-      new(relation.group(relation_group), mapper.group(mapper_group))
+    # @api private
+    def initialize(dataset, header = dataset.header)
+      super
+      @header = header.dup.freeze
     end
 
-    # Project a relation
-    #
-    # @example
-    #
-    #   users.project([:id, :name])
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def project(names)
-      new(relation.project(names), mapper.project(names))
+    # @api private
+    def each(&block)
+      return to_enum unless block
+      dataset.each(&block)
     end
 
-    # Rename attributes in a relation
-    #
-    # @example
-    #
-    #   users.rename(:user_id => :id)
-    #
-    # @return [Relation]
-    #
-    # @api public
-    def rename(names)
-      new(relation.rename(names), mapper.rename(names))
+    # @api private
+    def insert(tuple)
+      dataset.insert(tuple)
+      self
     end
 
-    # Sort wrapped relation using all attributes in the header
-    #
-    # @return [Axiom::Relation]
-    #
     # @api private
-    def sorted
-      relation.sort
+    def update(tuple)
+      dataset.update(tuple)
+      self
     end
 
-    # Return new relation instance
-    #
-    # @return [Relation]
-    #
     # @api private
-    def new(new_relation, new_mapper = mapper)
-      self.class.new(new_relation, new_mapper)
+    def delete
+      dataset.delete
+      self
     end
 
-  end # class Relation
+  end
 
-end # module ROM
+end

data/lib/rom/relation_builder.rb

@@ -0,0 +1,48 @@
+module ROM
+
+  # @api private
+  class RelationBuilder
+    attr_reader :schema, :mod
+
+    # @api private
+    def initialize(schema)
+      @schema = schema
+      @mod = schema.each_with_object(Module.new) do |(name, relation), m|
+        m.send(:define_method, name) { relation.dataset }
+      end
+    end
+
+    # @api private
+    def call(name)
+      schema_relation = schema[name]
+
+      klass = Class.new(Relation)
+
+      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.name
+          "#{Relation.name}[#{Inflecto.camelize(name)}]"
+        end
+
+        def self.inspect
+          name
+        end
+
+        def self.to_s
+          name
+        end
+
+        def name
+          #{name.inspect}
+        end
+      RUBY
+
+      klass.send(:include, mod)
+
+      yield(klass)
+
+      klass.new(schema_relation.dataset, schema_relation.header)
+    end
+
+  end
+
+end