alf-core 0.13.1 → 0.14.0

data/lib/alf-engine/alf/engine/infer_heading.rb

@@ -9,7 +9,8 @@ module Alf
       # @return [Enumerable] The operand
       attr_reader :operand
 
-      def initialize(operand)
+      def initialize(operand, expr = nil)
+        super(expr)
         @operand = operand
       end
 

data/lib/alf-engine/alf/engine/join.rb

@@ -1,3 +1,7 @@
-module Alf::Engine::Join
+module Alf
+  module Engine
+    module Join
+    end
+  end
 end
 require_relative 'join/hash'

data/lib/alf-engine/alf/engine/join/hash.rb

@@ -4,6 +4,7 @@ module Alf
     # Provides hash-based join.
     #
     class Join::Hash
+      include Join
       include Cog
 
       # @return [Enumerable] The left operand
@@ -13,18 +14,24 @@ module Alf
       attr_reader :right
 
       # Creates a Join::Hash instance
-      def initialize(left, right)
+      def initialize(left, right, expr = nil)
+        super(expr)
         @left = left
         @right = right
       end
 
+      # Returns left and right operands in an array
+      def operands
+        [ left, right ]
+      end
+
       # (see Cog#each)
       def _each(&block)
         index = nil
         left.each do |left_tuple|
           index ||= Materialize::Hash.new(right, lambda{|t|
             AttrList.new(left_tuple.keys & t.keys)
-          }, false).prepare
+          }, false, expr).prepare
           index[left_tuple, true].each do |right_tuple|
             yield left_tuple.merge(right_tuple)
           end

data/lib/alf-engine/alf/engine/leaf.rb

@@ -10,7 +10,8 @@ module Alf
       attr_reader :operand
 
       # Creates a Concat instance
-      def initialize(operand)
+      def initialize(operand, expr = nil)
+        super(expr)
         @operand = operand
       end
 
@@ -19,6 +20,10 @@ module Alf
         operand.each(&block)
       end
 
+      def to_s
+        "Engine::Leaf(#{operand})"
+      end
+
     end # class Leaf
   end # module Engine
 end # module Alf

data/lib/alf-engine/alf/engine/materialize/array.rb

@@ -37,7 +37,8 @@ module Alf
       attr_reader :ordering
 
       # Creates a Materialize::Array instance
-      def initialize(operand, ordering = nil)
+      def initialize(operand, ordering = nil, expr = nil)
+        super(expr)
         @operand = operand
         @ordering = ordering
         @materialized = nil

data/lib/alf-engine/alf/engine/materialize/hash.rb

@@ -50,7 +50,8 @@ module Alf
       attr_reader :allbut
 
       # Creates a Materialize::Hash instance
-      def initialize(operand, key, allbut = false)
+      def initialize(operand, key, allbut = false, expr = nil)
+        super(expr)
         @operand = operand
         @key = key
         @allbut = allbut

data/lib/alf-engine/alf/engine/quota/cesure.rb

@@ -13,7 +13,8 @@ module Alf
       attr_reader :summarization
 
       # Creates an Quota::Cesure instance
-      def initialize(operand, by, summarization)
+      def initialize(operand, by, summarization, expr = nil)
+        super(expr)
         @operand = operand
         @by = by.to_attr_list
         @summarization = summarization

data/lib/alf-engine/alf/engine/rank/cesure.rb

@@ -13,7 +13,8 @@ module Alf
       attr_reader :as
 
       # Creates an Rank::Cesure instance
-      def initialize(operand, by, as)
+      def initialize(operand, by, as, expr = nil)
+        super(expr)
         @operand = operand
         @by = by.to_attr_list
         @as = as

data/lib/alf-engine/alf/engine/rename.rb

@@ -23,7 +23,8 @@ module Alf
       attr_reader :renaming
 
       # Creates a Rename instance
-      def initialize(operand, renaming)
+      def initialize(operand, renaming, expr = nil)
+        super(expr)
         @operand = operand
         @renaming = renaming
       end

data/lib/alf-engine/alf/engine/semi/hash.rb

