rom 0.8.1 → 0.9.0.beta1

data/lib/rom/relation/lazy.rb

@@ -1,145 +0,0 @@
-require 'rom/pipeline'
-require 'rom/mapper_registry'
-
-require 'rom/relation/loaded'
-require 'rom/relation/composite'
-require 'rom/relation/graph'
-require 'rom/relation/materializable'
-
-module ROM
-  class Relation
-    # Lazy relation wraps canonical relation for data-pipelining
-    #
-    # @example
-    #   ROM.setup(:memory)
-    #
-    #   class Users < ROM::Relation[:memory]
-    #     def by_name(name)
-    #       restrict(name: name)
-    #     end
-    #   end
-    #
-    #   rom = ROM.finalize.env
-    #
-    #   rom.relations.users << { name: 'Jane' }
-    #   rom.relations.users << { name: 'Joe' }
-    #
-    #   mapper = proc { |users| users.map { |user| user[:name] } }
-    #   users = rom.relation(:users)
-    #
-    #   (users.by_name >> mapper)['Jane'].inspect # => ["Jane"]
-    #
-    # @api public
-    class Lazy
-      include Equalizer.new(:relation, :options)
-      include Options
-      include Materializable
-      include Pipeline
-
-      option :mappers, reader: true, default: proc { MapperRegistry.new }
-
-      # @return [Relation]
-      #
-      # @api private
-      attr_reader :relation
-
-      # Map of exposed relation methods
-      #
-      # @return [Hash<Symbol=>TrueClass>]
-      #
-      # @api private
-      attr_reader :exposed_relations
-
-      # @api private
-      def initialize(relation, options = {})
-        super
-        @relation = relation
-        @exposed_relations = @relation.exposed_relations
-      end
-
-      # Eager load other relation(s) for this relation
-      #
-      # @param [Array<Relation>] others The other relation(s) to eager load
-      #
-      # @return [Relation::Graph]
-      #
-      # @api public
-      def combine(*others)
-        Graph.build(self, others)
-      end
-
-      # Build a relation pipeline using registered mappers
-      #
-      # @example
-      #   rom.relation(:users).map_with(:json_serializer)
-      #
-      # @return [Relation::Composite]
-      #
-      # @api public
-      def map_with(*names)
-        [self, *names.map { |name| mappers[name] }]
-          .reduce { |a, e| Composite.new(a, e) }
-      end
-      alias_method :as, :map_with
-
-      # Load relation
-      #
-      # @return [Relation::Loaded]
-      #
-      # @api public
-      def call
-        Loaded.new(relation)
-      end
-
-      # @api private
-      def respond_to_missing?(name, include_private = false)
-        exposed_relations.include?(name) || super
-      end
-
-      # Return if this lazy relation is curried
-      #
-      # @return [false]
-      #
-      # @api private
-      def curried?
-        false
-      end
-
-      private
-
-      # Forward methods to the underlaying relation
-      #
-      # Auto-curry relations when args size doesn't match arity
-      #
-      # @return [Lazy,Curried]
-      #
-      # @api private
-      def method_missing(meth, *args, &block)
-        if !exposed_relations.include?(meth) || (curried? && name != meth)
-          super
-        else
-          arity = relation.method(meth).arity
-
-          if arity < 0 || arity == args.size
-            response = relation.__send__(meth, *args, &block)
-
-            if response.is_a?(Relation)
-              __new__(response)
-            else
-              response
-            end
-          else
-            Curried.new(relation, name: meth, curry_args: args, arity: arity)
-          end
-        end
-      end
-
-      # Return new lazy relation with updated options
-      #
-      # @api private
-      def __new__(relation, new_opts = {})
-        Lazy.new(relation, options.merge(new_opts))
-      end
-    end
-  end
-end

data/lib/rom/support/array_dataset.rb

