rom 0.5.0 → 0.6.0.beta1

data/lib/rom/adapter.rb

@@ -1,191 +0,0 @@
-require 'addressable/uri'
-
-module ROM
-  # Abstract adapter class
-  #
-  # @api public
-  class Adapter
-    include Equalizer.new(:connection)
-
-    # Return connection URI associated with the adapter
-    #
-    # @return [String]
-    #
-    # @api public
-    attr_reader :uri
-
-    # Return connection object
-    #
-    # @return [Object] type varies depending on the adapter
-    #
-    # @api public
-    attr_reader :connection
-
-    # Additional options hash
-    #
-    # @return [Hash]
-    #
-    # @api public
-    attr_reader :options
-
-    # @api private
-    def self.inherited(adapter)
-      Adapter.adapters.unshift(adapter)
-    end
-
-    # @api private
-    def self.adapters
-      @_adapters ||= []
-    end
-
-    # Setup an adapter instance with the given connection URI
-    #
-    # @example
-    #
-    #   Adapter = Class.new(ROM::Adapter)
-    #
-    #   adapter = Adapter.new('mysql://localhost/test')
-    #
-    #   adapter.uri.scheme # => 'mysql'
-    #   adapter.uri.host # => 'localhost'
-    #   adapter.uri.path # => '/test'
-    #
-    # @param [String] uri_string
-    #
-    # @return [Adapter]
-    #
-    # @api public
-    def self.setup(uri_string, options = {})
-      uri = Addressable::URI.parse(uri_string)
-      adapter = self[uri.scheme]
-
-      unless adapter
-        raise ArgumentError, "#{uri_string.inspect} uri is not supported"
-      end
-
-      adapter.new(uri, options)
-    end
-
-    # Register adapter class
-    #
-    # @example
-    #
-    #   Adapter = Class.new(ROM::Adapter) {
-    #     def self.schemes
-    #       [:super_db]
-    #     end
-    #   }
-    #
-    #   ROM::Adapter.register(Adapter)
-    #   ROM::Adapter[:super_db] # => Adapter
-    #
-    # @return [Array] registered adapters
-    #
-    # @api public
-    def self.register(_adapter)
-      warn "Adapter.register is no longer needed [#{caller[0]}"
-    end
-
-    # Return adapter class for the given scheme
-    #
-    # @see Adapter.register
-    #
-    # @return [Class] adapter class
-    #
-    # @api public
-    def self.[](scheme)
-      adapters.detect { |adapter| adapter.schemes.include?(scheme.to_sym) }
-    end
-
-    # Hook for adapters to normalize scheme name
-    #
-    # @api private
-    def self.normalize_scheme(scheme)
-      scheme
-    end
-
-    # @api private
-    def self.database_file?(_scheme)
-      false
-    end
-
-    # @api private
-    def initialize(uri, options = {})
-      @uri = uri
-      @options = options
-    end
-
-    # Extension hook for adding adapter-specific behavior to a relation class
-    #
-    # @param [Class] klass Relation class generated by ROM
-    #
-    # @return [Class] extended relation class
-    #
-    # @api public
-    def extend_relation_class(klass)
-      klass
-    end
-
-    # Extension hook for adding adapter-specific behavior to a relation instance
-    #
-    # @param [Relation] relation
-    #
-    # @return [Relation] extended relation instance
-    #
-    # @api public
-    def extend_relation_instance(relation)
-      relation
-    end
-
-    # Builds a command
-    #
-    # @param [Symbol] name of the command
-    # @param [Relation] relation used by the command
-    # @param [CommandDSL::Definition] command definition object
-    #
-    # @return [Object] created command instance
-    #
-    # @api public
-    def command(name, relation, definition)
-      type = definition.type || name
-
-      klass =
-        case type
-        when :create then command_namespace.const_get(:Create)
-        when :update then command_namespace.const_get(:Update)
-        when :delete then command_namespace.const_get(:Delete)
-        else
-          raise ArgumentError, "#{type.inspect} is not a supported command type"
-        end
-
-      klass.new(relation, definition.to_h)
-    end
-
-    # Schema inference hook
-    #
-    # Every adapter that supports schema inference should implement this method
-    #
-    # @return [Array] array with datasets and their names
-    #
-    # @api private
-    def schema
-      []
-    end
-
-    # Disconnect is optional and it's a no-op by default
-    #
-    # @api public
-    def disconnect
-      # noop
-    end
-
-    # Return namespace with adapter-specific command classes
-    #
-    # @return [Module]
-    #
-    # @api private
-    def command_namespace
-      self.class.const_get(:Commands)
-    end
-  end
-end

data/lib/rom/adapter/memory.rb

