rom 0.4.2 → 0.5.0

data/lib/rom/mapper_builder/model_dsl.rb

@@ -0,0 +1,29 @@
+require 'rom/model_builder'
+
+module ROM
+  class MapperBuilder
+    module ModelDSL
+      attr_reader :attributes, :builder, :klass
+
+      DEFAULT_TYPE = :poro
+
+      def model(options = nil)
+        if options.is_a?(Class)
+          @klass = options
+        elsif options
+          type = options.fetch(:type) { DEFAULT_TYPE }
+          @builder = ModelBuilder[type].new(options)
+        end
+
+        build_class unless options
+      end
+
+      private
+
+      def build_class
+        return klass if klass
+        return builder.call(attributes.map(&:first)) if builder
+      end
+    end
+  end
+end

data/lib/rom/mapper_registry.rb

@@ -0,0 +1,21 @@
+module ROM
+  # @private
+  class MapperRegistry < Registry
+    # @api private
+    def []=(name, mapper)
+      elements[name] = mapper
+    end
+
+    # @api private
+    def by_path(path)
+      elements[paths(path).detect { |name| elements.key?(name) }]
+    end
+
+    private
+
+    # @api private
+    def paths(path)
+      path.split('.').map(&:to_sym).reverse
+    end
+  end
+end

data/lib/rom/model_builder.rb

@@ -1,5 +1,4 @@
 module ROM
-
   # @api private
   class ModelBuilder
     attr_reader :options, :const_name, :namespace, :klass
@@ -19,14 +18,15 @@ module ROM
     def initialize(options = {})
       @options = options
 
-      if options[:name]
-        split = options[:name].split('::')
+      name = options[:name]
+      if name
+        parts = name.split('::')
 
-        @const_name = split.last
+        @const_name = parts.pop
 
         @namespace =
-          if split.size > 1
-            Inflecto.constantize((split-[const_name]).join('::'))
+          if parts.any?
+            Inflecto.constantize(parts.join('::'))
           else
             Object
           end
@@ -37,32 +37,26 @@ module ROM
       namespace.const_set(const_name, klass)
     end
 
-    def call(header)
-      define_class(header)
+    def call(attrs)
+      define_class(attrs)
       define_const if const_name
       @klass
     end
 
     class PORO < ModelBuilder
-
-      def define_class(header)
+      def define_class(attrs)
         @klass = Class.new
 
-        attributes = header.keys
-
-        @klass.send(:attr_reader, *attributes)
+        @klass.send(:attr_reader, *attrs)
 
         @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def initialize(params)
-            #{attributes.map { |name| "@#{name} = params[:#{name}]" }.join("\n")}
+            #{attrs.map { |name| "@#{name} = params[:#{name}]" }.join("\n")}
           end
         RUBY
 
         self
       end
-
     end
-
   end
-
 end

data/lib/rom/processor.rb

@@ -0,0 +1,28 @@
+require 'rom/mapper'
+
+module ROM
+  # Abstract processor class
+  #
+  # Every ROM processor should inherit from this class
+  #
+  # @public
+  class Processor
+    # Hook used to auto-register a processor class
+    #
+    # @api private
+    def self.inherited(processor)
+      Mapper.register_processor(processor)
+    end
+
+    # Required interface to be implemented by descendants
+    #
+    # @return [Processor]
+    #
+    # @abstract
+    #
+    # @api private
+    def self.build
+      raise NotImplementedError, "+build+ must be implemented"
+    end
+  end
+end

data/lib/rom/processor/transproc.rb

