alf 0.9.3 → 0.10.0

data/examples/operators/clip.alf

@@ -1,3 +1,3 @@
 #!/usr/bin/env alf
 (clip :suppliers, [:name, :city])
-(clip :suppliers, [:name, :city], true)
+(clip :suppliers, [:name, :city], :allbut => true)

data/examples/operators/database.alf

@@ -1,6 +1,5 @@
-Alf::Relation[{
-  :suppliers => (dataset :suppliers),
-  :parts     => (dataset :parts),
-  :cities    => (dataset :cities),
-  :supplies  => (dataset :supplies)
-}]
+Relation({
+  :suppliers => (Relation :suppliers),
+  :parts     => (Relation :parts),
+  :supplies  => (Relation :supplies),
+})

data/examples/operators/defaults.alf

@@ -1,3 +1,3 @@
 #!/usr/bin/env alf
 (defaults :suppliers, :country => 'Belgium')
-(defaults :suppliers, {:country => 'Belgium'}, true)
+(defaults :suppliers, {:country => 'Belgium'}, :strict => true)

data/examples/operators/group.alf

@@ -1,3 +1,3 @@
 #!/usr/bin/env alf
 (group :supplies, [:pid, :qty], :supplying)
-(group :supplies, [:sid], :supplying, true)
+(group :supplies, [:sid], :supplying, :allbut => true)

data/examples/operators/project.alf

@@ -1,2 +1,3 @@
 #!/usr/bin/env alf
-(project :suppliers, [:name, :city])
+(project :suppliers, [:name, :city])
+(project :suppliers, [:name, :city], :allbut => true)

data/examples/operators/pseudo-with.alf

@@ -3,5 +3,5 @@ with_countries = (join kept_suppliers, :cities)
 supplying      = (join with_countries, :supplies)
 (summarize supplying,
            [:country],
-           :which => Agg::group(:pid),
-           :total => Agg::sum{ qty })
+           :which => collect{ pid },
+           :total => sum{ qty })

data/examples/operators/quota.alf

@@ -1,4 +1,4 @@
 #!/usr/bin/env alf
 (quota :supplies, [:sid], [:qty],
-       :position => Agg::count,
-       :sum_qty  => Agg::sum(:qty))
+       :position => count(),
+       :sum_qty  => sum{ qty })

data/examples/operators/summarize.alf

@@ -3,7 +3,7 @@
 # What is the sum of supplied quantities by supplier?
 (summarize :supplies, 
            [:sid],
-           :total_qty => Agg::sum(:qty))
+           :total_qty => sum{ qty })
 
 # Give the maximal supplied quantity by country, taking only into account
 # suppliers that have a status greater than 10
@@ -13,4 +13,4 @@
           :supplies), 
     :cities),
   [:country], 
-  :maxqty => Agg::sum{ qty })
+  :maxqty => sum{ qty })

data/lib/alf/aggregator/aggregators.rb

