rom 0.4.2 → 0.5.0

data/lib/rom/boot/command_dsl.rb

@@ -1,48 +0,0 @@
-require 'rom/mapper_builder'
-
-module ROM
-
-  class CommandDSL
-    attr_reader :commands
-
-    class CommandDefinition
-      attr_reader :options
-
-      def initialize(options, &block)
-        @options = options
-        instance_exec(&block) if block
-      end
-
-      def to_h
-        options
-      end
-
-      def type
-        options[:type]
-      end
-
-      def method_missing(name, *args, &block)
-        if args.size == 1
-          options[name] = args.first
-        else
-          super
-        end
-      end
-    end
-
-    def initialize
-      @commands = {}
-    end
-
-    def call
-      commands
-    end
-
-    def define(name, options = {}, &block)
-      commands[name] = CommandDefinition.new(options, &block)
-      self
-    end
-
-  end
-
-end

data/lib/rom/boot/dsl.rb

@@ -1,37 +0,0 @@
-require 'rom/boot/schema_dsl'
-require 'rom/boot/mapper_dsl'
-require 'rom/boot/command_dsl'
-
-module ROM
-  class Boot
-
-    class DSL
-      attr_reader :env
-
-      def initialize(env)
-        @env = env
-        @schema = {}
-      end
-
-      def schema(&block)
-        dsl = SchemaDSL.new(env, @schema)
-        dsl.instance_exec(&block)
-        dsl.call
-      end
-
-      def mappers(&block)
-        dsl = MapperDSL.new
-        dsl.instance_exec(&block)
-        dsl.call
-      end
-
-      def commands(&block)
-        dsl = CommandDSL.new
-        dsl.instance_exec(&block)
-        dsl.call
-      end
-
-    end
-
-  end
-end

data/lib/rom/boot/mapper_dsl.rb

@@ -1,23 +0,0 @@
-require 'rom/mapper_builder'
-
-module ROM
-
-  class MapperDSL
-    attr_reader :mappers
-
-    def initialize
-      @mappers = []
-    end
-
-    def call
-      mappers
-    end
-
-    def define(name, options = {}, &block)
-      mappers << [name, options, block]
-      self
-    end
-
-  end
-
-end

data/lib/rom/boot/schema_dsl.rb

@@ -1,27 +0,0 @@
-require 'rom/boot/base_relation_dsl'
-
-module ROM
-  class Boot
-
-    class SchemaDSL
-      attr_reader :env, :schema
-
-      def initialize(env, schema = {})
-        @env = env
-        @schema = schema
-      end
-
-      def base_relation(name, &block)
-        dsl = BaseRelationDSL.new(env, name)
-        definition = dsl.call(&block)
-        (schema[dsl.repository] ||= []) << definition
-      end
-
-      def call
-        schema
-      end
-
-    end
-
-  end
-end

data/lib/rom/ra.rb

@@ -1,172 +0,0 @@
-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
-
-    # 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 : [self, 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)
-      ra_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)
-      ra_with_options(*args) { |relation, options|
-        Operation::Wrap.new(relation, options)
-      }
-    end
-
-    private
-
-    # @api private
-    def ra_with_options(*args)
-      relation =
-        if args.size > 1
-          args.first
-        else
-          self
-        end
-
-      options = args.last
-
-      yield(relation, options)
-    end
-
-  end
-
-end

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

@@ -1,47 +0,0 @@
-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
-
-          result = relation.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

@@ -1,39 +0,0 @@
-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 = left.each_with_object({}) { |tuple, h|
-            others = right.find_all { |t| (tuple.to_a & t.to_a).any? }
-            (h[tuple] ||= []).concat(others)
-          }
-
-          tuples = left.map { |tuple|
-            join_map[tuple].map { |other| tuple.merge(other) }
-          }.flatten
-
-          tuples.each(&block)
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-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.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