@@ -0,0 +1,105 @@
+require 'transproc/all'
+
+require 'rom/processor'
+
+module ROM
+  class Processor
+    class Transproc < Processor
+      include ::Transproc::Composer
+
+      attr_reader :header, :model, :mapping, :tuple_proc
+
+      EMPTY_FN = -> tuple { tuple }.freeze
+
+      def self.build(header)
+        new(header).to_transproc
+      end
+
+      def initialize(header)
+        @header = header
+        @model = header.model
+        @mapping = header.mapping
+        initialize_tuple_proc
+      end
+
+      def to_transproc
+        compose(EMPTY_FN) do |ops|
+          ops << header.groups.map { |attr| visit_group(attr, true) }
+          ops << t(:map_array!, tuple_proc) if tuple_proc
+        end
+      end
+
+      private
+
+      def visit(attribute)
+        type = attribute.class.name.split('::').last.downcase
+        send("visit_#{type}", attribute)
+      end
+
+      def visit_attribute(attribute)
+        if attribute.typed?
+          t(:map_key!, attribute.name, t(:"to_#{attribute.type}"))
+        end
+      end
+
+      def visit_hash(attribute)
+        with_tuple_proc(attribute) do |tuple_proc|
+          t(:map_key!, attribute.name, tuple_proc)
+        end
+      end
+
+      def visit_array(attribute)
+        with_tuple_proc(attribute) do |tuple_proc|
+          t(:map_key!, attribute.name, t(:map_array!, tuple_proc))
+        end
+      end
+
+      def visit_wrap(attribute)
+        name = attribute.name
+        keys = attribute.tuple_keys
+
+        compose do |ops|
+          ops << t(:nest!, name, keys)
+          ops << visit_hash(attribute)
+        end
+      end
+
+      def visit_group(attribute, preprocess = false)
+        if preprocess
+          name = attribute.name
+          header = attribute.header
+          keys = attribute.tuple_keys
+
+          other = header.groups
+
+          compose do |ops|
+            ops << t(:group, name, keys)
+
+            ops << other.map { |attr|
+              t(:map_array!, t(:map_key!, name, visit_group(attr, true)))
+            }
+          end
+        else
+          visit_array(attribute)
+        end
+      end
+
+      def initialize_tuple_proc
+        @tuple_proc = compose do |ops|
+          ops << t(:map_hash!, mapping) if header.aliased?
+          ops << header.map { |attr| visit(attr) }
+          ops << t(-> tuple { model.new(tuple) }) if model
+        end
+      end
+
+      def with_tuple_proc(attribute)
+        tuple_proc = new(attribute.header).tuple_proc
+        yield(tuple_proc) if tuple_proc
+      end
+
+      def new(*args)
+        self.class.new(*args)
+      end
+    end
+  end
+end

data/lib/rom/reader.rb

@@ -1,27 +1,92 @@
 module ROM
-
   # Exposes mapped tuples via enumerable interface
   #
   # See example for each method
   #
   # @api public
   class Reader
+    MapperMissingError = Class.new(StandardError)
+
     include Enumerable
     include Equalizer.new(:path, :relation, :mapper)
 
