rom 0.1.2 → 0.2.0

data/lib/rom/mapper/builder.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'rom/mapper/builder/definition'
+
+module ROM
+  class Mapper
+
+    # Builder DSL for ROM mappers
+    #
+    class Builder
+      attr_reader :schema, :mappers
+
+      # @api public
+      def self.call(*args, &block)
+        new(*args).call(&block)
+      end
+
+      # Initialize a new mapping instance
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(schema)
+        @schema = schema
+        @mappers = {}
+      end
+
+      # @api public
+      def relation(name, &block)
+        definition = Definition.build(schema[name].header, &block)
+        mappers[name] = definition.mapper
+        self
+      end
+
+      # @api private
+      def call(&block)
+        instance_eval(&block)
+      end
+
+      # @api private
+      def finalize
+        mappers.freeze
+      end
+
+      # @api private
+      def each(&block)
+        mappers.each(&block)
+      end
+
+      # @api private
+      def [](name)
+        mappers.fetch(name)
+      end
+
+    end # Builder
+
+  end # Mapper
+end # ROM

data/lib/rom/mapper/builder/definition.rb

@@ -0,0 +1,162 @@
+# encoding: utf-8
+
+require 'rom/mapper'
+require 'rom/mapper/attribute'
+
+module ROM
+  class Mapper
+    class Builder
+
+      # Mapping definition DSL
+      #
+      # @private
+      class Definition
+        include Adamantium::Flat
+
+        attr_reader :attributes
+
+        LOADERS = [:instance_variables, :attribute_hash, :attribute_accessors].freeze
+
+        # Build new mapping definition
+        #
+        # @api private
+        def self.build(header, &block)
+          new(header, &block)
+        end
+
+        # Initialize a new Definition instance
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(header, &block)
+          @header = header
+          @keys = header.keys.flat_map { |key_header| key_header.flat_map(&:name) }
+          @attributes = []
+          @loader = :load_instance_variables
+
+          instance_eval(&block)
+
+          build_mapper unless mapper
+        end
+
+        # @api private
+        def attribute_names
+          attributes.map(&:name)
+        end
+
+        # @api private
+        def loader(name = Undefined)
+          if name == Undefined
+            @loader
+          else
+            unless LOADERS.include?(name)
+              raise ArgumentError,
+                "loader +#{name.inspect}+ is not known. Valid loaders are #{LOADERS.inspect}"
+            end
+
+            @loader = :"load_#{name}"
+          end
+        end
+
+        # @api private
+        def header
+          @header.project(attributes.map(&:name))
+        end
+        memoize :header
+
+        # Get or set mapper
+        #
+        # @example
+        #
+        #   Mapping.build do
+        #     users do
+        #       mapper my_custom_mapper
+        #     end
+        #   end
+        #
+        # @param [Object]
+        #
+        # @return [Object]
+        #
+        # @api public
+        def mapper(mapper = Undefined)
+          if mapper == Undefined
+            @mapper
+          else
+            @mapper = mapper
+          end
+        end
+
+        # Get or set model for the mapper
+        #
+        # @example
+        #
+        #   Mapping.build do
+        #     users do
+        #       model User
+        #     end
+        #   end
+        #
+        # @param [Class]
+        #
+        # @return [Class]
+        #
+        # @api public
+        def model(model = Undefined)
+          if model == Undefined
+            @model
+          else
+            @model = model
+          end
+        end
+
+        # Configure attribute mappings
+        #
+        # @example
+        #
+        #   Mapping.build do
+        #     users do
+        #       map :id, :email
+        #       map :user_name, to: :name
+        #     end
+        #   end
+        #
+        # @params [Array<Symbol>,Symbol,Hash]
+        #
+        # @return [Definition]
+        #
+        # @api public
+        def map(*args)
+          if args.last.kind_of?(Hash)
+            attributes.concat([build_attribute(*args)])
+          else
+            attributes.concat(args.map { |name| build_attribute(name) })
+          end
+        end
+
+        private
+
+        # Build default rom mapper
+        #
+        # @api private
+        def build_mapper
+          @mapper = Mapper.build(attributes, model: model, type: loader)
+        end
+
+        def build_attribute(name, options = {})
+          header_name = options.fetch(:from, name)
+
+          defaults = {
+            key: @keys.include?(header_name),
+            type: @header[header_name].type.primitive
+          }
+
+          Attribute.build(name, defaults.merge(options))
+        end
+
+      end # Definition
+
+    end # DSL
+  end # Mapper
+end # ROM

