alf 0.10.1 → 0.11.0

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

@@ -0,0 +1,35 @@
+module Alf
+  module Engine
+    class Summarize::Hash < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrList] Summarization key
+      attr_reader :by
+
+      # @return [Summarization] The summarization to use
+      attr_reader :summarization
+
+      # @return [Boolean] Make an allbut summarization?
+      attr_reader :allbut
+
+      # Creates an Aggregate instance
+      def initialize(operand, by, summarization, allbut)
+        @operand = operand
+        @by = by
+        @summarization = summarization
+        @allbut = allbut
+      end
+
+      # (see Cog#each)
+      def each
+        index = Materialize::Hash.new(operand, by, allbut)
+        index.each_pair do |k, v|
+          yield k.merge(summarization.summarize(v))
+        end
+      end
+
+    end # class Summarize::Cesure
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,8 @@
+module Alf
+  module Engine
+    module Summarize
+    end # module Summarize
+  end # module Engine
+end # module Alf
+require_relative 'summarize/cesure'
+require_relative 'summarize/hash'

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

@@ -0,0 +1,29 @@
+module Alf
+  module Engine
+    class Ungroup < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrName] Relation-valued attribute to ungroup
+      attr_reader :attribute
+
+      # Creates a Ungroup instance
+      def initialize(operand, attribute)
+        @operand = operand
+        @attribute = attribute
+      end
+
+      # (see Cog#each)
+      def each
+        operand.each do |tuple|
+          tuple = tuple.dup
+          tuple.delete(@attribute).each do |subtuple|
+            yield tuple.merge(subtuple)
+          end
+        end
+      end
+
+    end # class Ungroup
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,31 @@
+module Alf
+  module Engine
+    #
+    # Unwraps a tuple attribute
+    #
+    class Unwrap < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrName] Name of the attribute to unwrap
+      attr_reader :attribute
+
+      # Creates a SetAttr instance
+      def initialize(operand, attribute)
+        @operand = operand
+        @attribute = attribute
+      end
+
+      # (see Cog#each)
+      def each
+        operand.each do |tuple|
+          tuple = tuple.dup
+          tuple.merge!(tuple.delete(@attribute) || {})
+          yield tuple
+        end
+      end
+
+    end # class Unwrap
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,39 @@
+module Alf
+  module Engine
+    #
+    # Wraps attributes under as a sub-tuple
+    #
+    class Wrap < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrList] Attributes to wrap
+      attr_reader :attributes
+
+      # @return [AttrName] Name of the introduced wrapped attribute
+      attr_reader :as
+
+      # @return [Boolean] Allbut wrapping?
+      attr_reader :allbut
+
+      # Creates a SetAttr instance
+      def initialize(operand, attributes, as, allbut)
+        @operand = operand
+        @attributes = attributes
+        @as = as
+        @allbut = allbut
+      end
+
+      # (see Cog#each)
+      def each
+        operand.each do |tuple|
+          rest, key = @attributes.split_tuple(tuple, @allbut)
+          key[@as] = rest
+          yield key
+        end
+      end
+
+    end # class Wrap
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,25 @@
+require_relative 'engine/cog'
+require_relative 'engine/cesure'
+require_relative 'engine/autonum'
+require_relative 'engine/clip'
+require_relative 'engine/coerce'
+require_relative 'engine/generator'
+require_relative 'engine/compact'
+require_relative 'engine/defaults'
+require_relative 'engine/sort'
+require_relative 'engine/set_attr'
+require_relative 'engine/filter'
+require_relative 'engine/concat'
+require_relative 'engine/aggregate'
+require_relative 'engine/rename'
+require_relative 'engine/materialize'
+require_relative 'engine/group'
+require_relative 'engine/join'
+require_relative 'engine/semi'
+require_relative 'engine/wrap'
+require_relative 'engine/unwrap'
+require_relative 'engine/summarize'
+require_relative 'engine/rank'
+require_relative 'engine/quota'
+require_relative 'engine/ungroup'
+

data/lib/{alf/extra/logs.rb → alf-logs/alf/logs/reader.rb}

@@ -1,24 +1,23 @@
 module Alf
   module Logs
-        
     #
     # Implements Alf::Reader contract for reading log files.
     #
     class Reader < Alf::Reader
-      
+
       DEFAULT_OPTIONS = {
         :file_format => nil,
         :line_def    => :access
       }
-      
+
       attr_reader :options