@@ -16,12 +16,18 @@ module Alf
       attr_reader :predicate
 
       # Creates a Semi::Hash instance
-      def initialize(left, right, predicate)
+      def initialize(left, right, predicate, expr = nil)
+        super(expr)
         @left = left
         @right = right
         @predicate = predicate
       end
 
+      # Returns left and right operands in an array
+      def operands
+        [ left, right ]
+      end
+
       # (see Cog#each)
       def _each
         index = nil

data/lib/alf-engine/alf/engine/set_attr.rb

@@ -28,7 +28,8 @@ module Alf
       attr_reader :computation
 
       # Creates a SetAttr instance
-      def initialize(operand, computation)
+      def initialize(operand, computation, expr = nil)
+        super(expr)
         @operand = operand
         @computation = computation
       end
@@ -37,8 +38,8 @@ module Alf
       def _each
         scope = tuple_scope
         operand.each do |tuple|
-          computed = @computation.evaluate(scope.__set_tuple(tuple))
-          yield tuple.merge(computed)
+          t, c = scope.__set_tuple(tuple), expr && expr.connection
+          yield tuple.merge(@computation.evaluate(t, c))
         end
       end
 

data/lib/alf-engine/alf/engine/sort.rb

@@ -13,14 +13,15 @@ module Alf
       attr_reader :ordering
 
       # Creates an Autonum instance
-      def initialize(operand, ordering)
+      def initialize(operand, ordering, expr = nil)
+        super(expr)
         @operand = operand
         @ordering = ordering
       end
 
       # (see Cog#each)
       def _each(&block)
-        Sort::InMemory.new(operand, ordering).each(&block)
+        Sort::InMemory.new(operand, ordering, expr).each(&block)
       end
 
     end # class Sort

data/lib/alf-engine/alf/engine/sort/in_memory.rb

@@ -25,7 +25,8 @@ module Alf
       attr_reader :ordering
 
       # Creates an Autonum instance
-      def initialize(operand, ordering)
+      def initialize(operand, ordering, expr = nil)
+        super(expr)
         @operand = operand
         @ordering = ordering
       end

data/lib/alf-engine/alf/engine/summarize/cesure.rb

@@ -16,7 +16,8 @@ module Alf
       attr_reader :allbut
 
       # Creates an Summarize::Cesure instance
-      def initialize(operand, by, summarization, allbut)
+      def initialize(operand, by, summarization, allbut, expr = nil)
+        super(expr)
         @operand = operand
         @by = by
         @summarization = summarization

data/lib/alf-engine/alf/engine/summarize/hash.rb

@@ -16,7 +16,8 @@ module Alf
       attr_reader :allbut
 
       # Creates an Summarize::Hash instance
-      def initialize(operand, by, summarization, allbut)
+      def initialize(operand, by, summarization, allbut, expr = nil)
+        super(expr)
         @operand = operand
         @by = by
         @summarization = summarization
@@ -25,7 +26,7 @@ module Alf
 
       # (see Cog#each)
       def _each
-        index = Materialize::Hash.new(operand, by, allbut)
+        index = Materialize::Hash.new(operand, by, allbut, expr)
         index.each_pair do |k, v|
           yield k.merge(summarization.summarize(v))
         end

data/lib/alf-engine/alf/engine/take.rb

@@ -0,0 +1,53 @@
+module Alf
+  module Engine
+    #
+    # Take only a frame of the input relation according to an (offset, limit)
+    # parameter.
+    #
+    # Example:
+    #
+    #   res = [
+    #     {:name => "Jones", :price => 12.0, :id => 1},
+    #     {:name => "Smith", :price => 10.0, :id => 2},
+    #     {:name => "Blake", :price => 14.0, :id => 3}
+    #     {:name => "Adams", :price => 13.0, :id => 4}
+    #   ]
+    #   Aggregate.new(res, 1, 2).to_a
+    #   # => [
+    #   #      {:name => "Smith", :price => 10.0, :id => 2},
+    #   #      {:name => "Blake", :price => 14.0, :id => 3}
+    #   #    ]
+    #
+    class Take
+      include Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [Integer] The frame offset
+      attr_reader :offset
+
+      # @return [Integer] The frame limit
+      attr_reader :limit
+
+      # Creates a Take instance
+      def initialize(operand, offset, limit, expr = nil)
+        super(expr)
+        @operand = operand
+        @offset  = offset
+        @limit   = limit
+      end
+
+      # (see Cog#each)
+      def _each
+        i = -1
+        operand.each do |tuple|
+          next   if (i += 1) < offset
+          return if i >= offset+limit
+          yield(tuple)
+        end
+      end
+
+    end # class Take
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/to_array.rb

