rom 0.2.0 → 0.3.0

data/lib/rom/model_builder.rb

@@ -0,0 +1,58 @@
+module ROM
+
+  # @api private
+  class ModelBuilder
+    attr_reader :options, :const_name, :klass
+
+    def self.[](type)
+      case type
+      when :poro then PORO
+      else
+        raise ArgumentError, "#{type.inspect} is not a supported model type"
+      end
+    end
+
+    def self.call(*args)
+      new(*args).call
+    end
+
+    def initialize(options)
+      @options = options
+      @const_name = options[:name]
+    end
+
+    def define_const
+      Object.const_set(const_name, klass)
+    end
+
+    def call(header)
+      define_class(header)
+      define_const if const_name
+    end
+
+    class PORO < ModelBuilder
+
+      def define_class(header)
+        @klass = Class.new
+
+        attributes = header.keys
+
+        @klass.send(:attr_accessor, *attributes)
+
+        ivar_list = attributes.map { |name| "@#{name}" }.join(", ")
+        sym_list = attributes.map { |name| ":#{name}" }.join(", ")
+
+        @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def initialize(params)
+        #{ivar_list} = params.values_at(#{sym_list})
+            end
+        RUBY
+
+        self
+      end
+
+    end
+
+  end
+
+end

data/lib/rom/ra.rb

@@ -0,0 +1,196 @@
+require 'rom/ra/operation/join'
+require 'rom/ra/operation/group'
+require 'rom/ra/operation/wrap'
+
+module ROM
+
+  # Experimental DSL for in-memory relational operations
+  #
+  # @api private
+  module RA
+
+    # Exposes in-memory relational operations
+    #
+    # See examples for join, group and wrap operations
+    #
+    # @api public
+    def in_memory(&block)
+      DSL.new(self).instance_exec(&block)
+    end
+
+    class DSL
+      include Concord.new(:relation)
+
+      # Join two relations in-memory using natural-join
+      #
+      # @example
+      #
+      #   require 'rom'
+      #   require 'rom/adapter/memory'
+      #
+      #   setup = ROM.setup(memory: 'memory://localhost')
+      #
+      #   setup.schema do
+      #     base_relation(:users) do
+      #       repository :memory
+      #
+      #       attribute :user_id
+      #       attribute :name
+      #     end
+      #
+      #     base_relation(:tasks) do
+      #       repository :memory
+      #
+      #       attribute :user_id
+      #       attribute :title
+      #     end
+      #   end
+      #
+      #   setup.relation(:tasks)
+      #
+      #   setup.relation(:users) do
+      #     def with_tasks
+      #       in_memory { join(tasks) }
+      #     end
+      #   end
+      #
+      #   rom.relations.users.insert user_id: 1, name: 'Piotr'
+      #   rom.relations.tasks.insert user_id: 1, title: 'Relax'
+      #
+      #   rom.relations.users.with_tasks.to_a
+      #   => [{:user_id=>1, :name=>"Piotr", :title=>"Relax"}]
+      #
+      # @api public
+      def join(*args)
+        left, right = args.size > 1 ? args : [relation, args.first]
+        Operation::Join.new(left, right)
+      end
+
+      # Groups two relations in-memory using group operation
+      #
+      # @example
+      #
+      #   require 'rom'
+      #   require 'rom/adapter/memory'
+      #
+      #   setup = ROM.setup(memory: 'memory://localhost')
+      #
+      #   setup.schema do
+      #     base_relation(:users) do
+      #       repository :memory
+      #
+      #       attribute :user_id
+      #       attribute :name
+      #     end
+      #
+      #     base_relation(:tasks) do
+      #       repository :memory
+      #
+      #       attribute :user_id
+      #       attribute :title
+      #     end
+      #   end
+      #
+      #   setup.relation(:tasks)
+      #
+      #   setup.relation(:users) do
+      #     def with_tasks
+      #       in_memory { group(join(tasks), tasks: [:title]) }
+      #     end
+      #   end
+      #
+      #   rom.relations.users.insert user_id: 1, name: 'Piotr'
+      #   rom.relations.tasks.insert user_id: 1, title: 'Work'
+      #   rom.relations.tasks.insert user_id: 1, title: 'Relax'
+      #
+      #   rom.relations.users.with_tasks.to_a
+      #   => [{:user_id=>1, :name=>"Piotr", tasks: [{:title=>"Relax"}, {:title=>"Work"}]}]
+      #
+      # @api public
+      def group(*args)
+        with_options(*args) { |relation, options|
+          Operation::Group.new(relation, options)
+        }
+      end
+
+      # Embed one relation in another in-memory using wrap operation
+      #
+      # @example
+      #
+      #   require 'rom'
+      #   require 'rom/adapter/memory'
+      #
+      #   setup = ROM.setup(memory: 'memory://localhost')
+      #
+      #   setup.schema do
+      #     base_relation(:users) do
+      #       repository :memory
+      #
+      #       attribute :user_id
+      #       attribute :name
+      #     end
+      #
+      #     base_relation(:addresses) do
+      #       repository :memory
+      #
+      #       attribute :user_id
+      #       attribute :street
+      #       attribute :zipcode
+      #       attribute :city
+      #     end
+      #   end
+      #
+      #   setup.relation(:addresses)
+      #
+      #   setup.relation(:users) do
+      #     def with_address
+      #       in_memory { wrap(join(addresses), address: [:street, :zipcode, :city]) }
+      #     end
+      #   end
+      #
+      #   rom = setup.finalize
+      #
+      #   rom.relations.users.insert user_id: 1, name: 'Piotr'
+      #   rom.relations.addresses.insert user_id: 1, street: 'Street 1', zipcode: '123', city: 'Kraków'
+      #
+      #   rom.relations.users.with_address.to_a
+      #   => [{:user_id=>1, :name=>"Piotr", :address=>{:street=>"Street 1", :zipcode=>"123", :city=>"Kraków"}}]
+      #
+      # @api public
+      def wrap(*args)
+        with_options(*args) { |relation, options|
+          Operation::Wrap.new(relation, options)
+        }
+      end
+
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        relation.respond_to?(name) || super
+      end
+
+      private
+
+      # @api private
+      def with_options(*args)
+        relation =
+          if args.size > 1
+            args.first
+          else
+            self.relation
+          end
+
+        options = args.last
+
+        yield(relation, options)
+      end
+
+      # @api private
+      def method_missing(name, *args, &block)
+        relation.public_send(name, *args, &block)
+      end
+
+    end
+
+  end
+
+end

