rom-relation 0.1.0

data/lib/rom/mapping.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module ROM
+
+  # Builder DSL for ROM relations
+  #
+  class Mapping
+    include Adamantium::Flat
+
+    attr_reader :environment, :schema, :model
+    private :environment, :schema, :model
+
+    # Build ROM relations
+    #
+    # @example
+    #   relation = Axiom::Relation::Base.new(:users, [[:id, Integer], [:user_name, String]])
+    #   env      = { users: relation }
+    #
+    #   User = Class.new(OpenStruct.new)
+    #
+    #   registry = Mapping.build(env) do
+    #     users do
+    #       map :id
+    #       map :user_name, to: :name
+    #     end
+    #   end
+    #
+    #   registry[:users]
+    #   # #<ROM::Relation:0x000000025d3160>
+    #
+    # @param [Environment] rom environment
+    # @param [Schema] rom schema
+    #
+    # @return [Hash]
+    #
+    # @api public
+    def self.build(environment, schema, &block)
+      new(environment, schema, &block)
+    end
+
+    # Initialize a new mapping instance
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(environment, schema, &block)
+      @environment = environment
+      @schema      = schema
+      instance_eval(&block)
+    end
+
+    private
+
+    # Method missing hook
+    #
+    # @return [Relation]
+    #
+    # @api private
+    def method_missing(name, *, &block)
+      relation = schema[name]
+
+      if relation
+        build_relation(relation, &block)
+      else
+        super
+      end
+    end
+
+    # Build relation
+    #
+    # @return [Relation]
+    #
+    # @api private
+    def build_relation(relation, &block)
+      definition = Definition.build(relation.header, &block)
+      environment[relation.name] = Relation.build(relation, definition.mapper)
+    end
+
+  end # Mapping
+
+end # ROM

data/lib/rom/relation.rb