@@ -26,7 +26,8 @@ module Alf
       attr_reader :ordering
 
       # Creates an ToArray instance
-      def initialize(operand, ordering)
+      def initialize(operand, ordering, expr = nil)
+        super(expr)
         @operand = operand
         @ordering = ordering
       end
@@ -43,15 +44,15 @@ module Alf
       def recurse(tuple)
         case tuple
         when Hash
-          Hash[tuple.map{|k,v| [k, reorder(v)] }]
+          Hash[tuple.map{|k,v| [ k, reorder(k,v) ] }]
         when Tuple
-          tuple.remap{|k,v| reorder(v) }
+          tuple.remap{|k,v| reorder(k, v) }
         end
       end
 
-      def reorder(value)
+      def reorder(key, value)
         if RelationLike===value
-          ToArray.new(value, ordering).to_a
+          ToArray.new(value, ordering.dive(key)).to_a
         else
           value
         end

data/lib/alf-engine/alf/engine/type_safe.rb

@@ -10,7 +10,8 @@ module Alf
       attr_reader :checker
 
       # Creates an Coerce instance
-      def initialize(operand, checker)
+      def initialize(operand, checker, expr = nil)
+        super(expr)
         @operand = operand
         @checker = checker
       end

data/lib/alf-engine/alf/engine/ungroup.rb

@@ -10,7 +10,8 @@ module Alf
       attr_reader :attribute
 
       # Creates a Ungroup instance
-      def initialize(operand, attribute)
+      def initialize(operand, attribute, expr = nil)
+        super(expr)
         @operand = operand
         @attribute = attribute
       end

data/lib/alf-engine/alf/engine/unwrap.rb

@@ -13,7 +13,8 @@ module Alf
       attr_reader :attribute
 
       # Creates a SetAttr instance
-      def initialize(operand, attribute)
+      def initialize(operand, attribute, expr = nil)
+        super(expr)
         @operand = operand
         @attribute = attribute
       end

data/lib/alf-engine/alf/engine/wrap.rb

@@ -19,7 +19,8 @@ module Alf
       attr_reader :allbut
 
       # Creates a SetAttr instance
-      def initialize(operand, attributes, as, allbut)
+      def initialize(operand, attributes, as, allbut, expr = nil)
+        super(expr)
         @operand = operand
         @attributes = attributes
         @as = as

data/lib/alf-io/alf/reader.rb

@@ -20,7 +20,6 @@ module Alf
   #   r = Reader.foo([a path or a IO object])
   #
   class Reader
-    include Alf::Engine::Cog
     include Enumerable
 
     class << self
@@ -187,3 +186,4 @@ end # module Alf
 require_relative 'reader/rash'
 require_relative 'reader/csv'
 require_relative 'reader/json'
+require_relative 'reader/ruby'

data/lib/alf-io/alf/reader/ruby.rb

@@ -0,0 +1,23 @@
+module Alf
+  class Reader
+    #
+    # Specialization of the Reader contract for .rb files.
+    #
+    # A .rb file/stream contains some ruby code that evaluates to a Relation-like
+    # object, typically an Array of hashes.
+    #
+    class Ruby < Reader
+
+      def self.mime_type
+        nil
+      end
+
+      def each(&bl)
+        return to_enum unless block_given?
+        ::Kernel.eval(input_text).each(&bl)
+      end
+
+      Reader.register(:ruby, [".rb", ".ruby"], self)
+    end # class Ruby
+  end # class Reader
+end # module Alf

