rom 0.4.2 → 0.5.0

data/lib/rom/config.rb

@@ -0,0 +1,70 @@
+module ROM
+  # Helper class used by ROM internally to deal with various configuration hashes
+  #
+  # @private
+  class Config
+    BASE_OPTIONS = [
+      :adapter,
+      :database,
+      :password,
+      :username,
+      :hostname,
+      :root
+    ].freeze
+
+    # Builds a configuration hash from a flat database config hash or a string
+    #
+    # This is used to support typical database.yml-complaint configs. It also
+    # uses adapter interface for things that are adapter-specific like handling
+    # schema naming.
+    #
+    # @param [Hash,String]
+    #
+    # @return [Hash]
+    #
+    # @api private
+    def self.build(config, options = {})
+      return config_hash(config, options) if config.is_a?(String)
+
+      return config unless config[:database]
+
+      root = config[:root]
+
+      raw_scheme = config[:adapter]
+      database = config[:database]
+      password = config.fetch(:password) { '' }
+      username = config[:username]
+      hostname = config.fetch(:hostname) { 'localhost' }
+
+      adapter = Adapter[raw_scheme]
+      scheme = adapter.normalize_scheme(raw_scheme)
+
+      path =
+        if adapter.database_file?(scheme)
+          [root, database].compact.join('/')
+        else
+          db_path = [hostname, database].join('/')
+
+          if username && password
+            [[username, password].join(':'), db_path].join('@')
+          else
+            db_path
+          end
+        end
+
+      other_keys = config.keys - BASE_OPTIONS
+      options = Hash[other_keys.zip(config.values_at(*other_keys))]
+
+      config_hash("#{scheme}://#{path}", options)
+    end
+
+    # @api private
+    def self.config_hash(uri, options = {})
+      if options.any?
+        { default: { uri: uri, options: options } }
+      else
+        { default: uri }
+      end
+    end
+  end
+end

data/lib/rom/env.rb

@@ -1,11 +1,12 @@
 module ROM
-
   # Exposes defined repositories, schema, relations and mappers
   #
   # @api public
   class Env
     include Adamantium::Flat
-    include Equalizer.new(:repositories, :schema, :relations, :mappers, :commands)
+    include Equalizer.new(
+      :repositories, :schema, :relations, :mappers, :commands
+    )
 
     attr_reader :repositories, :schema, :relations, :mappers, :commands
 
@@ -40,6 +41,10 @@ module ROM
       commands[name]
     end
 
+    # Return repository identified by its name
+    #
+    # @return [Repository]
+    #
     # @api private
     def [](name)
       repositories.fetch(name)
@@ -52,6 +57,10 @@ module ROM
 
     private
 
+    # Return repository if the method matches repository name
+    #
+    # @return [Repository]
+    #
     # @api private
     def method_missing(name, *args, &block)
       if repositories.key?(name)
@@ -61,5 +70,4 @@ module ROM
       end
     end
   end
-
 end

data/lib/rom/global.rb

@@ -0,0 +1,107 @@
+module ROM
+  # Globally accessible public interface exposed via ROM module
+  #
+  # @public
+  module Global
+    # Starts the setup process for schema, relations, mappers and commands
+    #
+    # @example
+    #
+    #   ROM.setup('sqlite::memory')
+    #
+    #   ROM.relation(:users) do
+    #     # ...
+    #   end
+    #
+    #   ROM.mappers do
+    #     define(:users) do
+    #       # ...
+    #     end
+    #   end
+    #
+    #   ROM.commands(:users) do
+    #     define(:create) do
+    #       # ...
+    #     end
+    #   end
+    #
+    #   ROM.finalize # builds the env
+    #   ROM.env # returns the env registry
+    #
+    # @param [Hash] options repository URIs
+    #
+    # @return [Setup] boot object
+    #
+    # @api public
+    def setup(*args, &block)
+      config = Config.build(*args)
+
+      adapters = config.each_with_object({}) do |(name, uri_or_opts), hash|
+        uri, opts =
+          if uri_or_opts.is_a?(Hash)
+            uri_or_opts.values_at(:uri, :options)
+          else
+            [uri_or_opts, {}]
+          end
+
+        hash[name] = Adapter.setup(uri, opts)
+      end
+
+      repositories = adapters.each_with_object({}) do |(name, adapter), hash|
+        hash[name] = Repository.new(adapter)
+      end
+
+      boot = Setup.new(repositories)
+
+      if block
+        boot.instance_exec(&block)
+        boot.finalize
+      else
+        @boot = boot
+      end
+    end
+
+    # @see ROM::Setup#schema
+    #
+    # @api public
+    def schema(&block)
+      boot.schema(&block)
+    end
+
+    # @see ROM::Setup#relation
+    #
+    # @api public
+    def relation(*args, &block)
+      boot.relation(*args, &block)
+    end
+
+    # @api public
+    def commands(*args, &block)
+      boot.commands(*args, &block)
+    end
+
+    # @api public
+    def mappers(*args, &block)
+      boot.mappers(*args, &block)
+    end
+
+    # @api public
+    def env
+      @env
+    end
+
+    # @api public
+    def finalize
+      @env = boot.finalize
+      @boot = nil
+      self
+    end
+
+    private
+
+    # @api private
+    def boot
+      @boot
+    end
+  end
+end