@@ -1,41 +0,0 @@
-require 'rom/support/enumerable_dataset'
-
-module ROM
-  # A helper module that adds data-proxy behavior to an array-like object
-  #
-  # @see EnumerableDataset
-  #
-  # @api public
-  module ArrayDataset
-    extend DataProxy::ClassMethods
-    include EnumerableDataset
-
-    # Extends the class with data-proxy behavior
-    #
-    # @api private
-    def self.included(klass)
-      klass.class_eval do
-        include Options
-        include DataProxy
-      end
-    end
-
-    forward(
-      :*, :+, :-, :compact, :compact!, :flatten, :flatten!, :length, :pop,
-      :reverse, :reverse!, :sample, :size, :shift, :shuffle, :shuffle!,
-      :slice, :slice!, :sort!, :uniq, :uniq!, :unshift, :values_at
-    )
-
-    [
-      :map!, :combination, :cycle, :delete_if, :keep_if, :permutation, :reject!,
-      :select!, :sort_by!
-    ].each do |method|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{method}(*args, &block)
-          return to_enum unless block
-          self.class.new(data.send(:#{method}, *args, &block), options)
-        end
-      RUBY
-    end
-  end
-end

data/lib/rom/support/class_builder.rb

@@ -1,44 +0,0 @@
-module ROM
-  # Internal support class for generating classes
-  #
-  # @private
-  class ClassBuilder
-    include Options
-
-    option :name, type: String, reader: true
-    option :parent, type: Class, reader: true, parent: Object
-
-    # Generate a class based on options
-    #
-    # @example
-    #   builder = ROM::ClasBuilder.new(name: 'MyClass')
-    #
-    #   klass = builder.call
-    #   klass.name # => "MyClass"
-    #
-    # @return [Class]
-    #
-    # @api private
-    def call
-      klass = Class.new(parent)
-
-      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.name
-          #{name.inspect}
-        end
-
-        def self.inspect
-          name
-        end
-
-        def self.to_s
-          name
-        end
-      RUBY
-
-      yield(klass) if block_given?
-
-      klass
-    end
-  end
-end

data/lib/rom/support/class_macros.rb

@@ -1,56 +0,0 @@
-module ROM
-  # Internal support module for class-level settings
-  #
-  # @private
-  module ClassMacros
-    # Specify what macros a class will use
-    #
-    # @example
-    #   class MyClass
-    #     extend ROM::ClassMacros
-    #
-    #     defines :one, :two
-    #
-    #     one 1
-    #     two 2
-    #   end
-    #
-    #   class OtherClass < MyClass
-    #     two 'two'
-    #   end
-    #
-    #   MyClass.one # => 1
-    #   MyClass.two # => 2
-    #
-    #   OtherClass.one # => 1
-    #   OtherClass.two # => 'two'
-    #
-    # @api private
-    def defines(*args)
-      mod = Module.new
-
-      args.each do |name|
-        mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{name}(value = Undefined)
-            if value == Undefined
-              defined?(@#{name}) && @#{name}
-            else
-              @#{name} = value
-            end
-          end
-        RUBY
-      end
-
-      delegates = args.map { |name| "klass.#{name}(#{name})" }.join("\n")
-
-      mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def inherited(klass)
-          super
-          #{delegates}
-        end
-      RUBY
-
-      extend(mod)
-    end
-  end
-end

data/lib/rom/support/data_proxy.rb

@@ -1,102 +0,0 @@
-require 'equalizer'
-
-module ROM
-  # Helper module for dataset classes
-  #
-  # It provides a constructor accepting data, header and an optional row_proc.
-  # This module is used internally by EnumerableDataset and ArrayDataset.
-  #
-  # @private
-  module DataProxy
-    NON_FORWARDABLE = [
-      :each, :to_a, :to_ary, :kind_of?, :instance_of?, :is_a?
-    ].freeze
-
-    # Wrapped data array
-    #
-    # @return [Object] Data object for the iterator
-    #
-    # @api private
-    attr_reader :data
-
-    # @return [Proc] tuple processing proc
-    #
-    # @api private
-    attr_reader :row_proc
-
-    # Extends the class with `forward` DSL and Equalizer using `data` attribute
-    #
-    # @see ClassMethods#forward
-    #
-    # @api private
-    def self.included(klass)
-      klass.class_eval do
-        extend ClassMethods
-
-        include Equalizer.new(:data)
-
-        option :row_proc, reader: true, default: proc { |obj| obj.class.row_proc }
-      end
-    end
-
-    # @api private
-    def initialize(data, options = {})
-      @data = data
-      super(data, options)
-    end
-
-    # Iterate over data using row_proc
-    #
-    # @return [Enumerator] if block is not given
-    #
-    # @api private
-    def each
-      return to_enum unless block_given?
-      data.each { |tuple| yield(row_proc[tuple]) }
-    end
-
-    module ClassMethods
-      # Default no-op tuple proc
-      #
-      # @return [Proc]
-      #
-      # @api private
-      def row_proc
-        -> tuple { tuple }
-      end
-
-      # Forward provided methods to the underlaying data object
-      #
-      # @example
-      #
-      #   class MyDataset
-      #     include DataProxy
-      #
-      #     forward(:find_all, :map)
-      #   end
-      #
-      # @return [undefined]
-      #
-      # @api public
-      def forward(*methods)
-        # FIXME: we should probably raise if one of the non-forwardable methods
-        #       was provided
-        (methods - NON_FORWARDABLE).each do |method_name|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method_name}(*args, &block)
-              response = data.public_send(#{method_name.inspect}, *args, &block)
-
-              if response.equal?(data)
-                self
-              elsif response.is_a?(data.class)
-                self.class.new(response)
-              else
-                response
-              end
-            end
-          RUBY
-        end
-      end
-    end
-  end
-end

data/lib/rom/support/deprecations.rb

@@ -1,36 +0,0 @@
-module ROM
-  module Deprecations
-    # @api private
-    def deprecate(old_name, new_name, msg = nil)
-      class_eval do
-        define_method(old_name) do |*args, &block|
-          ROM::Deprecations.announce "#{self.class}##{old_name} is", <<-MSG
-            Please use #{self.class}##{new_name} instead.
-            #{msg}
-          MSG
-          __send__(new_name, *args, &block)
-        end
-      end
-    end
-
-    def deprecate_class_method(old_name, new_name, msg = nil)
-      class_eval do
-        define_singleton_method(old_name) do |*args, &block|
-          ROM::Deprecations.announce"#{self}.#{old_name} is", <<-MSG
-            Please use #{self}.#{new_name} instead.
-            #{msg}
-          MSG
-          __send__(new_name, *args, &block)
-        end
-      end
-    end
-
-    def self.announce(name, msg)
-      warn <<-MSG.gsub(/^\s+/, '')
-        #{name} deprecated and will be removed in 1.0.0.
-        #{msg}
-        #{caller.detect { |l| !l.include?('lib/rom')}}
-      MSG
-    end
-  end
-end

data/lib/rom/support/enumerable_dataset.rb

@@ -1,65 +0,0 @@
-require 'rom/support/data_proxy'
-
-module ROM
-  # A helper module that adds data-proxy behavior to an enumerable object
-  #
-  # This module is intended to be used by gateways
-  #
-  # Class that includes this module can define `row_proc` class method which
-  # must return a proc-like object which will be used to process each element
-  # in the enumerable
-  #
-  # @example
-  #   class MyDataset
-  #     include ROM::EnumerableDataset
-  #
-  #     def self.row_proc
-  #       -> tuple { tuple.each_with_object({}) { |(k,v), h| h[k.to_sym] = v } }
-  #     end
-  #   end
-  #
-  #   ds = MyDataset.new([{ 'name' => 'Jane' }, [:name])
-  #   ds.to_a # => { :name => 'Jane' }
-  #
-  # @api public
-  module EnumerableDataset
-    extend DataProxy::ClassMethods
-    include Enumerable
-
-    # Coerce a dataset to an array
-    #
-    # @return [Array]
-    #
-    # @api public
-    alias_method :to_ary, :to_a
-
-    # Included hook which extends a class with DataProxy behavior
-    #
-    # This module can also be included into other modules so we apply the
-    # extension only for classes
-    #
-    # @api private
-    def self.included(klass)
-      return unless klass.is_a?(Class)
-
-      klass.class_eval do
-        include Options
-        include DataProxy
-      end
-    end
-
-    forward :take
-
-    [
-      :chunk, :collect, :collect_concat, :drop_while, :find_all, :flat_map,
-      :grep, :map, :reject, :select, :sort, :sort_by, :take_while
-    ].each do |method|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{method}(*args, &block)
-          return to_enum unless block
-          self.class.new(super(*args, &block), options)
-        end
-      RUBY
-    end
-  end
-end