alf 0.12.2 → 0.13.0

data/lib/alf-shell/alf/shell/doc_manager.rb

@@ -1,72 +0,0 @@
-module Alf
-  module Shell
-    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 Shell
-end # module Alf

data/lib/alf-shell/alf/shell/operator.rb

@@ -1,86 +0,0 @@
-module Alf
-  module Shell
-    module Operator
-      module ClassMethods
-
-        attr_accessor :operator_class
-
-        # Returns the ruby case name of this operator
-        def rubycase_name 
-          Tools.ruby_case(Tools.class_name(self))
-        end
-        
-        # @return false
-        def command?
-          false
-        end
-
-        # @return true
-        def operator?
-          true
-        end
-
-        # delegation to the class        
-        [ :signature, 
-          :relational?, :non_relational?, :experimental?,
-          :nullary?, :unary?, :binary? ].each do |meth|
-          define_method(meth) do |*args, &block|
-            operator_class.send(meth, *args, &block)
-          end
-        end
-        
-        # Runs the command on commandline arguments `argv`
-        #
-        # @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)
-          operands, args, options = signature.argv2args(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.map{|op| 
-            Iterator.coerce(op, req && req.environment)
-          }
-          operands = if nullary?
-            []
-          elsif unary?
-            [operands.last]
-          elsif binary?
-            operands[-2..-1]
-          end
-
-          init_args = [operands] + args + [options]
-          operator_class.new(*init_args)
-        end
-
-      end # module ClassMethods
-
-      # Defines a command for `clazz`
-      def self.define_operator(clazz)
-        superclass = Shell::Operator() do |b|
-          b.callback do |cmd|
-            cmd.operator_class = clazz
-          end
-        end
-        Operator.const_set(Tools.class_name(clazz), Class.new(superclass)) 
-      end
-    
-      Alf::Operator::Relational.each do |op_class|
-        define_operator(op_class)
-      end
-    
-      Alf::Operator::NonRelational.each do |op_class|
-        define_operator(op_class)
-      end
-    
-    end
-  end
-end

data/lib/alf-yaml/alf/yaml.rb

@@ -1 +0,0 @@
-require_relative 'yaml/renderer'

data/lib/alf-yaml/alf/yaml/renderer.rb

@@ -1,22 +0,0 @@
-module Alf
-  module YAML
-    #
-    # Implements Alf::Renderer contract for outputing YAML files.
-    #
-    class Renderer < ::Alf::Renderer
-
-      protected 
-
-      # (see Alf::Renderer#render)
-      def render(input, output)
-         require "yaml"
-        # TODO: refactor this to avoid loading all tuples
-        # in memory
-        output << input.to_a.to_yaml << "\n"
-        output
-      end
-
-      Alf::Renderer.register(:yaml, "as a yaml output",  self)
-    end # class Renderer
-  end # module YAML
-end # module Alf

data/lib/alf/aggregator.rb

@@ -1,51 +0,0 @@
-module Alf
-  #
-  # Aggregation operator.
-  #
-  # This class provides a basis for implementing aggregation operators. It 
-  # should always be used as a superclass for such implementations. See 
-  # ClassMethods and InstanceMethods for implementing your own aggregation 
-  # operators.
-  #
-  # Aggregation operators are made available through factory methods on the 
-  # Aggregator class itself:
-  #
-  #     Aggregator.count
-  #     Aggregator.sum{ qty }
-  #
-  # The coercion method should always be used for building aggregators from 
-  # lispy source code:
-  #
-  #     Aggregator.coerce("count")
-  #     Aggregator.coerce("sum{ qty }")
-  #
-  # Once built, aggregators can be used either in black-box or white-box modes.
-  #
-  #     relation = ...
-  #     agg = Aggregator.sum{ qty }
-  #
-  #     # Black box mode:
-  #     result = agg.aggregate(relation)
-  #
-  #     # White box mode:
-  #     memo = agg.least
-  #     relation.each do |tuple|
-  #       memo = agg.happens(memo, tuple)
-  #     end
-  #     result = agg.finalize(memo)
-  #
-  class Aggregator
-    require 'alf/aggregator/class_methods'
-    require 'alf/aggregator/instance_methods'
-    require 'alf/aggregator/count'
-    require 'alf/aggregator/sum'
-    require 'alf/aggregator/min'
-    require 'alf/aggregator/max'
-    require 'alf/aggregator/avg'
-    require 'alf/aggregator/variance'
-    require 'alf/aggregator/stddev'
-    require 'alf/aggregator/collect'
-    require 'alf/aggregator/concat'
-
-  end # class Aggregator
-end # module Alf

data/lib/alf/aggregator/avg.rb

@@ -1,39 +0,0 @@
-module Alf
-  class Aggregator
-    #
-    # Defines a `avg()` aggregation operator.
-    #
-    # Example:
-    #
-    #   # direct ruby usage
-    #   Alf::Aggregator.avg{ qty }.aggregate(...)
-    #
-    #   # lispy 
-    #   (summarize :supplies, [:sid], :avg => avg{ qty })
-    #
-    class Avg < Aggregator
-
-      # Returns [0.0, 0.0] as least value.
-      #
-      # @see Aggregator::InstanceMethods#least
-      def least()
-        [0.0, 0.0]
-      end
-
-      # Aggregates on a tuple occurence.
-      #
-      # @see Aggregator::InstanceMethods#_happens
-      def _happens(memo, val) 
-        [memo.first + val, memo.last + 1]
-      end
-
-      # Finalizes the computation.
-      #
-      # @see Aggregator::InstanceMethods#finalize
-      def finalize(memo) 
-        memo.first / memo.last 
-      end
-
-    end # class Avg
-  end # class Aggregator
-end # module Alf

data/lib/alf/aggregator/class_methods.rb

@@ -1,77 +0,0 @@
-module Alf
-  class Aggregator
-    #
-    # This module installs class-level utilities of Alf's aggregators.
-    #
-    # Subclasses of Aggregator are automatically tracked so as to add
-    # factory methods on the Aggregator class itself. Example: 
-    #
-    #   class Sum < Aggregate   # will give a method Aggregator.sum
-    #     ...
-    #   end
-    #   Aggregator.sum{ size }
-    #
-    # All registered aggregators are available under `Aggregator.aggregators`
-    # Those aggregators may also be iterated as follows:
-    #
-    #   Alf::Aggregator.each do |agg_class|
-    #
-    #     # agg_class is a subclass of Aggregator
-    #
-    #   end
-    #
-    module ClassMethods
-
-      # Returns registered aggregators as an Array of classes
-      #
-      # @return [Array<Class>] The list of registered aggregator classes
-      def aggregators
-        @aggregators ||= []
-      end
-
-      # Yields each aggregator class in turn
-      def each
-        aggregators.each(&Proc.new)
-      end
-
-      # Automatically installs factory methods for inherited classes.
-      #
-      # @param [Class] clazz a class that extends Aggregator
-      def inherited(clazz)
-        basename = Tools.ruby_case(Tools.class_name(clazz))
-        Aggregator.module_eval do
-          aggregators << clazz
-        end
-        Aggregator.module_eval <<-EOF
-          def self.#{basename}(*args, &block)
-            #{clazz}.new(*args, &block)
-          end
-        EOF
-      end
-
-      # Coerces `arg` to an Aggregator
-      #
-      # Implemented coercions are:
-      # - Aggregator -> self
-      # - String     -> through factory methods on self
-      #
-      # @param [Object] arg a value to coerce to an aggregator
-      # @return [Aggregator] the coerced aggregator
-      # @raise [ArgumentError] if the coercion fails
-      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/aggregator/collect.rb

@@ -1,32 +0,0 @@
-module Alf
-  class Aggregator
-    #
-    # Defines a `collect()` aggregation operator.
-    #
-    # Example:
-    #
-    #   # direct ruby usage
-    #   Alf::Aggregator.collect{ qty }.aggregate(...)
-    #
-    #   # lispy 
-    #   (summarize :supplies, [:sid], :col => collect{ qty })
-    #
-    class Collect < Aggregator
-
-      # Returns [] as least value.
-      #
-      # @see Aggregator::InstanceMethods#least
-      def least()
-        []
-      end
-
-      # Aggregates on a tuple occurence.
-      #
-      # @see Aggregator::InstanceMethods#_happens
-      def _happens(memo, val) 
-        memo << val
-      end
-
-    end # class Collect
-  end # class Aggregator
-end # module Alf

data/lib/alf/aggregator/concat.rb

@@ -1,47 +0,0 @@
-module Alf
-  class Aggregator
-    #
-    # Defines a `concat()` aggregation operator.
-    #
-    # Example:
-    #
-    #   # direct ruby usage
-    #   Alf::Aggregator.concat{ qty }.aggregate(...)
-    #
-    #   # lispy 
-    #   (summarize :supplies, [:sid], :cat => concat{ qty })
-    #
-    class Concat < Aggregator
-
-      # Sets default options.
-      #
-      # @see Aggregator::InstanceMethods#default_options
-      def default_options
-        {:before => "", :after => "", :between => ""}
-      end
-
-      # Returns least value (defaults to "")
-      #
-      # @see Aggregator::InstanceMethods#least
-      def least()
-        ""
-      end
-
-      # Aggregates on a tuple occurence.
-      #
-      # @see Aggregator::InstanceMethods#_happens
-      def _happens(memo, val) 
-        memo << options[:between].to_s unless memo.empty?
-        memo << val.to_s
-      end
-
-      # Finalizes computation
-      #
-      # @see Aggregator::InstanceMethods#finalize
-      def finalize(memo)
-        options[:before].to_s + memo + options[:after].to_s
-      end
-
-    end # class Concat
-  end # class Aggregator
-end # module Alf

data/lib/alf/aggregator/count.rb

@@ -1,32 +0,0 @@
-module Alf
-  class Aggregator
-    #
-    # Defines a `count()` aggregation operator.
-    #
-    # Example:
-    #
-    #   # direct ruby usage
-    #   Alf::Aggregator.count.aggregate(...)
-    #
-    #   # lispy 
-    #   (summarize :supplies, [:sid], :num_orders => count)
-    #
-    class Count < Aggregator
-
-      # Returns 0 as least value.
-      #
-      # @see Aggregator::InstanceMethods#least
-      def least()
-        0
-      end
-
-      # Aggregates on a tuple occurence through `memo + 1`
-      #
-      # @see Aggregator::InstanceMethods#happens
-      def happens(memo, tuple) 
-        memo + 1
-      end
-
-    end # class Count
-  end # class Aggregator
-end # module Alf