alf 0.10.1 → 0.11.0

data/lib/alf/iterator/proxy.rb

@@ -4,28 +4,22 @@ module Alf
       include Iterator
 
       # @return [Symbol] name of the dataset to request to environment
-      attr_reader :dataset
+      attr_reader :name
 
-      #
       # Creates a proxy instance.
       #
       # @param [Environment] env the environment serving iterator instances
       # @param [Symbol] dataset named dataset to rely on
-      #
-      def initialize(env, dataset)
-        @environment, @dataset = env, dataset
-      end
-
-      # (see Iterator#pipe)
-      def pipe(input, environment = nil)
-        @environment ||= environment 
-        @dataset ||= input
-        self
+      def initialize(env, name)
+        unless env.respond_to?(:dataset)
+          raise ArgumentError, "Invalid environment #{env.inspect}"
+        end
+        @environment, @name = env, name
       end
 
       # (see Iterator#each)
       def each(&block)
-        @environment.dataset(@dataset).each(&block)
+        @environment.dataset(@name).each(&block)
       end
 
     end # class Proxy

data/lib/alf/iterator.rb

@@ -0,0 +1,27 @@
+module Alf
+  #
+  # Marker module for all elements implementing tuple iterators.
+  #
+  # At first glance, an iterator is nothing else than an Enumerable that serves
+  # tuples (represented by ruby hashes). However, this module helps Alf's
+  # internal classes to recognize enumerables that may safely be considered as
+  # tuple iterators from other enumerables. For this reason, all elements that
+  # would like to participate to an iteration chain (that is, an logical
+  # operator implementation) should be marked with this module. This is the case
+  # for all Readers and Operators defined in Alf.
+  #
+  module Iterator
+    include Enumerable
+
+    # Converts this iterator to an in-memory Relation.
+    #
+    # @return [Relation] a relation instance, as the set of tuples
+    #         that would be yield by this iterator.
+    def to_rel
+      Relation::coerce(self)
+    end
+
+    require 'alf/iterator/class_methods'
+    require 'alf/iterator/proxy'
+  end # module Iterator
+end # module Alf

data/lib/alf/lispy/instance_methods.rb

@@ -1,11 +1,11 @@
 module Alf
   module Lispy
-    
+
     alias :ruby_extend :extend
-    
+
     # The environment
     attr_accessor :environment
-    
+
     #
     # Compiles a query expression given by a String or a block and returns
     # the result (typically a tuple iterator)
@@ -31,7 +31,7 @@ module Alf
         (path ? Kernel.eval(expr, b, path) : Kernel.eval(expr, b))
       end
     end
-  
+
     #
     # Evaluates a query expression given by a String or a block and returns
     # the result as an in-memory relation (Alf::Relation)
@@ -55,7 +55,7 @@ module Alf
         compiled
       end
     end
-    
+
     #
     # Coerces `h` to a valid tuple.
     #
@@ -68,7 +68,7 @@ module Alf
       end
       h
     end
-    
+
     #
     # Coerces `args` to a valid relation.
     #
@@ -94,16 +94,16 @@ module Alf
       if op_class.unary?
         define_method(meth_name) do |child, *args|
           child = Iterator.coerce(child, environment)
-          op_class.new(*args).pipe(child, environment)
+          op_class.new([child], *args)
         end
       elsif op_class.binary?
         define_method(meth_name) do |left, right, *args|
-          operands = [left, right].collect{|x| Iterator.coerce(x, environment)}
-          op_class.new(*args).pipe(operands, environment)
+          operands = [left, right].map{|x| Iterator.coerce(x, environment)}
+          op_class.new(operands, *args)
         end
       elsif op_class.nullary?
         define_method(meth_name) do |*args|
-          op_class.new(*args).pipe(nil, environment)
+          op_class.new([], *args)
         end
       else
         raise "Unexpected operator #{op_class}"
@@ -127,7 +127,7 @@ module Alf
     def allbut(child, attributes)
       (project child, attributes, :allbut => true)
     end
-  
+
     # 
     # Runs a command as in shell.
     #
@@ -141,17 +141,17 @@ module Alf
       argv = Quickl.split_commandline_args(argv, '|')
       argv.inject(nil) do |cmd,arr|
         arr.shift if arr.first == "alf"
-        main = Alf::Command::Main.new(environment)
+        main = Alf::Shell::Main.new(environment)
         main.stdin_reader = cmd unless cmd.nil?
         main.run(arr, requester)
       end
     end
 
     private 
