rom 0.2.0 → 0.3.0

data/lib/rom.rb

@@ -1,14 +1,52 @@
-# encoding: utf-8
-
-require 'adamantium'
 require 'concord'
-require 'equalizer'
 require 'charlatan'
-require 'morpher'
-require 'axiom'
-require 'axiom-optimizer'
+require 'inflecto'
+
+require 'rom/version'
+require 'rom/support/registry'
 
-require 'rom/environment'
+require 'rom/header'
 require 'rom/relation'
 require 'rom/mapper'
-require 'rom/session'
+require 'rom/reader'
+
+require 'rom/adapter'
+require 'rom/repository'
+require 'rom/env'
+
+require 'rom/boot'
+
+module ROM
+  EnvAlreadyFinalizedError = Class.new(StandardError)
+
+  Schema = Class.new(Registry)
+  RelationRegistry = Class.new(Registry)
+  ReaderRegistry = Class.new(Registry)
+
+  # Starts the setup process for schema, relations and mappers
+  #
+  # @param [Hash] options repository URIs
+  #
+  # @return [Boot] boot object
+  #
+  # @api public
+  def self.setup(options, &block)
+    adapters = options.each_with_object({}) do |(name, uri), hash|
+      hash[name] = Adapter.setup(uri)
+    end
+
+    repositories = adapters.each_with_object({}) do |(name, adapter), hash|
+      hash[name] = Repository.new(adapter)
+    end
+
+    boot = Boot.new(repositories)
+
+    if block
+      boot.instance_exec(&block)
+      boot.finalize
+    end
+
+    boot
+  end
+
+end

data/lib/rom/adapter.rb

@@ -0,0 +1,52 @@
+require 'addressable/uri'
+
+module ROM
+
+  class Adapter
+    include Equalizer.new(:connection)
+
+    @adapters = []
+
+    attr_reader :uri
+
+    def self.setup(uri_string)
+      uri = Addressable::URI.parse(uri_string)
+
+      unless adapter = self[uri.scheme]
+        raise ArgumentError, "#{uri_string.inspect} uri is not supported"
+      end
+
+      adapter.new(uri)
+    end
+
+    def self.register(adapter)
+      @adapters.unshift adapter
+    end
+
+    def self.[](scheme)
+      @adapters.detect { |adapter| adapter.schemes.include?(scheme.to_sym) }
+    end
+
+    def initialize(uri)
+      @uri = uri
+    end
+
+    def connection
+      raise NotImplementedError, "#{self.class}#connection must be implemented"
+    end
+
+    def extend_relation_class(klass)
+      klass
+    end
+
+    def extend_relation_instance(relation)
+      relation
+    end
+
+    def schema
+      []
+    end
+
+  end
+
+end

data/lib/rom/adapter/memory.rb

@@ -0,0 +1,70 @@
+module ROM
+  class Adapter
+
+    class Memory < Adapter
+      attr_reader :connection
+
+      def self.schemes
+        [:memory]
+      end
+
+      class Dataset
+        include Charlatan.new(:data)
+
+        def each(&block)
+          return to_enum unless block
+          data.each(&block)
+        end
+
+        def restrict(criteria = nil, &block)
+          if criteria
+            find_all { |tuple| criteria.all? { |k, v| tuple[k] == v } }
+          else
+            find_all { |tuple| yield(tuple) }
+          end
+        end
+
+        def project(*names)
+          map { |tuple| tuple.reject { |key,_| names.include?(key) } }
+        end
+
+        def order(*names)
+          sort_by { |tuple| tuple.values_at(*names) }
+        end
+
+        def insert(tuple)
+          data << tuple
+        end
+
+        def header
+          []
+        end
+      end
+
+      class Storage
+        attr_reader :data
+
+        def initialize(*)
+          super
+          @data = {}
+        end
+
+        def [](name)
+          data[name] ||= Dataset.new([])
+        end
+      end
+
+      def initialize(*args)
+        super
+        @connection = Storage.new
+      end
+
+      def [](name)
+        connection[name]
+      end
+
+      Adapter.register(self)
+    end
+
+  end
+end

data/lib/rom/boot.rb