data/lib/alf-io/alf/renderer/text.rb

@@ -124,20 +124,33 @@ module Alf
         end
 
         def sep
-          @sep ||= '+-' << sizes.map{|s| '-' * s}.join('-+-') << '-+' << "\n"
+          @sep ||= '+-' << sizes.map{|s| '-' * s}.join('-+-') << '-+'
+        end
+
+        def each_line(pretty = options[:pretty])
+          if pretty
+            trim = options[:trim_at]
+            each_line(false) do |line|
+              yield(line[0..trim])
+            end
+          else
+            yield(sep)
+            yield(header.rendering_lines(sizes).first)
+            yield(sep)
+            rows.each do |row|
+              row.rendering_lines(sizes).each do |line|
+                yield(line)
+              end
+            end
+            yield(sep)
+          end
         end
 
         def each
           return to_enum unless block_given?
-          yield(sep)
-          yield header.rendering_lines(sizes).first << "\n"
-          yield(sep)
-          rows.each do |row|
-            row.rendering_lines(sizes).each do |line|
-              yield(line << "\n")
-            end
+          each_line do |line|
+            yield(line.strip << "\n")
           end
-          yield(sep)
         end
 
         def to_s

data/lib/alf-lang/alf/lang/lispy.rb

@@ -1,43 +1,55 @@
 module Alf
   module Lang
-    class Lispy < Support::Scope
-
-      module OwnMethods
-
-        def parse(expr = nil, path = nil, line = nil, &block)
-          if (expr && block) || (expr.nil? and block.nil?)
-            raise ArgumentError, "Either `expr` or `block` should be specified"
-          end
-          expr = evaluate(expr, path, line, &block) if block or expr.is_a?(String)
-          expr = __send__(expr)                     if expr.is_a?(Symbol)
-          expr = expr.bind(connection)              if expr.is_a?(Support::Bindable) && connection
-          expr
+    class Lispy
+      include Functional
+      include Predicates
+
+      # Creates a language instance
+      def initialize(helpers = [ ], connection = nil)
+        @connection = connection
+        @extensions = helpers
+        helpers.each do |helper|
+          helper.send(:extend_object, self)
         end
+      end
 
-        attr_reader :connection
+      attr_reader :connection
 
-        def connection!
-          connection.tap{|c| ::Kernel.raise(UnboundError, "#{self} not bound") unless c }
-        end
+      def connection!
+        connection.tap{|c| ::Kernel.raise(UnboundError, "#{self} not bound") unless c }
+      end
+
+      def evaluate(expr = nil, path=nil, line=nil, &bl)
+        return instance_exec(&bl) if bl
+        ::Kernel.eval expr, __eval_binding, *[path, line].compact
+      end
 
-        def to_s
-          mods = @extensions
-            .map(&:name)
-            .compact
-            .reject{|x| x =~ /^Alf::|OwnMethods/}
-            .join(',')
-          "Lispy(#{mods})"
+      def parse(expr = nil, path = nil, line = nil, &block)
+        if (expr && block) || (expr.nil? and block.nil?)
+          raise ArgumentError, "Either `expr` or `block` should be specified"
         end
-        alias_method :inspect, :to_s
+        expr = evaluate(expr, path, line, &block) if block or expr.is_a?(String)
+        expr = __send__(expr)                     if expr.is_a?(Symbol)
+        expr = expr.bind(connection)              if expr.is_a?(Support::Bindable) && connection
+        expr
+      end
 
-      end # OwnMethods
+      def to_s
+        "Lispy(#{@extensions.map(&:name).compact.join(',')})"
+      end
 
-      # Creates a language instance
-      def initialize(helpers = [ ], connection = nil)
-        @connection = connection
-        super [ OwnMethods, Functional, Predicates ] + helpers
+      def inspect
+        "Lispy(#{@extensions.inspect})"
       end
 
+    private
+
+      def __eval_binding
+        ::Kernel.binding
+      end
+
+    public
+
       # Resolve DUM and DEE in ruby 1.9.2 context
       def self.const_missing(name)
         case name.to_s