-    attr_reader :path, :relation, :header, :mappers, :mapper
+    # @return [String] access path used to read a relation
+    #
+    # @api private
+    attr_reader :path
+
+    # @return [Relation] relation used by the reader
+    #
+    # @api private
+    attr_reader :relation
+
+    # @return [MapperRegistry] registry of mappers used by the reader
+    #
+    # @api private
+    attr_reader :mappers
+
+    # @return [Mapper] mapper to read the relation
+    #
+    # @api private
+    attr_reader :mapper
+
+    # Build a reader subclass for the relation and instantiate it
+    #
+    # This method defines public methods on the class narrowing down data access
+    # only to the methods exposed by a given relation
+    #
+    # @param [Symbol] name of the root relation
+    # @param [Relation] relation that the reader will use
+    # @param [MapperRegistry] registry of mappers
+    # @param [Array<Symbol>] a list of method names exposed by the relation
+    #
+    # @return [Reader]
+    #
+    # @api private
+    def self.build(name, relation, mappers, method_names = [])
+      klass = Class.new(self)
+
+      klass_name = "#{self.name}[#{Inflecto.camelize(relation.name)}]"
+
+      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.name
+          #{klass_name.inspect}
+        end
+
+        def self.inspect
+          name
+        end
+
+        def self.to_s
+          name
+        end
+      RUBY
+
+      method_names.each do |method_name|
+        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method_name}(*args, &block)
+            new_relation = relation.send(#{method_name.inspect}, *args, &block)
+            self.class.new(
+              new_path(#{method_name.to_s.inspect}), new_relation, mappers
+            )
+          end
+        RUBY
+      end
+
+      klass.new(name, relation, mappers)
+    end
 
     # @api private
     def initialize(path, relation, mappers = {})
       @path = path.to_s
       @relation = relation
       @mappers = mappers
+      @mapper = mappers.by_path(@path) || raise(MapperMissingError, path)
+    end
 
-      names = @path.split('.')
-
-      mapper_key = names.reverse.detect { |name| mappers.key?(name.to_sym) }
-      @mapper = mappers.fetch(mapper_key.to_sym)
-      @header = mapper.header
+    # @api private
+    def header
+      mapper.header
     end
 
     # Yields tuples mapped to objects
@@ -39,24 +104,19 @@ module ROM
       mapper.process(relation) { |tuple| yield(tuple) }
     end
 
-    # @api private
-    def respond_to_missing?(name, include_private = false)
-      relation.respond_to?(name)
-    end
-
     private
 
     # @api private
-    def method_missing(name, *args, &block)
-      new_relation = relation.public_send(name, *args, &block)
-
-      splits = path.split('.')
-      splits << name
-      new_path = splits.join('.')
-
-      self.class.new(new_path, new_relation, mappers)
+    def method_missing(name)
+      raise(
+        NoRelationError,
+        "undefined relation #{name.inspect} within #{path.inspect}"
+      )
     end
 
+    # @api private
+    def new_path(name)
+      path.dup << ".#{name}"
+    end
   end
-
 end

data/lib/rom/reader_builder.rb

@@ -1,5 +1,6 @@
-module ROM
+require 'rom/mapper_registry'
 
+module ROM
   # @api private
   class ReaderBuilder
     DEFAULT_OPTIONS = { inherit_header: true }.freeze
@@ -21,10 +22,20 @@ module ROM
         builder.instance_exec(&block) if block
         mapper = builder.call
 
-        mappers = options[:parent] ? readers.fetch(parent.name).mappers : {}
+        mappers =
+          if options[:parent]
+            readers.fetch(parent.name).mappers
+          else
+            MapperRegistry.new
+          end
 
         mappers[name] = mapper
-        readers[name] = Reader.new(name, parent, mappers) unless options[:parent]
+
+        unless options[:parent]
+          readers[name] = Reader.build(
+            name, parent, mappers, parent.class.relation_methods
+          )
+        end
       end
     end
 
@@ -33,6 +44,5 @@ module ROM
     def with_options(options)
       yield(DEFAULT_OPTIONS.merge(options))
     end
-
   end
 end

data/lib/rom/relation.rb

@@ -1,11 +1,10 @@
 module ROM
-
   # Base relation class
   #
   # Relation is a proxy for the dataset object provided by the adapter, it
   # forwards every method to the dataset that's why "native" interface of the
   # underlying adapter is available in the relation. This interface, however, is
-  # considered to private and should not be used outside of the relation instance.
+  # considered private and should not be used outside of the relation instance.
   #
   # ROM builds sub-classes of this class for every relation defined in the env
   # for easy inspection and extensibility - every adapter can provide extensions
@@ -21,11 +20,24 @@ module ROM
     include Charlatan.new(:dataset)
     include Equalizer.new(:header, :dataset)
 
+    class << self
+      # Relation methods that were defined inside setup.relation DSL
+      #
+      # @return [Array<Symbol>]
+      #
+      # @api private
+      attr_accessor :relation_methods
+    end
+
+    # @return [Array] relation base header
+    #
     # @api private
     attr_reader :header
 
+    # Hook to finalize a relation after its instance was created
+    #
     # @api private
-    def self.finalize(env, relation)
+    def self.finalize(_env, _relation)
       # noop
     end
 
@@ -35,12 +47,14 @@ module ROM
       @header = header.dup.freeze
     end
 
+    # Yield dataset tuples
+    #
+    # @yield [Hash]
+    #
     # @api private
     def each(&block)
       return to_enum unless block
       dataset.each(&block)
     end
-
   end
-
 end