rom 0.9.1 → 1.0.0.beta1

data/lib/rom/commands/lazy/create.rb

@@ -0,0 +1,23 @@
+module ROM
+  module Commands
+    class Lazy
+      class Create < Lazy
+        def call(*args)
+          first = args.first
+          last = args.last
+          size = args.size
+
+          if size > 1 && last.is_a?(Array)
+            last.map.with_index do |parent, index|
+              children = evaluator.call(first, index)
+              command_proc[command, parent, children].call(children, parent)
+            end.reduce(:concat)
+          else
+            input = evaluator.call(first)
+            command.call(input, *args[1..size-1])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/commands/lazy/delete.rb

@@ -0,0 +1,27 @@
+module ROM
+  module Commands
+    class Lazy
+      class Delete < Lazy
+        def call(*args)
+          first = args.first
+          last = args.last
+          size = args.size
+
+          if size > 1 && last.is_a?(Array)
+            raise NotImplementedError
+          else
+            input = evaluator.call(first)
+
+            if input.is_a?(Array)
+              input.map do |item|
+                command_proc[command, *(size > 1 ? [last, item] : [input])].call
+              end
+            else
+              command_proc[command, input].call
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/commands/lazy/update.rb

@@ -0,0 +1,34 @@
+module ROM
+  module Commands
+    class Lazy
+      class Update < Lazy
+        def call(*args)
+          first = args.first
+          last = args.last
+          size = args.size
+
+          if size > 1 && last.is_a?(Array)
+            last.map.with_index do |parent, index|
+              children = evaluator.call(first, index)
+
+              children.map do |child|
+                command_proc[command, parent, child].call(child, parent)
+              end
+            end.reduce(:concat)
+          else
+            input = evaluator.call(first)
+
+            if input.is_a?(Array)
+              input.map.with_index do |item, index|
+                command_proc[command, last, item].call(item, *args[1..size-1])
+              end
+            else
+              command_proc[command, *(size > 1 ? [last, input] : [input])]
+                .call(input, *args[1..size-1])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/commands/result.rb

@@ -24,6 +24,20 @@ module ROM
       end
       alias_method :to_a, :to_ary
 
+      # Return true if command successful
+      #
+      # @api public
+      def success?
+        is_a?(Success)
+      end
+
+      # Return true if command failed
+      #
+      # @api public
+      def failure?
+        is_a?(Failure)
+      end
+
       # Success result has a value and no error
       #
       # @api public

data/lib/rom/commands/update.rb

@@ -1,5 +1,4 @@
 require 'rom/command'
-require 'rom/support/deprecations'
 
 module ROM
   module Commands
@@ -9,14 +8,11 @@ module ROM
     #
     # @abstract
     class Update < Command
-      extend Deprecations
-
       # @see AbstractCommand#call
       def call(*args)
         assert_tuple_count
         super
       end
-      deprecate :set, :call
     end
   end
 end

data/lib/rom/configuration.rb

@@ -0,0 +1,86 @@
+require 'rom/environment'
+require 'rom/setup'
+
+module ROM
+  class Configuration
+    extend Forwardable
+
+    NoDefaultAdapterError = Class.new(StandardError)
+
+    attr_reader :environment, :setup
+
+    def_delegators :@setup, :register_relation, :register_command, :register_mapper,
+                            :relation_classes, :command_classes, :mapper_classes,
+                            :auto_registration
+
+    def_delegators :@environment, :gateways, :gateways_map, :configure, :config
+
+    # @api public
+    def initialize(*args, &block)
+      @environment = Environment.new(*args)
+      @setup = Setup.new
+
+      block.call(self) unless block.nil?
+    end
+
+    # Apply a plugin to the configuration
+    #
+    # @param [Mixed] The plugin identifier, usually a Symbol
+    # @param [Hash] Plugin options
+    #
+    # @api public
+    def use(plugin, options = {})
+      if plugin.is_a?(Array)
+        plugin.each { |p| use(p) }
+      elsif plugin.is_a?(Hash)
+        plugin.to_a.each { |p| use(*p) }
+      else
+        ROM.plugin_registry.configuration.fetch(plugin).apply_to(self, options)
+      end
+
+      self
+    end
+
+    # Return gateway identified by name
+    #
+    # @return [Gateway]
+    #
+    # @api private
+    def [](name)
+      gateways.fetch(name)
+    end
+
+    # Returns gateway if method is a name of a registered gateway
+    #
+    # @return [Gateway]
+    #
+    # @api private
+    def method_missing(name, *)
+      gateways.fetch(name) { super }
+    end
+
+    # Hook for respond_to? used internally
+    #
+    # @api private
+    def respond_to?(name, include_all=false)
+      gateways.has_key?(name) || super
+    end
+
+    # @api private
+    def default_gateway
+      @default_gateway ||= gateways[:default]
+    end
+
+    # @api private
+    def adapter_for_gateway(gateway)
+      ROM.adapters.select do |key, value|
+        value.const_defined?(:Gateway) && gateway.kind_of?(value.const_get(:Gateway))
+      end.keys.first
+    end
+
+    # @api private
+    def default_adapter
+      @default_adapter ||= adapter_for_gateway(default_gateway) || ROM.adapters.keys.first
+    end
+  end
+end