-    
+
     def _clean_binding
       binding
     end
-  
+
   end # module Lispy
 end # module Alf

data/lib/alf/lispy.rb

@@ -0,0 +1,24 @@
+module Alf
+  #
+  # Implements a small LISP-like DSL on top of Alf.
+  #
+  # The lispy dialect is the functional one used in .alf files and in compiled
+  # expressions as below:
+  #
+  #   Alf.lispy.compile do
+  #     (restrict :suppliers, lambda{ city == 'London' })
+  #   end
+  #
+  # The DSL this module provides is part of Alf's public API and won't be broken 
+  # without a major version change. The module itself and its inclusion pre-
+  # conditions are not part of the DSL itself, thus not considered as part of 
+  # the API, and may therefore evolve at any time. In other words, this module 
+  # is not intended to be directly included by third-party classes. 
+  #
+  module Lispy
+    require 'alf/lispy/instance_methods'
+
+    DUM = Relation::DUM
+    DEE = Relation::DEE
+  end # module Lispy
+end # module Alf

data/lib/alf/loader.rb

@@ -1,3 +1,3 @@
 require "quickl"
 require "myrrha"
-require "highline"
+require "backports" if RUBY_VERSION <= "1.9"

data/lib/alf/operator/binary.rb

@@ -5,28 +5,17 @@ module Alf
     #
     module Binary
       include Operator 
-      
-      # 
-      # Sets the operator input
-      #
-      def pipe(input, env = environment)
-        self.environment = env
-        self.datasets = input
-        self
-      end
 
-      protected
-      
       # Returns the left operand
       def left
-        Iterator.coerce(datasets.first, environment)
+        operands.first
       end
-      
+
       # Returns the right operand
       def right
-        Iterator.coerce(datasets.last, environment)
+        operands.last
       end
-      
+
     end # module Binary
   end # module Operator
 end # module Alf

data/lib/alf/operator/class_methods.rb

@@ -6,127 +6,77 @@ module Alf
     # 
     module ClassMethods
 
-      #
-      # Returns false
-      #
-      def command?
-        false
-      end
-    
-      #
-      # Returns true
-      #
-      def operator?
-        true
+      # Returns the ruby case name of this operator
+      def rubycase_name 
+        Tools.ruby_case(Tools.class_name(self))
       end
 
-      #
-      # Returns true if this is a relational operator, false otherwise
-      #
+      ########################################################### Query methods
+
+      # @return true if this is a relational operator, false otherwise
       def relational?
         ancestors.include?(Relational)
       end
-    
-      #
-      # Returns true if this is a non relational operator, false otherwise
-      #
-      def non_relational?
-        ancestors.include?(NonRelational)
-      end
-    
-      #
-      # Runs the command on commandline arguments
-      #
-      # @param [Array] argv an array of commandline arguments, typically ARGV
-      # @param [Object] req an optional requester, typically a super command
-      # @return [Iterator] an Iterator with query result
-      #
-      def run(argv, req = nil)
-        inst, operands = from_argv(argv)
-
-        # find standard input reader
-        stdin_reader = if req && req.respond_to?(:stdin_reader)
-          req.stdin_reader
-        else 
-          Reader.coerce($stdin)
-        end
 
-        # normalize operands
-        operands = [ stdin_reader ] + Array(operands)
-        operands = operands.collect{|op| 
-          Iterator.coerce(op, req && req.environment)
-        }
-        operands = if nullary?
-          []
-        elsif unary?
-          operands.last
-        elsif binary?
-          operands[-2..-1]
-        end
+      # @return true if this is an experimental operator, false otherwise
+      def experimental?
+        ancestors.include?(Experimental)
+      end
 
-        inst.pipe(operands, req && req.environment)
-        inst
+      # @return true if this is a non relational operator, false otherwise
+      def non_relational?
+        ancestors.include?(NonRelational)
       end
 
-      #
-      # Returns true if this operator is a zero-ary operator, false otherwise
-      #
+      # @return true if this operator is a zero-ary operator, false otherwise
       def nullary?
         ancestors.include?(Operator::Nullary)
       end
 
-      #
-      # Returns true if this operator is an unary operator, false otherwise
-      #
+      # @return true if this operator is an unary operator, false otherwise
       def unary?
         ancestors.include?(Operator::Unary)
       end
 