@@ -0,0 +1,339 @@
+# encoding: utf-8
+
+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, Concord::Public.new(:relation, :mapper)
+
+    # Build a new relation
+    #
+    # @param [Axiom::Relation]
+    # @param [Object] mapper
+    #
+    # @return [Relation]
+    #
+    # @api public
+    def self.build(relation, mapper)
+      new(mapper.call(relation), 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
+
+    # Restrict the relation
+    #
+    # @example
+    #   axiom    = Axiom::Relation.new([[:id, Integer]], [[1], [2]])
+    #   relation = ROM::Relation.new(axiom, mapper)
+    #
+    #   relation.restrict(id: 2).to_a # => [[2]]
+    #
+    # @param [Hash] conditions
+    #
+    # @return [Relation]
+    #
+    # @api public
+    def restrict(*args, &block)
+      new(relation.restrict(*args, &block))
+    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
+
+    # Sort the relation by provided attributes
+    #
+    # @example
+    #   axiom    = Axiom::Relation.new([[:id, Integer]], [[2], [1]])
+    #   relation = ROM::Relation.new(axiom, mapper)
+    #
+    #   relation.sort_by(:id).to_a # => [[1], [2]]
+    #
+    # @param [Array<Symbol>]
+    #
+    # @return [Relation]
+    #
+    # @api public
+    def sort_by(*args, &block)
+      new(relation.sort_by(*args, &block))
+    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
+
+    private
+
+    # 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

data/lib/rom/repository.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module ROM
+
+  # A repository with a given +name+ and +adapter+
+  #
+  # @api private
+  class Repository
+    include Concord.new(:name, :adapter, :relations)
+
+    # Build a repository with a given +name+ and +uri+
+    #
+    # @param [Symbol] name
+    #   the repository's name
+    #
+    # @param [Addressable::URI] uri
+    #   the uri for initializing the adapter
+    #
+    # @return [Repository]
+    #
+    # @api private
+    def self.build(name, uri, relations = {})
+      new(name, Axiom::Adapter.build(uri), relations)
+    end
+
+    # Return the relation identified by +name+
+    #
+    # @example
+    #
+    #   repo = Repository.coerce(:test, 'in_memory://test')
+    #   repo.register(:foo, [[:id, String], [:foo, String]])
+    #   repo[:foo]
+    #
+    #   # => <Axiom::Relation header=Axiom::Header ...>
+    #
+    # @param [Symbol] name
+    #   the name of the relation
+    #
+    # @return [Axiom::Relation]
+    #
+    # @raise [KeyError]
+    #
+    # @api public
+    def [](name)
+      relations.fetch(name)
+    end
+
+    # Register a relation with this repository
+    #
+    # @param [Axiom::Relation::Base] relation
+    #
+    # @return [Object] relation gateway
+    #
+    # @api public
+    def []=(name, relation)
+      adapter[name]   = relation
+      relations[name] = adapter[name]
+    end
+
+  end # Repository
+
+end # ROM

data/lib/rom/schema/definition/relation/base.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module ROM
+  class Schema
+    class Definition
+      class Relation
+
+        # Base relation builder object
+        #
+        class Base < self
+
+          def repository(name = Undefined)
+            if name == Undefined
+              @repository
+            else
+              @repository = name
+            end
+          end
+
+        end # Base
+
+      end # Relation
+    end # Definition
+  end # Schema
+end # ROM

data/lib/rom/schema/definition/relation.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module ROM
+  class Schema
+    class Definition
+
+      # Builder object for Axiom relation
+      #
+      # @private
+      class Relation
+        include Equalizer.new(:header, :keys)
+
+        # @api private
+        def initialize(&block)
+          @header = []
+          @keys   = []
+          instance_eval(&block)
+        end
+
+        # @api private
+        def call(name)
+          Axiom::Relation::Base.new(name, header)
+        end
+
+        # @api private
+        def header
+          Axiom::Relation::Header.coerce(@header, keys: @keys)
+        end
+
+        # @api private
+        def attribute(name, type)
+          @header << [name, type]
+        end
+
+        # @api private
+        def key(*attribute_names)
+          @keys.concat(attribute_names)
+        end
+
+      end # Relation
+
+    end # Definition
+  end # Schema
+end # ROM

data/lib/rom/schema/definition.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+module ROM
+  class Schema
+
+    # Builder object used by schema DSL to establish Axiom relations
+    #
+    # @private
+    class Definition
+      include Equalizer.new(:repositories, :relations)
+
+      attr_reader :repositories, :relations
+
+      # @api private
+      def initialize(repositories, &block)
+        @repositories = repositories
+        @relations    = {}
+        instance_eval(&block) if block
+      end
+
+      # Build a base relation
+      #
+      # @example
+      #
+      #   Schema.build do
+      #     base_relation :users do
+      #       # ...
+      #     end
+      #   end
+      #
+      # @return [Definition]
+      #
+      # @api private
+      def base_relation(name, &block)
+        builder    = Relation::Base.new(&block)
+        repository = repositories.fetch(builder.repository)
+
+        repository[name] = builder.call(name)
+        relations[name]  = repository[name]
+      end
+
+      # Build a relation
+      #
+      # @example
+      #
+      #   Schema.build do
+      #     relation :users do
+      #       # ...
+      #     end
+      #   end
+      #
+      # @return [Definition]
+      #
+      # @api private
+      def relation(name, &block)
+        relations[name] = instance_eval(&block)
+      end
+
+      # Return relation identified by name
+      #
+      # @return [Axiom::Relation, Axiom::Relation::Base]
+      #
+      # @api private
+      def [](name)
+        relations[name]
+      end
+
+      private
+
+      # Method missing hook
+      #
+      # @return [Axiom::Relation, Axiom::Relation::Base]
+      #
+      # @api private
+      def method_missing(name)
+        self[name] || super
+      end
+
+    end # Definition
+
+  end # Schema
+end # ROM

data/lib/rom/schema.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module ROM
+
+  # Schema builder DSL
+  #
+  class Schema
+    include Concord.new(:definition), Adamantium::Flat
+
+    # Build a relation schema
+    #
+    # @example
+    #
+    #   Schema.build do
+    #     base_relation :users do
+    #       repository :test
+    #       attribute :id, :name
+    #     end
+    #   end
+    #
+    # @return [Schema]
+    #
+    # @api public
+    def self.build(repositories, &block)
+      new(Definition.new(repositories, &block))
+    end
+
+    # Return defined relation identified by name
+    #
+    # @example
+    #
+    #   schema[:users] # => #<Axiom::Relation::Base ..>
+    #
+    # @return [Axiom::Relation, Axiom::Relation::Base]
+    #
+    # @api public
+    def [](name)
+      definition[name]
+    end
+
+    # @api private
+    def call(&block)
+      definition.instance_eval(&block)
+      self
+    end
+
+  end # Schema
+
+end # ROM

data/lib/rom/support/axiom/adapter/data_objects.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'axiom-do-adapter'
+
+module Axiom
+  module Adapter
+
+    # Reopenend to add functionality that should eventually
+    # be puhsed down to Adapter::DataObjects proper, or whatever
+    # will be the base class.
+    #
+    class DataObjects
+
+      extend Adapter
+
+      include Equalizer.new(:uri)
+
+      # The URI this adapter uses for establishing a connection
+      #
+      # @return [Addressable::URI]
+      #
+      # @api private
+      attr_reader :uri
+
+      # Wrap the given +relation+ with a gateway
+      #
+      # @param [Axiom::Relation] relation
+      #   the relation to wrap with a gateway
+      #
+      # @return [Axiom::Relation::Gateway]
+      #
+      # @api private
+      def gateway(relation)
+        Axiom::Relation::Gateway.new(self, relation)
+      end
+
+    end # class DataObjects
+  end # module Adapter
+end # module Axiom