@@ -0,0 +1,77 @@
+module Alf
+  class Aggregator
+  
+    # 
+    # Defines a COUNT aggregation operator
+    #
+    class Count < Aggregator
+      def least(); 0; end
+      def happens(memo, tuple) memo + 1; end
+    end # class Count
+  
+    # 
+    # Defines a SUM aggregation operator
+    #
+    class Sum < Aggregator
+      def least(); 0; end
+      def _happens(memo, val) memo + val; end
+    end # class Sum
+  
+    # 
+    # Defines an AVG aggregation operator
+    #
+    class Avg < Aggregator
+      def least(); [0.0, 0.0]; end
+      def _happens(memo, val) [memo.first + val, memo.last + 1]; end
+      def finalize(memo) memo.first / memo.last end
+    end # class Sum
+  
+    # 
+    # Defines a MIN aggregation operator
+    #
+    class Min < Aggregator
+      def least(); nil; end
+      def _happens(memo, val) 
+        memo.nil? ? val : (memo < val ? memo : val) 
+      end
+    end # class Min
+  
+    # 
+    # Defines a MAX aggregation operator
+    #
+    class Max < Aggregator
+      def least(); nil; end
+      def _happens(memo, val) 
+        memo.nil? ? val : (memo > val ? memo : val) 
+      end
+    end # class Max
+    
+    #
+    # Defines a COLLECT aggregation operator
+    #
+    class Collect < Aggregator
+      def least(); []; end
+      def _happens(memo, val) 
+        memo << val
+      end
+    end
+  
+    # 
+    # Defines a CONCAT aggregation operator
+    # 
+    class Concat < Aggregator
+      def least(); ""; end
+      def default_options
+        {:before => "", :after => "", :between => ""}
+      end
+      def _happens(memo, val) 
+        memo << options[:between].to_s unless memo.empty?
+        memo << val.to_s
+      end
+      def finalize(memo)
+        options[:before].to_s + memo + options[:after].to_s
+      end
+    end
+  
+  end # class Aggregator
+end # module Alf

data/lib/alf/aggregator/base.rb

@@ -0,0 +1,95 @@
+module Alf
+  class Aggregator
+    module Base
+      
+      # @return [Hash] Aggregation options 
+      attr_reader :options
+
+      # @return [TupleExpression] the underlying functor
+      attr_reader :functor
+
+      # @return [String] source code of the aggregator, if any
+      attr_accessor :source
+
+      #
+      # Creates an Aggregator instance.
+      #
+      # Example:
+      #
+      #   Aggregator.new{ size * price }
+      #
+      def initialize(options = {}, &block)
+        @handle = Tools::TupleHandle.new
+        @options = default_options.merge(options)
+        @functor = Tools.coerce(block, TupleExpression)
+      end
+    
+      #
+      # Returns the default options to use
+      #
+      def default_options
+        {}
+      end
+    
+      #
+      # Returns the least value, which is the one to use on an empty
+      # set.
+      #
+      # This method is intended to be overriden by subclasses; default 
+      # implementation returns nil.
+      # 
+      def least
+        nil
+      end
+    
+      # 
+      # This method is called on each aggregated tuple and must return
+      # an updated _memo_ value. It can be seen as the block typically
+      # given to Enumerable.inject.
+      #
+      # The default implementation collects the pre-value on the tuple 
+      # and delegates to _happens.
+      #
+      def happens(memo, tuple)
+        _happens(memo, @functor.evaluate(@handle.set(tuple)))
+      end
+    
+      #
+      # This method finalizes a computation.
+      #
+      # Argument _memo_ is either _least_ or the result of aggregating 
+      # through _happens_. The default implementation simply returns
+      # _memo_. The method is intended to be overriden for complex 
+      # aggregations that need statefull information. See Avg for an 
+      # example 
+      #
+      def finalize(memo)
+        memo
+      end
+    
+      #
+      # Aggregates over an enumeration of tuples. 
+      #
+      def aggregate(enum)
+        finalize(
+          enum.inject(least){|memo,tuple| 
+            happens(memo, tuple)
+          })
+      end
+    
+      protected
+    
+      #
+      # @see happens.
+      #
+      # This method is intended to be overriden and returns _value_
+      # by default, making this aggregator a "Last" one...
+      #
+      def _happens(memo, value)
+        value
+      end
+      
+    end # module Base
+    include(Base)
+  end # class Aggregator
+end # module Alf

data/lib/alf/aggregator/class_methods.rb