data/lib/rom/{setup_dsl/setup.rb → configuration_dsl.rb}

@@ -1,13 +1,14 @@
-require 'rom/setup_dsl/relation'
+require 'rom/support/constants'
 
-require 'rom/setup_dsl/mapper_dsl'
-require 'rom/setup_dsl/command_dsl'
+require 'rom/configuration_dsl/relation'
+require 'rom/configuration_dsl/mapper_dsl'
+require 'rom/configuration_dsl/command_dsl'
 
 module ROM
-  # This extends Setup class with the DSL methods
+  # This extends Configuration class with the DSL methods
   #
   # @api public
-  class Setup
+  module ConfigurationDSL
     # Relation definition DSL
     #
     # @example
@@ -24,6 +25,7 @@ module ROM
       klass = Relation.build_class(name, klass_opts)
       klass.register_as(name)
       klass.class_eval(&block) if block
+      register_relation(klass)
       klass
     end
 
@@ -43,7 +45,7 @@ module ROM
     #
     # @api public
     def mappers(&block)
-      MapperDSL.new(self, &block)
+      register_mapper(*MapperDSL.new(self, mapper_classes, block).mapper_classes)
     end
 
     # Command definition DSL
@@ -70,7 +72,7 @@ module ROM
     #
     # @api public
     def commands(name, &block)
-      CommandDSL.new(name, default_adapter, &block)
+      register_command(*CommandDSL.new(name, default_adapter, &block).command_classes)
     end
   end
 end

data/lib/rom/configuration_dsl/command.rb

@@ -0,0 +1,43 @@
+require 'rom/support/constants'
+
+require 'rom/support/inflector'
+require 'rom/support/class_builder'
+
+module ROM
+  module ConfigurationDSL
+    # Setup DSL-specific command extensions
+    #
+    # @private
+    class Command
+      # Generate a command subclass
+      #
+      # This is used by Setup#commands DSL and its `define` block
+      #
+      # @api private
+      def self.build_class(name, relation, options = EMPTY_HASH, &block)
+        type = options.fetch(:type) { name }
+        command_type = Inflector.classify(type)
+        adapter = options.fetch(:adapter)
+        parent = ROM::Command.adapter_namespace(adapter).const_get(command_type)
+        class_name = generate_class_name(adapter, command_type, relation)
+
+        ClassBuilder.new(name: class_name, parent: parent).call do |klass|
+          klass.register_as(name)
+          klass.relation(relation)
+          klass.class_eval(&block) if block
+        end
+      end
+
+      # Create a command subclass name based on adapter, type and relation
+      #
+      # @api private
+      def self.generate_class_name(adapter, command_type, relation)
+        pieces = ['ROM']
+        pieces << Inflector.classify(adapter)
+        pieces << 'Commands'
+        pieces << "#{command_type}[#{Inflector.classify(relation)}s]"
+        pieces.join('::')
+      end
+    end
+  end
+end

data/lib/rom/{setup_dsl → configuration_dsl}/command_dsl.rb

@@ -1,17 +1,18 @@
-require 'rom/setup_dsl/command'
+require 'rom/configuration_dsl/command'
 
 module ROM
-  class Setup
+  module ConfigurationDSL
     # Command `define` DSL used by Setup#commands
     #
     # @private
     class CommandDSL