-      
+
       def initialize(*args)
         Alf::Tools::friendly_require('request_log_analyzer')
         super(*args)
         @options[:file_format] = coerce_file_format(@options[:file_format])
       end
-      
+
       def each
         parser = infer_parser(input_path)
         with_input_io do |io|
@@ -27,9 +26,9 @@ module Alf
           end
         end
       end
-      
+
       private
-      
+
       def coerce_file_format(file_format)
         case file_format
         when NilClass
@@ -44,7 +43,7 @@ module Alf
           raise ArgumentError, "Invalid file format: #{file_format}"
         end
       end
-      
+
       def infer_parser(path)
         file_format = @options[:file_format] || begin
           unless path
@@ -54,11 +53,11 @@ module Alf
         end
         RequestLogAnalyzer::Source::LogParser.new(file_format)
       end
-      
+
       def request_to_tuple(req)
         req.attributes
       end
-      
+
       LOG_TYPES = {
         # RequestLogAnalyzer::Request::Converters
         :string          => String,
@@ -81,20 +80,19 @@ module Alf
         # MySQL
         :sql             => String
       }
-      
+
       def infer_heading(format, line_def = :access)
         h = Hash[format.line_definitions[line_def].captures.collect{|capt|
           [ capt[:name], to_type(capt[:type]) ]
         }]
         Alf::Heading.new(h)
       end
-      
+
       def to_type(log_type)
         LOG_TYPES[log_type] || String
       end
-      
-      ::Alf::Reader.register(:logs, [".log"], self)
+
+      Alf::Reader.register(:logs, [".log"], self)
     end # class Reader
-    
   end # module Logs
-end # module Alf
+end # module Alf

data/lib/alf-logs/alf/logs.rb

@@ -0,0 +1 @@
+require_relative 'logs/reader'

data/lib/alf-sequel/alf/sequel/environment.rb

@@ -0,0 +1,57 @@
+module Alf
+  module Sequel
+    #
+    # Specialization of Alf::Environment to distribute Sequel datasets
+    #
+    class Environment < ::Alf::Environment
+
+      class << self
+
+        # (see Alf::Environment.recognizes?)
+        #
+        # @return true if args contains one String that can be interpreted as
+        # a valid database uri, false otherwise
+        def recognizes?(args)
+          require 'uri'
+          if args.size == 1 and args.first.is_a?(String)
+            uri = URI::parse(args.first)
+            !!uri.scheme or looks_a_sqlite_file?(args.first)
+          else
+            false
+          end
+        rescue ::URI::Error
+          false
+        end
+
+        # Returns trus if `f` looks like a sqlite file
+        def looks_a_sqlite_file?(f)
+          File.file?(f) and File.extname(f) == ".db"
+        end
+
+      end # class << self
+
+      # Creates an Environment instance
+      def initialize(uri, options = {})
+        @uri = self.class.looks_a_sqlite_file?(uri) ? "sqlite://#{uri}" : uri
+        @options = options
+      end
+
+      # (see Alf::Environment#dataset)
+      def dataset(name)
+        Iterator.new(connect[name])
+      end
+
+      private 
+
+      # Creates a database connection
+      def connect
+        @db ||= begin
+          Alf::Tools::friendly_require('sequel')
+          ::Sequel.connect(@uri, @options)
+        end
+      end
+
+      Alf::Environment.register(:sequel, self)
+    end # class Environment
+  end # module Sequel
+end # module Alf

data/lib/alf-sequel/alf/sequel/iterator.rb

@@ -0,0 +1,21 @@
+module Alf
+  module Sequel
+    #
+    # Specialization of Alg::Iterator to work on a Sequel dataset
+    #
+    class Iterator
+      include Alf::Iterator
+
+      # Creates an iterator instance
+      def initialize(dataset)
+        @dataset = dataset
+      end
+
+      # (see Alf::Iterator#each)
+      def each
+        @dataset.each(&Proc.new)
+      end
+
+    end # class Iterator
+  end # module Sequel
+end # module Alf

data/lib/alf-sequel/alf/sequel.rb

@@ -0,0 +1,2 @@
+require_relative 'sequel/environment'
+require_relative 'sequel/iterator'

data/lib/{alf → alf-shell/alf/shell}/command/exec.rb

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

data/lib/{alf → alf-shell/alf/shell}/command/help.rb

@@ -1,7 +1,6 @@
 module Alf
-  module Command
-    class Help < Alf::Command()
-      include Command
+  module Shell
+    class Help < Shell::Command()
       
       # Let NoSuchCommandError be passed to higher stage
       no_react_to Quickl::NoSuchCommand