-      #
-      # Returns true if this operator is a binary operator, false otherwise
-      #
+      # @return true if this operator is a binary operator, false otherwise
       def binary?
         ancestors.include?(Operator::Binary)
       end
 
-      #
+      ################################################################# Factory
+      
       # Installs or set the operator signature
-      #
       def signature
         if block_given?
           @signature = Signature.new(self, &Proc.new) 
           @signature.install
-          options do |opt|
-            signature.fill_option_parser(opt, self)
-          end
         else
           @signature ||= Signature.new(self)
         end
       end
-      
-      private 
-
-      # Factors an operator instance from commandline arguments
-      def from_argv(argv)
-        inst = new
-        operands = inst.signature.parse_argv(argv, inst)
-        [inst, operands]
-      end
 
     end # module ClassMethods
 
-    #
     # Yields non-relational then relational operators, in turn.
-    #
     def self.each
       Operator::NonRelational.each{|x| yield(x)}
       Operator::Relational.each{|x| yield(x)}
     end
+
+    # Let submodules and classes have required methods
+    module Installer
+
+      # Ensures that the Introspection module is set on real operators
+      def included(mod)
+        if mod.is_a?(Class)
+          mod.extend(ClassMethods) 
+        else
+          mod.extend(Installer)
+        end
+      end
+
+    end # module Installer
+    extend(Installer)
     
-    # Ensures that the Introspection module is set on real operators
-    def self.included(mod)
-      mod.extend(ClassMethods) if mod.is_a?(Class)
-    end
-      
   end # module Operator
 end # module Alf

data/lib/alf/operator/instance_methods.rb

@@ -0,0 +1,29 @@
+module Alf
+  module Operator
+    #
+    # Contains all methods for operator instances
+    #
+    module InstanceMethods
+
+      # @param [Array] operands Operator operands
+      attr_accessor :operands
+
+      # Create an operator instance
+      def initialize(*args)
+        signature.parse_args(args, self)
+      end
+
+      # @return [Signature] the operator signature.
+      def signature
+        self.class.signature
+      end
+
+      # Yields each tuple in turn 
+      def each(&block)
+        compile.each(&block)
+      end
+
+    end # module InstanceMethods
+    include InstanceMethods
+  end # module Operator
+end # module Alf

data/lib/alf/operator/non_relational/autonum.rb

@@ -1,24 +1,19 @@
 module Alf
-  module Operator::NonRelational
-    class Autonum < Alf::Operator()
-      include Operator::NonRelational, Operator::Transform
-    
-      signature do |s|
-        s.argument :as, AttrName, :autonum
-      end
-          
-      protected
-        
-      # (see Operator#_prepare)
-      def _prepare
-        @autonum = -1
-      end
-      
-      # (see Operator::Transform#_tuple2tuple)
-      def _tuple2tuple(tuple)
-        tuple.merge(@as => (@autonum += 1))
-      end
-    
-    end # class Autonum
-  end # module Operator::NonRelational
+  module Operator
+    module NonRelational
+      class Autonum
+        include NonRelational, Unary
+
+        signature do |s|
+          s.argument :as, AttrName, :autonum
+        end
+
+        # (see Operator#compile)
+        def compile
+          Engine::Autonum.new(operand, as)
+        end
+
+      end # class Autonum
+    end # module NonRelational
+  end # module Operator
 end # module Alf

data/lib/alf/operator/non_relational/clip.rb

@@ -1,20 +1,20 @@
 module Alf
-  module Operator::NonRelational
-    class Clip < Alf::Operator()
-      include Operator::NonRelational, Operator::Transform
-  
-      signature do |s|
-        s.argument :attributes, AttrList, []
-        s.option   :allbut,     Boolean, false, "Apply an allbut clipping?"
-      end
-      
-      protected 
-  
-      # (see Operator::Transform#_tuple2tuple)
-      def _tuple2tuple(tuple)
-        @attributes.project(tuple, @allbut)
-      end
-  
-    end # class Clip
-  end # module Operator::NonRelational
+  module Operator
+    module NonRelational
+      class Clip
+        include NonRelational, Unary
+
+        signature do |s|
+          s.argument :attributes, AttrList, []
+          s.option   :allbut,     Boolean, false, "Apply an allbut clipping?"
+        end
+
+        # (see Operator#compile)
+        def compile
+          Engine::Clip.new(operand, attributes, allbut)
+        end
+
+      end # class Clip
+    end # module NonRelational
+  end # module Operator
 end # module Alf