@@ -0,0 +1,57 @@
+module Alf
+  class Aggregator
+    module ClassMethods
+      
+      #
+      # Returns registered aggregators as an Array of classes
+      #
+      def aggregators
+        @aggregators ||= []
+      end
+
+      #
+      # Yields aggregator classes in turn
+      # 
+      def each
+        aggregators.each(&Proc.new)
+      end
+
+      #
+      # Automatically installs factory methods for inherited classes.
+      #
+      # Example: 
+      #   class Sum < Aggregate   # will give a method Aggregator.sum
+      #     ...
+      #   end
+      #   Aggregator.sum{ size }
+      # 
+      def inherited(clazz)
+        aggregators << clazz
+        basename = Tools.ruby_case(Tools.class_name(clazz))
+        instance_eval <<-EOF
+          def #{basename}(*args, &block)
+            #{clazz}.new(*args, &block)
+          end
+        EOF
+      end
+  
+      #
+      # Coerces `arg` as an Aggregator
+      #
+      def coerce(arg)
+        case arg
+        when Aggregator
+          arg
+        when String
+          agg = instance_eval(arg)
+          agg.source = arg
+          agg
+        else
+          raise ArgumentError, "Invalid arg `arg` for Aggregator()"
+        end
+      end
+        
+    end # module ClassMethods
+    extend(ClassMethods)
+  end # class Aggregator
+end # module Alf

data/lib/alf/buffer/sorted.rb

@@ -0,0 +1,48 @@
+module Alf
+  class Buffer
+    # 
+    # Keeps tuples ordered on a specific key
+    #
+    # Example:
+    #
+    #   sorted = Buffer::Sorted.new Ordering.new(...)
+    #   sorted.add_all(...)
+    #   sorted.each do |tuple|
+    #     # tuples are ordered here 
+    #   end
+    #
+    class Sorted < Buffer
+  
+      #
+      # Creates a buffer instance with an ordering key
+      #
+      def initialize(ordering)
+        @ordering = ordering
+        @buffer = []
+      end
+  
+      #
+      # Adds all elements of an iterator to the buffer
+      #
+      def add_all(enum)
+        sorter = @ordering.sorter
+        @buffer = merge_sort(@buffer, enum.to_a.sort(&sorter), sorter)
+      end
+  
+      #
+      # (see Buffer#each)
+      #
+      def each
+        @buffer.each(&Proc.new)
+      end
+  
+      private
+    
+      # Implements a merge sort between two iterators s1 and s2
+      def merge_sort(s1, s2, sorter)
+        (s1 + s2).sort(&sorter)
+      end
+  
+    end # class Sorted
+  end # class Buffer
+end # module Alf

data/lib/alf/command/class_methods.rb

@@ -0,0 +1,27 @@
+module Alf
+  module Command
+    module ClassMethods
+
+      #
+      # Returns true
+      #
+      def command?
+        true
+      end
+    
+      #
+      # Returns false
+      #
+      def operator?
+        false
+      end
+    
+    end
+
+    def self.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+  end # module Command
+end # module Alf
+

data/lib/alf/command/doc_manager.rb