data/lib/rom/ra/operation/group.rb

@@ -0,0 +1,49 @@
+module ROM
+  module RA
+    class Operation
+
+      class Group
+        # FIXME: only reading from a relation should be allowed here so this is
+        #       obviously too much
+        include Charlatan.new(:relation)
+
+        include Enumerable
+
+        attr_reader :options, :header
+
+        def initialize(relation, options)
+          super
+          @options = options
+          @header = relation.header + options.keys - attribute_names
+        end
+
+        def each(&block)
+          return to_enum unless block
+
+          tuples = relation.to_a
+
+          result = tuples.each_with_object({}) do |tuple, grouped|
+            left = tuple.reject { |k,_| attribute_names.include?(k) }
+            right = tuple.reject { |k,_| !attribute_names.include?(k) }
+
+            grouped[left] ||= {}
+            grouped[left][key] ||= []
+            grouped[left][key] << right if right.values.any?
+          end
+
+          result.map { |k,v| k.merge(v) }.each(&block)
+        end
+
+        def key
+          options.keys.first
+        end
+
+        def attribute_names
+          options.values.first
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rom/ra/operation/join.rb

@@ -0,0 +1,41 @@
+module ROM
+  module RA
+    class Operation
+
+      class Join
+        include Charlatan.new(:left)
+        include Enumerable
+
+        attr_reader :right
+
+        def initialize(left, right)
+          super
+          @left, @right = left, right
+        end
+
+        def header
+          left.header + right.header
+        end
+
+        def each(&block)
+          return to_enum unless block
+
+          join_map = right.each_with_object({}) { |tuple, h|
+            other = left.detect { |t| (tuple.to_a & t.to_a).any?  }
+            (h[other] ||= []) << tuple if other
+          }
+
+          tuples = left.map { |tuple|
+            others = join_map[tuple]
+            next unless others.any?
+            others.map { |other| tuple.merge(other) }
+          }.flatten
+
+          tuples.each(&block)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rom/ra/operation/wrap.rb

@@ -0,0 +1,45 @@
+module ROM
+  module RA
+    class Operation
+
+      class Wrap
+        # FIXME: only reading from a relation should be allowed here so this is
+        #       obviously too much
+        include Charlatan.new(:relation)
+
+        include Enumerable
+
+        attr_reader :options, :header
+
+        def initialize(relation, options)
+          super
+          @options = options
+          @header = relation.header + options.keys - attribute_names
+        end
+
+        def each(&block)
+          return to_enum unless block
+
+          results = relation.to_a.each_with_object([]) do |tuple, wrapped|
+            result = tuple.reject { |k,_| attribute_names.include?(k) }
+            result[key] = tuple.reject { |k,_| !attribute_names.include?(k) }
+
+            wrapped << result
+          end
+
+          results.each(&block)
+        end
+
+        def key
+          options.keys.first
+        end
+
+        def attribute_names
+          options.values.first
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rom/reader.rb

@@ -0,0 +1,62 @@
+module ROM
+
+  # Exposes mapped tuples via enumerable interface
+  #
+  # See example for each method
+  #
+  # @api public
+  class Reader
+    include Enumerable
+    include Equalizer.new(:path, :relation, :mapper)
+
+    attr_reader :path, :relation, :header, :mappers, :mapper
+
+    # @api private
+    def initialize(path, relation, mappers = {})
+      @path = path.to_s
+      @relation = relation
+      @header = relation.header
+      @mappers = mappers
+
+      names = @path.split('.')
+
+      mapper_key = names.reverse.detect { |name| mappers.key?(name.to_sym) }
+      @mapper = mappers.fetch(mapper_key.to_sym)
+    end
+
+    # Yields tuples mapped to objects
+    #
+    # @example
+    #
+    #   # accessing root relation
+    #   rom.read(:users).each { |user| # ... }
+    #
+    #   # accessing virtual relations
+    #   rom.read(:users).adults.recent.active.each { |user| # ... }
+    #
+    # @api public
+    def each
+      relation.each { |tuple| yield(mapper.load(tuple)) }
+    end
+
+    # @api private
+    def respond_to_missing?(name, include_private = false)
+      relation.respond_to?(name)
+    end
+
+    private
+
+    # @api private
+    def method_missing(name, *args, &block)
+      new_relation = relation.public_send(name, *args, &block)
+
+      splits = path.split('.')
+      splits << name
+      new_path = splits.join('.')
+
+      self.class.new(new_path, new_relation, mappers)
+    end
+
+  end
+
+end