data/lib/rom/header.rb

@@ -1,123 +1,156 @@
-module ROM
+require 'rom/header/attribute'
 
-  # @api private
+module ROM
+  # Header provides information about data mapping of a specific relation
+  #
+  # Processors use headers to build objects that process raw relations that go
+  # through mappers.
+  #
+  # @private
   class Header
     include Enumerable
-    include Equalizer.new(:attributes)
+    include Equalizer.new(:attributes, :model)
 
+    # @api private
     attr_reader :attributes
 
-    class Attribute
-      include Equalizer.new(:name, :key, :type)
-
-      attr_reader :name, :key, :meta
-
-      class Embedded < Attribute
-        include Equalizer.new(:name, :type, :model, :header)
-
-        def model
-          meta[:model]
-        end
-
-        def header
-          meta.fetch(:header)
-        end
-
-        def mapping
-          header.mapping
-        end
-
-        def embedded?
-          true
-        end
-
-      end
-
-      def self.[](type)
-        if type == Array || type == Hash
-          Embedded
-        else
-          self
-        end
-      end
-
-      def self.coerce(input)
-        if input.kind_of?(self)
-          input
-        else
-          name = input[0]
-          meta = (input[1] || {}).dup
-
-          meta[:type] ||= Object
-
-          if meta.key?(:header)
-            meta[:header] = Header.coerce(meta[:header])
-          end
-
-          self[meta[:type]].new(name, meta)
-        end
-      end
-
-      def initialize(name, meta = {})
-        @name = name
-        @meta = meta
-        @key = meta.fetch(:from) { name }
-      end
-
-      def type
-        meta.fetch(:type)
-      end
-
-      def aliased?
-        key != name
-      end
-
-      def embedded?
-        false
-      end
-
-      def mapping
-        [key, name]
-      end
-    end
-
-    def self.coerce(input)
-      if input.kind_of?(self)
+    # @return [Class] optional model associated with a header
+    #
+    # @api private
+    attr_reader :model
+
+    # @return [Hash] attribute key/name mapping for all primitive attributes
+    #
+    # @api private
+    attr_reader :mapping
+
+    # @return [Array] all attribute keys that are in a tuple
+    #
+    # @api private
+    attr_reader :tuple_keys
+
+    # Coerce array with attribute definitions into a header object
+    #
+    # @param [Array<Array>] attribute name/option pairs
+    #
+    # @param [Class] optional model
+    #
+    # @return [Header]
+    #
+    # @api private
+    def self.coerce(input, model = nil)
+      if input.instance_of?(self)
         input
       else
         attributes = input.each_with_object({}) { |pair, h|
           h[pair.first] = Attribute.coerce(pair)
         }
 
-        new(attributes)
+        new(attributes, model)
       end
     end
 
-    def initialize(attributes)
+    # @api private
+    def initialize(attributes, model = nil)
       @attributes = attributes
+      @model = model
+      initialize_mapping
+      initialize_tuple_keys
     end
 
+    # Iterate over attributes
+    #
+    # @yield [Attribute]
+    #
+    # @api private
     def each(&block)
-      return to_enum unless block
       attributes.values.each(&block)
     end
 
+    # Return if there are any aliased attributes
+    #
+    # @api private
+    def aliased?
+      any?(&:aliased?)
+    end
+
+    # Return attribute keys
+    #
+    # An attribute key corresponds to tuple attribute names
+    #
+    # @api private
     def keys
       attributes.keys
     end
 
-    def mapping
-      Hash[select { |a| !a.embedded? }.map(&:mapping)]
+    # Return attribute identified by its name
+    #
+    # @return [Attribute]
+    #
+    # @api private
+    def [](name)
+      attributes.fetch(name)
     end
 
-    def values
-      attributes.values
+    # Return all Group attributes
+    #
+    # @return [Array<Group>]
+    #
+    # @api private
+    def groups
+      by_type(Group)
     end
 
-    def [](name)
-      attributes.fetch(name)
+    # Return all Wrap attributes
+    #
+    # @return [Array<Wrap>]
+    #
+    # @api private
+    def wraps
+      by_type(Wrap)
     end
 
-  end
+    # Return all primitive attributes (no Group and Wrap)
+    #
+    # @return [Array<Attribute>]
+    #
+    # @api private
+    def primitives
+      to_a - non_primitives
+    end
+
+    # Return all non-primitive attributes (only Group and Wrap types)
+    #
+    # @return [Array<Group,Wrap>]
+    #
+    # @api private
+    def non_primitives
+      groups + wraps
+    end
+
+    private
 
+    # Find all attribute matching specific attribute class (not kind)
+    #
+    # @return [Array<Attribute>]
+    #
+    # @api private
+    def by_type(*types)
+      select { |attribute| types.include?(attribute.class) }
+    end
+
+    # Set mapping hash from primitive attributes
+    #
+    # @api private
+    def initialize_mapping
+      @mapping = primitives.map(&:mapping).reduce(:merge) || {}
+    end
+
+    # Set all tuple keys from all attributes going deep into Wrap and Group too
+    #
+    # @api private
+    def initialize_tuple_keys
+      @tuple_keys = mapping.keys + non_primitives.map(&:tuple_keys).flatten
+    end
+  end
 end