@@ -0,0 +1,158 @@
+require 'rom/boot/dsl'
+require 'rom/relation_builder'
+require 'rom/reader_builder'
+
+module ROM
+
+  # Exposes DSL for defining schema, relations and mappers
+  #
+  # @api public
+  class Boot
+    attr_reader :repositories, :adapter_relation_map, :env
+
+    # @api private
+    def initialize(repositories)
+      @repositories = repositories
+      @schema = {}
+      @relations = {}
+      @mappers = []
+      @adapter_relation_map = {}
+      @env = nil
+    end
+
+    # Schema definition DSL
+    #
+    # @example
+    #
+    #   setup.schema do
+    #     base_relation(:users) do
+    #       repository :sqlite
+    #
+    #       attribute :id
+    #       attribute :name
+    #     end
+    #   end
+    #
+    # @api public
+    def schema(&block)
+      @schema = DSL.new(self).schema(&block)
+    end
+
+    # Relation definition DSL
+    #
+    # @example
+    #
+    #   setup.relation(:users) do
+    #     def names
+    #       project(:name)
+    #     end
+    #   end
+    #
+    # @api public
+    def relation(name, &block)
+      @relations.update(name => block)
+    end
+
+    # Mapper definition DSL
+    #
+    # @example
+    #
+    #   setup.mappers do
+    #     define(:users) do
+    #       model name: 'User'
+    #     end
+    #
+    #     define(:names, parent: :users) do
+    #       exclude :id
+    #     end
+    #   end
+    #
+    # @api public
+    def mappers(&block)
+      @mappers.concat(DSL.new(self).mappers(&block))
+    end
+
+    # Finalize the setup
+    #
+    # @return [Env] frozen env with access to repositories, schema, relations and mappers
+    #
+    # @api public
+    def finalize
+      raise EnvAlreadyFinalizedError if env
+
+      schema = load_schema
+      relations = load_relations(schema)
+      readers = load_readers(relations)
+
+      @env = Env.new(repositories, schema, relations, readers)
+    end
+
+    # @api private
+    def [](name)
+      repositories.fetch(name)
+    end
+
+    # @api private
+    def respond_to_missing?(name, include_context = false)
+      repositories.key?(name)
+    end
+
+    private
+
+    # @api private
+    def method_missing(name, *args)
+      repositories.fetch(name)
+    end
+
+    # @api private
+    def load_schema
+      repositories.values.each do |repo|
+        (@schema[repo] ||= []).concat(repo.schema)
+      end
+
+      base_relations = @schema.each_with_object({}) do |(repo, schema), h|
+        schema.each do |name, dataset, header|
+          adapter_relation_map[name] = repo.adapter
+          h[name] = Relation.new(dataset, header)
+        end
+      end
+
+      Schema.new(base_relations)
+    end
+
+    # @api private
+    def load_relations(schema)
+      builder = RelationBuilder.new(schema)
+
+      relations = @relations.each_with_object({}) do |(name, block), h|
+        adapter = adapter_relation_map[name]
+
+        relation = builder.call(name) { |klass|
+          adapter.extend_relation_class(klass)
+          klass.class_eval(&block) if block
+        }
+
+        adapter.extend_relation_instance(relation)
+
+        h[name] = relation
+      end
+
+      relations.each_value { |relation| relation.class.finalize(relations, relation) }
+
+      RelationRegistry.new(relations)
+    end
+
+    # @api private
+    def load_readers(relations)
+      reader_builder = ReaderBuilder.new(relations)
+
+      readers = @mappers.each_with_object({}) do |(name, options, block), h|
+        h[name] = reader_builder.call(name, options, &block)
+      end
+
+      RelationRegistry.new(readers)
+    end
+
+  end
+
+end

data/lib/rom/boot/base_relation_dsl.rb

@@ -0,0 +1,43 @@
+module ROM
+  class Boot
+
+    class BaseRelationDSL
+      attr_reader :env, :name, :repositories, :attributes, :datasets
+
+      def initialize(env, name)
+        @env = env
+        @name = name
+        @attributes = []
+      end
+
+      def repository(name = nil)
+        if @repository
+          @repository
+        else
+          @repository = env[name]
+        end
+      end
+
+      def attribute(name)
+        attributes << name
+      end
+
+      def call(&block)
+        instance_exec(&block)
+
+        dataset = repository[name]
+
+        header =
+          if attributes.any?
+            attributes
+          else
+            dataset.header
+          end
+
+        [name, repository[name], header]
+      end
+
+    end
+
+  end
+end

data/lib/rom/boot/dsl.rb

@@ -0,0 +1,30 @@
+require 'rom/boot/schema_dsl'
+require 'rom/boot/mapper_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
+
+    end
+
+  end
+end

data/lib/rom/boot/mapper_dsl.rb

@@ -0,0 +1,23 @@
+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/relation_dsl.rb

@@ -0,0 +1,23 @@
+module ROM
+  class Boot
+
+    class RelationDSL
+      attr_reader :schema, :relations
+
+      def initialize(schema, relations)
+        @schema = schema
+        @relations = relations
+      end
+
+      def register(name, &block)
+        relations[name] = [block]
+      end
+
+      def call
+        relations
+      end
+
+    end
+
+  end
+end