-      attr_reader :relation, :adapter
+      attr_reader :relation, :adapter, :command_classes
 
       # @api private
       def initialize(relation, adapter = nil, &block)
         @relation = relation
         @adapter = adapter
+        @command_classes = []
         instance_exec(&block)
       end
 
@@ -25,7 +26,7 @@ module ROM
       #
       # @api public
       def define(name, options = EMPTY_HASH, &block)
-        Command.build_class(
+        @command_classes << Command.build_class(
           name, relation, { adapter: adapter }.merge(options), &block
         )
       end

data/lib/rom/configuration_dsl/mapper.rb

@@ -0,0 +1,37 @@
+require 'rom/support/constants'
+require 'rom/support/class_builder'
+
+module ROM
+  module ConfigurationDSL
+    # Setup DSL-specific mapper extensions
+    #
+    # @private
+    class Mapper
+      # Generate a mapper subclass
+      #
+      # This is used by Setup#mappers DSL
+      #
+      # @api private
+      def self.build_class(name, mapper_registry, options = EMPTY_HASH, &block)
+        class_name = "ROM::Mapper[#{name}]"
+
+        parent = options[:parent]
+        inherit_header = options.fetch(:inherit_header) { ROM::Mapper.inherit_header }
+
+        parent_class =
+          if parent
+            mapper_registry.detect { |klass| klass.relation == parent }
+          else
+            ROM::Mapper
+          end
+
+        ClassBuilder.new(name: class_name, parent: parent_class).call do |klass|
+          klass.relation(name)
+          klass.inherit_header(inherit_header)
+
+          klass.class_eval(&block) if block
+        end
+      end
+    end
+  end
+end

data/lib/rom/{setup_dsl → configuration_dsl}/mapper_dsl.rb

@@ -1,17 +1,23 @@
-require 'rom/setup_dsl/mapper'
+require 'rom/support/constants'
+require 'rom/configuration_dsl/mapper'
 
 module ROM
-  class Setup
+  module ConfigurationDSL
     # Mapper definition DSL used by Setup DSL
     #
     # @private
     class MapperDSL
-      attr_reader :registry
+      attr_reader :registry, :mapper_classes, :mapper_classes
 
       # @api private
-      def initialize(registry, &block)
+      def initialize(registry, mapper_classes, block)
         @registry = registry
+        @mapper_classes = mapper_classes
+        @defined_mappers = []
+
         instance_exec(&block)
+
+        @mapper_classes = @defined_mappers
       end
 
       # Define a mapper class
@@ -23,7 +29,7 @@ module ROM
       #
       # @api public
       def define(name, options = EMPTY_HASH, &block)
-        Mapper.build_class(name, options, &block)
+        @defined_mappers << Mapper.build_class(name, (@mapper_classes + @defined_mappers), options, &block)
         self
       end
 

data/lib/rom/configuration_dsl/relation.rb

@@ -0,0 +1,26 @@
+require 'rom/support/constants'
+require 'rom/support/class_builder'
+
+module ROM
+  module ConfigurationDSL
+    # Setup DSL-specific relation extensions
+    #
+    # @private
+    class Relation
+      # Generate a relation subclass
+      #
+      # This is used by Setup#relation DSL
+      #
+      # @api private
+      def self.build_class(name, options = EMPTY_HASH)
+        class_name = "ROM::Relation[#{Inflector.camelize(name)}]"
+        adapter = options.fetch(:adapter)
+
+        ClassBuilder.new(name: class_name, parent: ROM::Relation[adapter]).call do |klass|
+          klass.gateway(options.fetch(:gateway, :default))
+          klass.dataset(name)
+        end
+      end
+    end
+  end
+end

data/lib/rom/configuration_plugin.rb

@@ -0,0 +1,17 @@
+require 'rom/plugin_base'
+
+module ROM
+  # ConfigurationPlugin is a simple object used to store configuration plugin configurations
+  #
+  # @private
+  class ConfigurationPlugin < PluginBase
+    # Apply this plugin to the provided configuration
+    #
+    # @param [ROM::Configuration] configuration
+    #
+    # @api private
+    def apply_to(configuration, options = {})
+      mod.apply(configuration, options)
+    end
+  end
+end