@@ -27,5 +26,5 @@ module Alf
       end
       
     end # class Help
-  end # module Command
+  end # module Shell
 end # module Alf

data/lib/alf-shell/alf/shell/command/main/class_methods.rb

@@ -0,0 +1,46 @@
+module Alf
+  module Shell
+    class Main
+      module ClassMethods
+
+        def relational_operators(sort_by_name = false)
+          ops = subcommands.select{|cmd|
+             cmd.operator? and cmd.relational? and !cmd.experimental?
+          }
+          sort_operators(ops, sort_by_name)
+        end
+
+        def experimental_operators(sort_by_name = false)
+          ops = subcommands.select{|cmd| 
+            cmd.operator? and cmd.relational? and cmd.experimental?
+          }
+          sort_operators(ops, sort_by_name)
+        end
+
+        def non_relational_operators(sort_by_name = false)
+          ops = subcommands.select{|cmd| 
+            cmd.operator? and !cmd.relational?
+          }
+          sort_operators(ops, sort_by_name)
+        end
+
+        def other_non_relational_commands(sort_by_name = false)
+          ops = subcommands.select{|cmd| 
+            cmd.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)
+    end # class Main
+  end # module Shell
+end # module Alf

data/lib/{alf → alf-shell/alf/shell}/command/main.rb

@@ -1,51 +1,7 @@
 module Alf
-  module Command
-    class Main < Alf::Delegator()
-      include Command
+  module Shell
+    class Main < Shell::Delegator()
     
-      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
 
@@ -139,13 +95,14 @@ module Alf
         else
           super
         end
-        
+        operator = Iterator.coerce(operator, environment) if operator
+
         # 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_class = self.renderer_class ||= Renderer::Rash
-          renderer = renderer_class.new(rendering_options)
-          renderer.pipe(operator, environment).execute($stdout)
+          renderer_class = (self.renderer_class ||= Renderer::Rash)
+          renderer = renderer_class.new(operator, rendering_options)
+          renderer.execute($stdout)
         else
           operator
         end
@@ -174,5 +131,6 @@ module Alf
       end
       
     end # class Main
-  end # module Command
+  end # module Shell
 end # module Alf
+require_relative 'main/class_methods'

data/lib/{alf → alf-shell/alf/shell}/command/show.rb

@@ -1,7 +1,6 @@
 module Alf
-  module Command
-    class Show < Alf::Command()
-      include Command
+  module Shell
+    class Show < Shell::Command()
     
       options do |opt|
         @renderer_class = nil
@@ -39,12 +38,11 @@ module Alf
         # normalize args
         args = argv.first
         args = [ stdin_reader ] if args.empty?
-        chain = args.first
+        chain = Iterator.coerce(args.first, requester && requester.environment)
 
         # put a sorter
         if argv[1]
-          sorter = Alf::Operator::NonRelational::Sort.new(argv[1])
-          chain  = sorter.pipe(chain, requester.environment)
+          chain = Alf::Operator::NonRelational::Sort.new([chain], argv[1])
         end
 
         chain
@@ -61,5 +59,5 @@ module Alf
       end
 
     end # class Show
-  end # module Command
+  end # module Shell
 end # module Alf

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

@@ -0,0 +1,26 @@
+module Alf
+  module Command
+    module ClassMethods
+
+      # Returns the ruby case name of this operator
+      def rubycase_name 
+        Tools.ruby_case(Tools.class_name(self))
+      end
+
+      # @return true
+      def command?
+        true
+      end
+    
+      # @return false
+      def operator?
+        false
+      end
+    
+    end # module ClassMethods
+  end # module Command
+end # module Alf
+require_relative 'command/main'
+require_relative 'command/exec'
+require_relative 'command/help'
+require_relative 'command/show'

data/lib/{alf/command → alf-shell/alf/shell}/doc_manager.rb

@@ -1,9 +1,9 @@
 module Alf
-  module Command
+  module Shell
     class DocManager
 
       # Main documentation folder
-      DOC_FOLDER = File.expand_path('../../../../doc/', __FILE__)
+      DOC_FOLDER = File.expand_path('../../../../../doc/', __FILE__)
 
       #
       # Called by Quickl when it's time to generate documentation of `cmd`.
@@ -68,5 +68,5 @@ module Alf
       end
 
     end # class DocManager
-  end # module Command
+  end # module Shell
 end # module Alf

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

@@ -0,0 +1,86 @@
+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