data/lib/rom/mapper/header.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+require 'rom/mapper/attribute'
+
+module ROM
+  class Mapper
+
+    # Mapper header wrapping axiom header and providing mapping information
+    #
+    # @private
+    class Header
+      include Enumerable, Concord.new(:attributes), Adamantium, Morpher::NodeHelpers
+
+      # Build a header
+      #
+      # @api private
+      def self.build(input)
+        if input.is_a?(self)
+          input
+        else
+          new(input.map { |args| Attribute.build(*args) })
+        end
+      end
+
+      # Return attribute mapping
+      #
+      # @api private
+      def mapping
+        each_with_object({}) { |attribute, hash| hash.update(attribute.mapping) }
+      end
+      memoize :mapping
+
+      # Return all key attributes
+      #
+      # @return [Array<Attribute>]
+      #
+      # @api public
+      def keys
+        select(&:key?)
+      end
+      memoize :keys
+
+      def to_ast
+        s(:hash_transform, *map(&:to_ast))
+      end
+      memoize :to_ast
+
+      # Return attribute with the given name
+      #
+      # @return [Attribute]
+      #
+      # @api public
+      def [](name)
+        detect { |attribute| attribute.name == name } || raise(KeyError)
+      end
+
+      # Return attribute names
+      #
+      # @api private
+      def attribute_names
+        map(&:name)
+      end
+
+      # Iterate over attributes
+      #
+      # @api private
+      def each(&block)
+        return to_enum unless block_given?
+        attributes.each(&block)
+        self
+      end
+
+      # TODO: this should receive a hash with header objects already
+      def wrap(other)
+        new_attributes = other.map { |name, mapper| mapper.attribute(Attribute::EmbeddedValue, name) }
+        self.class.new((attributes + new_attributes).uniq)
+      end
+
+      # TODO: this should receive a hash with header objects already
+      def group(other)
+        new_attributes = other.map { |name, mapper| mapper.attribute(Attribute::EmbeddedCollection, name) }
+        self.class.new((attributes + new_attributes).uniq)
+      end
+
+      # @api private
+      def join(other)
+        self.class.new((attributes + other.attributes).uniq)
+      end
+
+      # @api private
+      def project(names)
+        self.class.new(select { |attribute| names.include?(attribute.tuple_key) })
+      end
+
+      # @api private
+      def rename(names)
+        self.class.new(map { |attribute| names[attribute.name] ? attribute.rename(names[attribute.name]) : attribute })
+      end
+
+    end # Header
+
+  end # Mapper
+end # ROM

data/lib/rom/mapper/loader_builder.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module ROM
+  class Mapper
+
+    # Abstract loader class
+    #
+    # @private
+    class LoaderBuilder
+      extend Morpher::NodeHelpers
+
+      def self.call(header, model, type)
+        param =
+          if type == :load_attribute_hash
+            s(:param, model)
+          else
+            s(:param, model, *header.attribute_names)
+          end
+
+        Morpher.compile(s(:block, header.to_ast, s(type, param)))
+      end
+
+    end # Loader
+
+  end # Mapper
+end # ROM

data/lib/rom/relation.rb

@@ -0,0 +1,375 @@
+# encoding: utf-8
+
+require 'rom/constants'
+
+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)
+  #
+  #   # relation is an enumerable and it uses mapper to load/dump tuples/objects
+  #   relation.to_a
+  #   # => [{:id=>1, :name=>'John'}, {:id=>2, :name=>'Jane'}]
+  #
+  #   # 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"}]
+  #
+  #   relation.delete(id: 1, name: 'John').to_a
+  #   # => [{:id=>2, :name=>"Jane"}]
+  #
+  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
+
+    # 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 }
+
+      new(relation.wrap(relation_wrap), mapper.wrap(mapper_wrap))
+    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))
+    end
+
+    # Project a relation
+    #
+    # @example
+    #
+    #   users.project([:id, :name])
+    #
+    # @return [Relation]
+    #
+    # @api public
+    def project(names)
+      new(relation.project(names), mapper.project(names))
+    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))
+    end
+
+    # Sort wrapped relation using all attributes in the header
+    #
+    # @return [Axiom::Relation]
+    #
+    # @api private
+    def sorted
+      relation.sort
+    end
+
+    # Return new relation instance
+    #
+    # @return [Relation]
+    #
+    # @api private
+    def new(new_relation, new_mapper = mapper)
+      self.class.new(new_relation, new_mapper)
+    end
+
+  end # class Relation
+
+end # module ROM