alf-core 0.14.0 → 0.15.0

data/lib/{alf-engine/alf → alf}/engine/materialize/hash.rb

@@ -38,6 +38,7 @@ module Alf
     #     # => []
     #
     class Materialize::Hash
+      include Materialize
       include Cog
 
       # @return [Enumerable] The operand
@@ -50,8 +51,8 @@ module Alf
       attr_reader :allbut
 
       # Creates a Materialize::Hash instance
-      def initialize(operand, key, allbut = false, expr = nil)
-        super(expr)
+      def initialize(operand, key, allbut = false, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @key = key
         @allbut = allbut

data/lib/alf/engine/quota.rb

@@ -0,0 +1,7 @@
+module Alf
+  module Engine
+    module Quota
+    end
+  end
+end
+require_relative 'quota/cesure'

data/lib/{alf-engine/alf → alf}/engine/quota/cesure.rb

@@ -1,6 +1,7 @@
 module Alf
   module Engine
     class Quota::Cesure
+      include Quota
       include Engine::Cesure
 
       # @return [Enumerable] The operand
@@ -13,14 +14,18 @@ module Alf
       attr_reader :summarization
 
       # Creates an Quota::Cesure instance
-      def initialize(operand, by, summarization, expr = nil)
-        super(expr)
+      def initialize(operand, by, summarization, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @by = by.to_attr_list
         @summarization = summarization
       end
 
-      protected
+      def arguments
+        [ by, summarization ]
+      end
+
+    protected
 
       # (see Cesure#project)
       def project(tuple)

data/lib/alf/engine/rank.rb

@@ -0,0 +1,7 @@
+module Alf
+  module Engine
+    module Rank
+    end
+  end
+end
+require_relative 'rank/cesure'

data/lib/{alf-engine/alf → alf}/engine/rank/cesure.rb

@@ -1,6 +1,7 @@
 module Alf
   module Engine
     class Rank::Cesure
+      include Rank
       include Engine::Cesure
 
       # @return [Enumerable] The operand
@@ -13,14 +14,18 @@ module Alf
       attr_reader :as
 
       # Creates an Rank::Cesure instance
-      def initialize(operand, by, as, expr = nil)
-        super(expr)
+      def initialize(operand, by, as, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @by = by.to_attr_list
         @as = as
       end
 
-      protected
+      def arguments
+        [ by, as ]
+      end
+
+    protected
 
       # (see Cesure#project)
       def project(tuple)

data/lib/{alf-engine/alf → alf}/engine/rename.rb

@@ -23,8 +23,8 @@ module Alf
       attr_reader :renaming
 
       # Creates a Rename instance
-      def initialize(operand, renaming, expr = nil)
-        super(expr)
+      def initialize(operand, renaming, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @renaming = renaming
       end
@@ -36,6 +36,10 @@ module Alf
         end
       end
 
+      def arguments
+        [ renaming ]
+      end
+
     end # class Rename
   end # module Engine
 end # module Alf

data/lib/alf/engine/semi.rb

@@ -0,0 +1,7 @@
+module Alf
+  module Engine
+    module Semi
+    end
+  end
+end
+require_relative 'semi/hash'

data/lib/{alf-engine/alf → alf}/engine/semi/hash.rb

@@ -4,6 +4,7 @@ module Alf
     # Filters tuples from `left` that match or do not match tuples from `right`.
     #
     class Semi::Hash
+      include Semi
       include Cog
 
       # @return [Enumerable] The left operand
@@ -16,8 +17,8 @@ module Alf
       attr_reader :predicate
 
       # Creates a Semi::Hash instance
-      def initialize(left, right, predicate, expr = nil)
-        super(expr)
+      def initialize(left, right, predicate, expr = nil, compiler = nil)
+        super(expr, compiler)
         @left = left
         @right = right
         @predicate = predicate
@@ -41,6 +42,10 @@ module Alf
         end
       end
 
+      def arguments
+        [ predicate ]
+      end
+
     end # class Semi::Hash
   end # module Engine
 end # module Alf

data/lib/{alf-engine/alf → alf}/engine/set_attr.rb

@@ -28,8 +28,8 @@ module Alf
       attr_reader :computation
 
       # Creates a SetAttr instance
-      def initialize(operand, computation, expr = nil)
-        super(expr)
+      def initialize(operand, computation, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @computation = computation
       end
@@ -38,11 +38,15 @@ module Alf
       def _each
         scope = tuple_scope
         operand.each do |tuple|
-          t, c = scope.__set_tuple(tuple), expr && expr.connection
-          yield tuple.merge(@computation.evaluate(t, c))
+          t = scope.__set_tuple(tuple)
+          yield tuple.merge(@computation.evaluate(t))
         end
       end
 
+      def arguments
+        [ computation ]
+      end
+
     end # class SetAttr
   end # module Engine
 end # module Alf

data/lib/alf/engine/sort.rb

@@ -0,0 +1,13 @@
+module Alf
+  module Engine
+    module Sort
+
+      # Delegates to Sort::InMemory
+      def self.new(operand, ordering, expr = nil, compiler = nil)
+        Sort::InMemory.new(operand, ordering, expr, compiler)
+      end
+
+    end # module Sort
+  end # module Engine
+end # module Alf
+require_relative 'sort/in_memory'

data/lib/{alf-engine/alf → alf}/engine/sort/in_memory.rb

@@ -16,6 +16,7 @@ module Alf
     #     #    ]
     #
     class Sort::InMemory
+      include Sort
       include Cog
 
       # @return [Enumerable] The operand
@@ -25,17 +26,26 @@ module Alf
       attr_reader :ordering
 
       # Creates an Autonum instance
-      def initialize(operand, ordering, expr = nil)
-        super(expr)
+      def initialize(operand, ordering, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @ordering = ordering
       end
 
+      # (see Cog#cog_orders)
+      def cog_orders
+        @cog_orders ||= [ ordering ]
+      end
+
       # (see Cog#each)
       def _each(&block)
         operand.to_a.sort!(&ordering.sorter).each(&block)
       end
 
+      def arguments
+        [ ordering ]
+      end
+
     end # class Sort::InMemory
   end # module Engine
 end # module Alf

data/lib/alf/engine/summarize.rb

@@ -0,0 +1,13 @@
+module Alf
+  module Engine
+    module Summarize
+
+      def arguments
+        [ by, summarization, allbut ]
+      end
+
+    end
+  end
+end
+require_relative 'summarize/cesure'
+require_relative 'summarize/hash'

data/lib/{alf-engine/alf → alf}/engine/summarize/cesure.rb

@@ -1,7 +1,8 @@
 module Alf
   module Engine
     class Summarize::Cesure
-      include Engine::Cesure
+      include Summarize
+      include Cesure
 
       # @return [Enumerable] The operand
       attr_reader :operand
@@ -16,15 +17,15 @@ module Alf
       attr_reader :allbut
 
       # Creates an Summarize::Cesure instance
-      def initialize(operand, by, summarization, allbut, expr = nil)
-        super(expr)
+      def initialize(operand, by, summarization, allbut, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @by = by
         @summarization = summarization
         @allbut = allbut
       end
 
-      protected
+    protected
 
       # (see Cesure#project)
       def project(tuple)

data/lib/{alf-engine/alf → alf}/engine/summarize/hash.rb

@@ -1,6 +1,7 @@
 module Alf
   module Engine
     class Summarize::Hash
+      include Summarize
       include Cog
 
       # @return [Enumerable] The operand
@@ -16,8 +17,8 @@ module Alf
       attr_reader :allbut
 
       # Creates an Summarize::Hash instance
-      def initialize(operand, by, summarization, allbut, expr = nil)
-        super(expr)
+      def initialize(operand, by, summarization, allbut, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @by = by
         @summarization = summarization

data/lib/{alf-engine/alf → alf}/engine/take.rb

@@ -31,8 +31,8 @@ module Alf
       attr_reader :limit
 
       # Creates a Take instance
-      def initialize(operand, offset, limit, expr = nil)
-        super(expr)
+      def initialize(operand, offset, limit, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @offset  = offset
         @limit   = limit
@@ -48,6 +48,10 @@ module Alf
         end
       end
 
+      def arguments
+        [ offset, limit ]
+      end
+
     end # class Take
   end # module Engine
 end # module Alf

data/lib/{alf-engine/alf → alf}/engine/to_array.rb

@@ -26,19 +26,24 @@ module Alf
       attr_reader :ordering
 
       # Creates an ToArray instance
-      def initialize(operand, ordering, expr = nil)
-        super(expr)
+      def initialize(operand, ordering = nil, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @ordering = ordering
       end
 
       # (see Cog#each)
       def _each(&block)
-        Sort.new(operand, ordering).each do |tuple|
+        operand = ordering ? Sort.new(self.operand, ordering) : self.operand
+        operand.each do |tuple|
           yield recurse(tuple)
         end
       end
 
+      def arguments
+        [ ordering ]
+      end
+
     private
 
       def recurse(tuple)
@@ -46,13 +51,16 @@ module Alf
         when Hash
           Hash[tuple.map{|k,v| [ k, reorder(k,v) ] }]
         when Tuple
-          tuple.remap{|k,v| reorder(k, v) }
+          tuple.remap{|k,v| reorder(k, v) }.to_hash
         end
       end
 
       def reorder(key, value)
         if RelationLike===value
-          ToArray.new(value, ordering.dive(key)).to_a
+          subordering = ordering ? ordering.dive(key) : nil
+          ToArray.new(value, subordering).to_a
+        elsif TupleLike===value
+          value.to_hash
         else
           value
         end

data/lib/{alf-engine/alf → alf}/engine/type_safe.rb

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

data/lib/{alf-engine/alf → alf}/engine/ungroup.rb

@@ -10,8 +10,8 @@ module Alf
       attr_reader :attribute
 
       # Creates a Ungroup instance
-      def initialize(operand, attribute, expr = nil)
-        super(expr)
+      def initialize(operand, attribute, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @attribute = attribute
       end
@@ -22,11 +22,16 @@ module Alf
           tuple = tuple.dup
           tuple = tuple.to_hash unless tuple.is_a?(Hash)
           tuple.delete(@attribute).each do |subtuple|
+            subtuple = symbolize(subtuple)
             yield tuple.merge(subtuple)
           end
         end
       end
 
+      def arguments
+        [ attribute ]
+      end
+
     end # class Ungroup
   end # module Engine
 end # module Alf

data/lib/{alf-engine/alf → alf}/engine/unwrap.rb

@@ -13,8 +13,8 @@ module Alf
       attr_reader :attribute
 
       # Creates a SetAttr instance
-      def initialize(operand, attribute, expr = nil)
-        super(expr)
+      def initialize(operand, attribute, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @attribute = attribute
       end
@@ -22,13 +22,19 @@ module Alf
       # (see Cog#each)
       def _each
         operand.each do |tuple|
-          tuple = tuple.dup
-          tuple = tuple.to_hash unless tuple.is_a?(Hash)
-          tuple.merge!(tuple.delete(@attribute) || {})
+          tuple   = tuple.dup
+          tuple   = tuple.to_hash unless tuple.is_a?(Hash)
+          wrapped = tuple.delete(@attribute) || {}
+          wrapped = symbolize(wrapped)
+          tuple.merge!(wrapped)
           yield tuple
         end
       end
 
+      def arguments
+        [ attribute ]
+      end
+
     end # class Unwrap
   end # module Engine
 end # module Alf