data/lib/alf/operator/non_relational/coerce.rb

@@ -1,21 +1,19 @@
 module Alf
-  module Operator::NonRelational
-    class Coerce < Alf::Operator()
-      include Operator::NonRelational, Operator::Transform
-    
-      signature do |s|
-        s.argument :heading, Heading, {}
-      end
-      
-      protected 
-      
-      # (see Operator::Transform#_tuple2tuple)
-      def _tuple2tuple(tuple)
-        tuple.merge tuple_collect(@heading.attributes){|k,d|
-          [k, coerce(tuple[k], d)]
-        }
-      end
-    
-    end # class Coerce
-  end # module Operator::NonRelational
+  module Operator
+    module NonRelational
+      class Coerce
+        include NonRelational, Unary
+
+        signature do |s|
+          s.argument :heading, Heading, {}
+        end
+
+        # (see Operator#compile)
+        def compile
+          Engine::Coerce.new(operand, heading)
+        end
+
+      end # class Coerce
+    end # module NonRelational
+  end # module Operator
 end # module Alf

data/lib/alf/operator/non_relational/compact.rb

@@ -1,62 +1,18 @@
 module Alf
-  module Operator::NonRelational
-    class Compact < Alf::Operator()
-      include Operator::NonRelational, Operator::Shortcut, Operator::Unary
-  
-      signature do |s|
-      end
-      
-      # Removes duplicates according to a complete order
-      class SortBased
-        include Operator, Operator::Cesure
+  module Operator
+    module NonRelational
+      class Compact
+        include NonRelational, Unary
 
-        def initialize
-          @cesure_key ||= AttrList.new([])
+        signature do |s|
         end
-          
-        protected
-        
-        # (see Operator::Cesure#project)
-        def project(tuple)
-          @cesure_key.project(tuple, true)
-        end
-  
-        # (see Operator::Cesure#accumulate_cesure)
-        def accumulate_cesure(tuple, receiver)
-          @tuple = tuple
-        end
-  
-        # (see Operator::Cesure#flush_cesure)
-        def flush_cesure(key, receiver)
-          receiver.call(@tuple)
-        end
- 
-      end # class SortBased
-  
-      # Removes duplicates by loading all in memory and filtering 
-      # them there 
-      class BufferBased
-        include Operator, Operator::Unary
-  
-        protected
-        
-        def _prepare
-          @tuples = input.to_a.uniq
-        end
-  
-        def _each
-          @tuples.each(&Proc.new)
+
+        # (see Operator#compile)
+        def compile
+          Engine::Compact.new(operand)
         end
-  
-      end # class BufferBased
-  
-      protected 
-      
-      def longexpr
-        chain BufferBased.new,
-              datasets
-      end
-  
-    end # class Compact
-  end # module Operator::NonRelational
+
+      end # class Compact
+    end # module NonRelational
+  end # module Operator
 end # module Alf

data/lib/alf/operator/non_relational/defaults.rb

@@ -1,25 +1,22 @@
 module Alf
-  module Operator::NonRelational
-    class Defaults < Alf::Operator()
-      include Operator::NonRelational, Operator::Transform
-  
-      signature do |s|
-        s.argument :defaults, TupleComputation, {}
-        s.option   :strict,   Boolean, false, "Restrict to default attributes only?"
-      end
-      
-      protected 
-  
-      # (see Operator::Transform#_tuple2tuple)
-      def _tuple2tuple(tuple)
-        handle = TupleHandle.new.set(tuple)
-        defs = @defaults.evaluate(handle)
-        keys = @strict ? defs.keys : (tuple.keys | defs.keys)
-        tuple_collect(keys){|k|
-          [k, coalesce(tuple[k], defs[k])]
-        }
-      end
-      
-    end # class Defaults
-  end # module Operator::NonRelational
+  module Operator
+    module NonRelational
+      class Defaults
+        include NonRelational, Unary
+
+        signature do |s|
+          s.argument :defaults, TupleComputation, {}
+          s.option   :strict,   Boolean, false, "Restrict to default attributes only?"
+        end
+
+        # (see Operator#compile)
+        def compile
+          op = Engine::Defaults.new(operand, defaults)
+          op = Engine::Clip.new(op, defaults.to_attr_list, false) if strict
+          op
+        end
+
+      end # class Defaults
+    end # module NonRelational
+  end # module Operator
 end # module Alf