@@ -1,32 +0,0 @@
-require 'rom/adapter/memory/storage'
-require 'rom/adapter/memory/dataset'
-require 'rom/adapter/memory/commands'
-
-module ROM
-  class Adapter
-    class Memory < Adapter
-      attr_accessor :logger
-
-      def self.schemes
-        [:memory]
-      end
-
-      def initialize(*args)
-        super
-        @connection = Storage.new
-      end
-
-      def dataset(name, header = [])
-        connection.create_dataset(name, header)
-      end
-
-      def dataset?(name)
-        connection.key?(name)
-      end
-
-      def [](name)
-        connection[name]
-      end
-    end
-  end
-end

data/lib/rom/adapter/memory/commands.rb

@@ -1,31 +0,0 @@
-module ROM
-  class Adapter
-    class Memory < Adapter
-      module Commands
-        class Create < ROM::Commands::Create
-          def execute(tuple)
-            attributes = input[tuple]
-            validator.call(attributes)
-            [relation.insert(attributes.to_h).to_a.last]
-          end
-        end
-
-        class Update < ROM::Commands::Update
-          def execute(params)
-            attributes = input[params]
-            validator.call(attributes)
-            relation.map { |tuple| tuple.update(attributes.to_h) }
-          end
-        end
-
-        class Delete < ROM::Commands::Delete
-          def execute
-            tuples = target.to_a
-            tuples.each { |tuple| relation.delete(tuple) }
-            tuples
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rom/adapter/memory/dataset.rb

@@ -1,67 +0,0 @@
-module ROM
-  class Adapter
-    class Memory < Adapter
-      class Dataset
-        include Charlatan.new(:data)
-
-        attr_reader :header
-
-        def initialize(data, header)
-          super
-          @header = header
-        end
-
-        def to_ary
-          data.dup
-        end
-        alias_method :to_a, :to_ary
-
-        def each(&block)
-          return to_enum unless block
-          data.each(&block)
-        end
-
-        def join(*args)
-          left, right = args.size > 1 ? args : [self, args.first]
-
-          join_map = left.to_a.each_with_object({}) { |tuple, h|
-            others = right.to_a.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
-
-          self.class.new(tuples, left.header + right.header)
-        end
-
-        def restrict(criteria = nil)
-          if criteria
-            find_all { |tuple| criteria.all? { |k, v| tuple[k].eql?(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
-          self
-        end
-
-        def delete(tuple)
-          data.delete(tuple)
-          self
-        end
-      end
-    end
-  end
-end

data/lib/rom/adapter/memory/storage.rb

@@ -1,26 +0,0 @@
-module ROM
-  class Adapter
-    class Memory < Adapter
-      class Storage
-        attr_reader :data
-
-        def initialize(*)
-          super
-          @data = {}
-        end
-
-        def [](name)
-          data[name]
-        end
-
-        def create_dataset(name, header)
-          data[name] = Dataset.new([], header)
-        end
-
-        def key?(name)
-          data.key?(name)
-        end
-      end
-    end
-  end
-end

data/lib/rom/commands/with_options.rb

@@ -1,18 +0,0 @@
-module ROM
-  module Commands
-    # Common behavior for Create and Update commands
-    #
-    # TODO: find a better name for this module
-    module WithOptions
-      attr_reader :validator, :input
-
-      # @api private
-      def initialize(relation, options)
-        super
-
-        @validator = options[:validator] || proc {}
-        @input = options[:input] || Hash
-      end
-    end
-  end
-end

data/lib/rom/config.rb

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

@@ -1,52 +0,0 @@
-require 'rom/mapper_builder/model_dsl'
-require 'rom/mapper_builder/mapper_dsl'
-
-module ROM
-  # @api private
-  class MapperBuilder
-    attr_reader :name, :root, :options, :prefix, :symbolize_keys, :dsl
-
-    DEFAULT_PROCESSOR = :transproc
-
-    def initialize(name, root, options = {})
-      @name = name
-      @options = options
-      @root = root
-      @prefix = options[:prefix]
-      @symbolize_keys = options[:symbolize_keys]
-
-      attributes =
-        if options[:inherit_header]
-          root.header.map { |attr| [prefix ? :"#{prefix}_#{attr}" : attr] }
-        else
-          []
-        end
-
-      @dsl = MapperDSL.new(attributes, options)
-
-      @processor = DEFAULT_PROCESSOR
-    end
-
-    def processor(identifier = nil)
-      if identifier
-        @processor = identifier
-      else
-        @processor
-      end
-    end
-
-    def call
-      Mapper.build(dsl.header, processor)
-    end
-
-    private
-
-    def method_missing(name, *args, &block)
-      if dsl.respond_to?(name)
-        dsl.public_send(name, *args, &block)
-      else
-        super
-      end
-    end
-  end
-end