@@ -0,0 +1,72 @@
+module Alf
+  module Command
+    class DocManager
+
+      # Main documentation folder
+      DOC_FOLDER = File.expand_path('../../../../doc/', __FILE__)
+
+      #
+      # Called by Quickl when it's time to generate documentation of `cmd`.
+      # 
+      def call(cmd, options = {})
+        if File.exists?(file = find_file(cmd))
+          text = File.read(file)
+
+          # Replace occurences of #{signature} to #{signature.to_xxx}
+          # according to options
+          method = (options[:method] || "shell").to_s
+          text = text.gsub('#(signature)', '#(signature.to_' + method + ')')
+
+          # Replace occurences of #{...} on single lines
+          text = text.gsub(/^([ \t]*)#\(([^\)]+)\)/){|match| 
+            spacing, invocation  = $1, $2
+            res = cmd.instance_eval(invocation).to_s
+            realign(res, spacing, true)
+          }
+
+          # Replace occurences of #{...} in other places
+          text = text.gsub(/#\(([^\)]+)\)/){|match| 
+            cmd.instance_eval($1).to_s
+          }
+
+          # Replace occurences of !{...} by the execution of the example
+          text = text.gsub(/^([ \t]*)!\(([^\)]+)\)/){|match| 
+            spacing, invocation  = $1, $2
+            args = Quickl.parse_commandline_args(invocation)[1..-1]
+            op   = Alf.lispy(Alf::Environment.examples).run(args)
+            res  = op.to_rel.to_s
+            res  = realign(res, spacing, false)[0...-1]
+            if options[:method] == :lispy
+              invocation = Tools.to_lispy(op)
+            end
+            realign("$ #{invocation}\n\n#{res}", spacing, false)
+          }
+
+        else
+          "Sorry, no documentation available for #{cmd.command_name}"
+        end
+      end
+
+      private 
+
+      def realign(txt, spacing, strip)
+        rx = strip ? /^[ \t]*/ : /^/
+        txt.gsub(rx, spacing)
+      end
+
+      def find_file(cmd)
+        where = if cmd.command?
+          "commands"
+        elsif cmd.operator? && cmd.relational?
+          File.join("operators", "relational")
+        elsif cmd.operator? && cmd.non_relational?
+          File.join("operators", "non_relational")
+        else 
+          raise "Unexpected command #{cmd}"
+        end
+        File.join(DOC_FOLDER, where, "#{cmd.command_name}.md")
+      end
+
+    end # class DocManager
+  end # module Command
+end # module Alf

data/lib/alf/command/exec.rb

@@ -0,0 +1,12 @@
+module Alf
+  module Command
+    class Exec < Alf::Command()
+      include Command
+      
+      def execute(args)
+        Reader.alf(args.first || $stdin, requester.environment)
+      end
+      
+    end # class Exec
+  end # module Command
+end # module Alf

data/lib/alf/command/help.rb

@@ -0,0 +1,31 @@
+module Alf
+  module Command
+    class Help < Alf::Command()
+      include Command
+      
+      # Let NoSuchCommandError be passed to higher stage
+      no_react_to Quickl::NoSuchCommand
+      
+      options do |opt|
+        @dialect = :shell
+        opt.on('--lispy', 
+               'Display operator signatures in lispy DSL') do
+          @dialect = :lispy
+        end
+        opt.on('--shell', 
+               'Display operator signatures in shell DSL') do
+          @dialect = :shell
+        end
+      end
+
+      # Command execution
+      def execute(args)
+        sup = Quickl.super_command(self)
+        sub = (args.size != 1) ? sup : Quickl.sub_command!(sup, args.first)
+        doc = sub.documentation(:method => @dialect)
+        puts doc
+      end
+      
+    end # class Help
+  end # module Command
+end # module Alf

data/lib/alf/command/main.rb

@@ -0,0 +1,146 @@
+module Alf
+  module Command
+    class Main < Alf::Delegator()
+      include Command
+    
+      module ClassMethods
+
+        def relational_operators(sort_by_name = false)
+          ops = subcommands.select{|cmd| 
+             cmd.include?(Alf::Operator::Relational) &&
+            !cmd.include?(Alf::Operator::Experimental)
+          }
+          sort_operators(ops, sort_by_name)
+        end
+
+        def experimental_operators(sort_by_name = false)
+          ops = subcommands.select{|cmd| 
+            cmd.include?(Alf::Operator::Relational) &&
+            cmd.include?(Alf::Operator::Experimental)
+          }
+          sort_operators(ops, sort_by_name)
+        end
+
+        def non_relational_operators(sort_by_name = false)
+          ops = subcommands.select{|cmd| 
+            cmd.include?(Alf::Operator::NonRelational)
+          }
+          sort_operators(ops, sort_by_name)
+        end
+
+        def other_non_relational_commands(sort_by_name = false)
+          ops = subcommands.select{|cmd| 
+            cmd.include?(Alf::Command)
+          }
+          sort_operators(ops, sort_by_name)
+        end
+
+        private
+
+        def sort_operators(ops, sort_by_name)
+          sort_by_name ? ops.sort{|op1,op2| 
+            op1.command_name.to_s <=> op2.command_name.to_s
+          } : ops
+        end
+
+      end
+      extend(ClassMethods)
+
+      # Environment instance to use to get base iterators
+      attr_accessor :environment
+
+      # The reader to use when stdin is used as operand
+      attr_accessor :stdin_reader
+
+      # Output renderer
+      attr_accessor :renderer
+      
+      # Creates a command instance
+      def initialize(env = Environment.default)
+        @environment = env
+      end
+      
+      # Install options
+      options do |opt|
+        @execute = false
+        opt.on("-e", "--execute", "Execute one line of script (Lispy API)") do 
+          @execute = true
+        end
+        
+        @renderer = nil
+        Renderer.each_renderer do |name,descr,clazz|
+          opt.on("--#{name}", "Render output #{descr}"){ 
+            @renderer = clazz.new 
+          }
+        end
+        
+        opt.on('--env=ENV', 
+               "Set the environment to use") do |value|
+          @environment = Environment.autodetect(value)
+        end
+
+        @input_reader = :rash
+        readers = Reader.readers.collect{|r| r.first}
+        opt.on('--input-reader=READER', readers,
+               "Specify the kind of reader when reading on $stdin "\
+               "(#{readers.join(',')})") do |value|
+          @input_reader = value.to_sym
+        end
+        
+        opt.on("-Idirectory", 
+               "Specify $LOAD_PATH directory (may be used more than once)") do |val|
+          $LOAD_PATH.unshift val
+        end
+
+        opt.on('-rlibrary', 
+               "Require the library, before executing alf") do |value|
+          require(value)
+        end
+        
+        opt.on_tail('-h', "--help", "Show help") do
+          raise Quickl::Help
+        end
+        
+        opt.on_tail('-v', "--version", "Show version") do
+          raise Quickl::Exit, "alf #{Alf::VERSION}"\
+                              " (c) 2011, Bernard Lambeau"
+        end
+      end # Alf's options
+
+      # 
+      # Returns the $stdin Reader to use, according to the 
+      # --input-reader= option
+      #
+      def stdin_reader
+        @stdin_reader || Reader.send(@input_reader, $stdin)
+      end
+
+      #
+      # Executes the command on an array of arguments.
+      #
+      def execute(argv)
+        # 1) special case where a .alf file is provided
+        if argv.empty? or (argv.size == 1 && File.exists?(argv.first))
+          argv.unshift("exec")
+        end
+
+        # 2) build the operator according to -e option
+        operator = if @execute
+          Alf.lispy(environment).compile(argv.first)
+        else
+          super
+        end
+        
+        # 3) if there is a requester, then we do the job (assuming bin/alf)
+        # with the renderer to use. Otherwise, we simply return built operator
+        if operator && requester
+          renderer = self.renderer ||= Renderer::Rash.new
+          renderer.pipe(operator, environment).execute($stdout)
+        else
+          operator
+        end
+      end
+      
+    end # class Main
+  end # module Command
+end # module Alf

data/lib/alf/command/show.rb

@@ -0,0 +1,33 @@
+module Alf
+  module Command
+    class Show < Alf::Command()
+      include Command
+    
+      options do |opt|
+        @renderer = nil
+        Renderer.each_renderer do |name,descr,clazz|
+          opt.on("--#{name}", "Render output #{descr}"){ 
+            @renderer = clazz.new 
+          }
+        end
+      end
+        
+      def execute(args)
+        requester.renderer = (@renderer || requester.renderer || Text::Renderer.new)
+        args = [ stdin_reader ] if args.empty?
+        args.first
+      end
+    
+      private 
+
+      def stdin_reader
+        if requester && requester.respond_to?(:stdin_reader)
+          requester.stdin_reader
+        else 
+          Reader.coerce($stdin)
+        end
+      end
+
+    end # class Show
+  end # module Command
+end # module Alf