alf 0.12.2 → 0.13.0

data/lib/alf/operator/relational/restrict.rb

@@ -1,18 +0,0 @@
-module Alf
-  module Operator
-    module Relational
-      class Restrict
-        include Relational, Unary
-
-        signature do |s|
-          s.argument :predicate, TuplePredicate, "true"
-        end
-
-        def compile
-          Engine::Filter.new(operand, predicate)
-        end
-
-      end # class Restrict
-    end # module Relational
-  end # module Operator
-end # module Alf

data/lib/alf/operator/relational/summarize.rb

@@ -1,27 +0,0 @@
-module Alf
-  module Operator
-    module Relational
-      class Summarize
-        include Relational, Unary
-
-        signature do |s|
-          s.argument :by,            AttrList, []
-          s.argument :summarization, Summarization, {}
-          s.option   :allbut,        Boolean, false, "Summarize on all but specified attributes?"
-        end
-
-        # (see Operator#compile)
-        def compile
-          if @allbut
-            Engine::Summarize::Hash.new(operand, by, summarization, allbut)
-          else
-            op = Engine::Sort.new(operand, by.to_ordering)
-            op = Engine::Summarize::Cesure.new(op, by, summarization, allbut)
-            op
-          end
-        end
-  
-      end # class Summarize
-    end # module Relational
-  end # module Operator
-end # module Alf

data/lib/alf/operator/relational/ungroup.rb

@@ -1,19 +0,0 @@
-module Alf
-  module Operator
-    module Relational
-      class Ungroup
-        include Relational, Unary
-
-        signature do |s|
-          s.argument :attribute, AttrName, :grouped
-        end
-
-        # (see Operator#compile)
-        def compile
-          Engine::Ungroup.new(operand, attribute)
-        end
-
-      end # class Ungroup
-    end # module Relational
-  end # module Operator
-end # module Alf

data/lib/alf/operator/relational/union.rb

@@ -1,20 +0,0 @@
-module Alf
-  module Operator
-    module Relational
-      class Union
-        include Relational, Binary
-
-        signature do |s|
-        end
-
-        # (see Operator#compile)
-        def compile
-          op = Engine::Concat.new([left, right])
-          op = Engine::Compact.new(op)
-          op
-        end
-
-      end # class Union
-    end # module Relational
-  end # module Operator
-end # module Alf

data/lib/alf/operator/relational/unwrap.rb

@@ -1,19 +0,0 @@
-module Alf
-  module Operator
-    module Relational
-      class Unwrap
-        include Relational, Unary
-
-        signature do |s|
-          s.argument :attribute, AttrName, :wrapped
-        end
-
-        # (see Operator#compile)
-        def compile
-          Engine::Unwrap.new(operand, attribute)
-        end
-
-      end # class Unwrap
-    end # module Relational
-  end # module Operator
-end # module Alf

data/lib/alf/operator/relational/wrap.rb

@@ -1,20 +0,0 @@
-module Alf
-  module Operator
-    module Relational
-      class Wrap
-        include Relational, Unary
-
-        signature do |s|
-          s.argument :attributes, AttrList, []
-          s.argument :as, AttrName, :wrapped
-        end
-
-        # (see Operator#compile)
-        def compile
-          Engine::Wrap.new(operand, attributes, as, false)
-        end
-
-      end # class Wrap
-    end # module Relational
-  end # module Operator
-end # module Alf

data/lib/alf/operator/signature.rb

@@ -1,233 +0,0 @@
-module Alf
-  module Operator
-    # Provides an operator signature
-    class Signature
-
-      # @return [Class] the operator class to which this signature belongs
-      attr_reader :operator
-
-      # @return [Array] signature arguments
-      attr_reader :arguments
-
-      # @return [Array] signature options
-      attr_reader :options
-
-      # Creates an empty signature instance
-      #
-      # @param [Class] the operator class to which this signature belongs
-      def initialize(operator)
-        @operator = operator
-        @arguments = []
-        @options = []
-        yield(self) if block_given?
-      end
-
-      # Adds an argument to the signature
-      #
-      # @param [Symbol] name argument name
-      # @param [Class] domain argument domain
-      # @param [Object] default (optional) default value
-      def argument(name, domain, default = nil, descr = nil)
-        arguments << [name, domain, default, descr]
-      end
-
-      # Adds an option to the signature
-      # 
-      # @param [Symbol] name argument name
-      # @param [Class] domain argument domain
-      # @param [Object] default (optional) default value
-      def option(name, domain, default = nil, descr = nil)
-        options << [name, domain, default, descr]
-      end
-
-      # Builds an option parser instance `opt` prepared for installing options on
-      # `receiver`.
-      #
-      # @param [Hash|Operator] a receiver for option values
-      # @param [OptionParser] opt the parser to fill with options
-      # @return [OptionParser] `opt`
-      def option_parser(receiver, opt = OptionParser.new)
-        options.each do |option|
-          name, dom, defa, descr = option
-          opt.on(option_name(option), descr || "") do |val|
-            if receiver.is_a?(Hash)
-              receiver[name] = val
-            else
-              receiver.send(:"#{name}=", val)
-            end
-          end
-        end
-        opt
-      end
-
-      # Installs the signature on the operator class
-      #
-      # This method installs an attr reader and an attr writer for each
-      # signature argument and each signature option.
-      #
-      # @return [Hash] the default options to use
-      def install
-        clazz = operator
-        code = (arguments + options).each{|siginfo|
-          name, domain, = siginfo
-          clazz.send(:attr_reader, name)
-          clazz.send(:define_method, :"#{name}=") do |val|
-            instance_variable_set(:"@#{name}", Tools.coerce(val, domain))
-          end
-          clazz.send(:private, :"#{name}=")
-        }
-        default_options
-      end
-
-      # Parses arguments `args` passed to the operator `initialize` and 
-      # sets attributes accordingly on `receiver`.
-      #
-      # @param [Array] args an array of initialize arguments
-      # @param [Operator] receiver an operator instance
-      # @return [Operator] installed `receiver`
-      def parse_args(args, receiver)
-
-        # 1) Check and set operands, passed as an array as first argument
-        invalid_args!(args) unless args.first.is_a?(Array)
-        receiver.operands = args.shift
-
-        # 2) Extract options if provided
-        optargs = default_options
-        if args.size == (1+arguments.size)
-          # options are passed as last argument
-          invalid_args!(args) unless args.last.is_a?(Hash)
-          optargs = optargs.merge(args.pop)
-        elsif args.size > arguments.size
-          # too many arguments here
-          invalid_args!(args)
-        end
-
-        # 3) Set options now, including default ones
-        optargs.each_pair do |name,val|
-          receiver.send(:"#{name}=", val)
-        end
-        
-        # 4) Parse other arguments now
-        with_each_arg(args) do |name,dom,value|
-          invalid_args!(args) if value.nil?
-          receiver.send(:"#{name}=", value)
-        end
-
-        receiver
-      end
-
-      # Converts commandline arguments to operator constructor arguments
-      def argv2args(argv)
-        # First split over --
-        argv = Quickl.split_commandline_args(argv)
-
-        # Parse the options and replace argv[0] by remaining arguments
-        opts = {}
-        argv[0] = option_parser(opts).parse!(argv[0])
-        opts = default_options.merge(opts)
-
-        # Operands are argv[0], and can be removed
-        oper = argv.shift
-
-        # Coerce each remaining argument according to the signature
-        args = []
-        with_each_arg(argv) do |name,dom,value|
-          invalid_args!(args) if value.nil?
-          args << dom.from_argv(Array(value))
-        end
-
-        [oper, args, opts]
-      end
-
-      # Collects signature values on a given operator.
-      #
-      # This methods returns a triple `[datasets, arguments, options]` with
-      # the respective values collected on `op`.
-      #
-      # @param [Operator] op an operator, which should be an instance of 
-      #                   `self.operator`
-      # @return [Array] a triple [datasets, arguments, options] with operands, 
-      #                 then signature values
-      def collect_on(op)
-        oper = op.operands
-        args = arguments.map{|name,_| op.send(name) }
-        opts = Hash[options.map{|name,dom,defa,_| 
-          val = op.send(name)
-          (val == defa) ? nil : [name, val]
-        }.compact]
-        [oper, args, opts]
-      end
-
-      # Returns a lispy synopsis for this signature
-      #
-      # Example:
-      #
-      #     Alf::Operator::Relational::Project.signature.to_shell
-      #     # => "(project operand, attributes:AttrList, {allbut: Boolean})"
-      def to_lispy
-        cmd  = operator.rubycase_name
-        oper = operator.nullary? ? "" :
-              (operator.unary? ? "operand" : "left, right")
-
-        args = arguments.collect{|name,dom,_| 
-          dom.to_s =~ /::([A-Za-z]+)$/
-          "#{name}:#{$1}" 
-        }.join(", ")
-        args = (args.empty? ? "#{oper}" : "#{oper}, #{args}").strip
-
-        opts = options.collect{|name,dom,_|
-          dom.to_s =~ /::([A-Za-z]+)$/
-          "#{name}: #{$1}" 
-        }.join(', ')
-        opts = opts.empty? ? "" : "{#{opts}}"
-
-        argopt = [args, opts].select{|s| !s.empty?}.join(', ')
-        "(#{cmd} #{argopt}".strip + ")"
-      end
-
-      # Returns a shell synopsis for this signature.
-      #
-      # Example:
-      #
-      #     Alf::Operator::Relational::Project.signature.to_shell
-      #     # => "alf project [--allbut] [OPERAND] -- ATTRIBUTES"
-      def to_shell
-        oper = operator.nullary? ? "" :
-              (operator.unary? ? "[OPERAND]" : "[LEFT] RIGHT")
-        opts =   options.collect{|opt|   "[#{option_name(opt)}]" }.join(" ")
-        args = arguments.collect{|arg,_| "#{arg.to_s.upcase}"    }.join(" -- ")
-        optargs = "#{opts} #{oper} " + (args.empty? ? "" : "-- #{args}")
-        "alf #{operator.rubycase_name} #{optargs.strip}".strip
-      end
-
-      private
-
-      # @return the default options as a Hash
-      def default_options
-        @default_options ||=
-          Hash[options.select{|opt| !opt[2].nil? }.
-                       map{|opt| [opt[0], opt[2]]}]
-      end
-
-      # @return the name to use in shell for `option`
-      def option_name(option)
-        name, domain, defa, = option
-        domain == Boolean ? "--#{name}" : "--#{name}=#{name.to_s.upcase}"
-      end
-
-      # Yields `(name,dom,value)` triples for each argument value
-      def with_each_arg(args)
-        arguments.zip(args).collect do |sigpart,subargs|
-          name, dom, default = sigpart
-          val = Array(subargs).empty? ? default : subargs
-          yield(name, dom, val)
-        end
-      end
-
-      def invalid_args!(args, msg = "Invalid `#{args.inspect}` for #{self}")
-        raise ArgumentError, msg, caller
-      end
-
-    end # class Signature
-  end # module Operator
-end # module Alf

data/lib/alf/operator/unary.rb

@@ -1,16 +0,0 @@
-module Alf
-  module Operator
-    # 
-    # Specialization of Operator for operators that work on a unary input
-    #
-    module Unary
-      include Operator 
-
-      # Simply returns the first operand
-      def operand
-        operands.first
-      end
-
-    end # module Unary
-  end # module Operator
-end # module Alf

data/lib/alf/reader.rb

@@ -1,37 +0,0 @@
-module Alf
-  #
-  # Implements an Iterator at the interface with the outside world.
-  #
-  # The contrat of a Reader is simply to be an Iterator. Unlike operators, 
-  # however, readers are not expected to take other iterators as input, but IO 
-  # objects, database tables, or something similar instead. This base class 
-  # provides a default behavior for readers that works with IO objects. It can 
-  # be safely extended, overriden, or even mimiced (provided that you include 
-  # and implement the Iterator contract).
-  #
-  # This class also provides a registration mechanism to help getting Reader 
-  # instances for specific file extensions. A typical scenario for using this
-  # registration mechanism is as follows:
-  #
-  #   # Registers a reader kind named :foo, associated with ".foo" file 
-  #   # extensions and the FooFileDecoder class (typically a subclass of 
-  #   # Reader)
-  #   Reader.register(:foo, [".foo"], FooFileDecoder)   
-  #
-  #   # Later on, you can request a reader instance for a .foo file, as 
-  #   # illustrated below.  
-  #   r = Reader.reader('/a/path/to/a/file.foo')
-  #
-  #   # Also, a factory method is automatically installed on the Reader class
-  #   # itself. This factory method can be used with a String, or an IO object.
-  #   r = Reader.foo([a path or a IO object])
-  #
-  class Reader
-    include Iterator
-
-    require 'alf/reader/class_methods'
-    require 'alf/reader/instance_methods'
-    require 'alf/reader/rash'
-    require 'alf/reader/alf_file'
-  end # class Reader
-end # module Alf

data/lib/alf/reader/alf_file.rb

@@ -1,24 +0,0 @@
-module Alf
-  class Reader
-    #
-    # Specialization of the Reader contract for .alf files.
-    #
-    # A .alf file simply contains a query expression in the Lispy DSL. This
-    # reader decodes and compiles the expression and delegates the enumeration
-    # to the obtained operator.
-    #
-    # Note that an Environment must be wired at creation time. A 
-    # NoSuchDatasetError will certainly occur otherwise.
-    #
-    class AlfFile < Reader
-
-      # (see Reader#each)
-      def each
-        op = Alf.lispy(environment).compile(input_text, input_path)
-        op.each(&Proc.new)
-      end
-
-      Reader.register(:alf, [".alf"], self)
-    end # module AlfFile
-  end # class Reader
-end # module Alf

data/lib/alf/reader/class_methods.rb

@@ -1,91 +0,0 @@
-module Alf
-  class Reader
-    module ClassMethods
-
-      # @return [Array<Reader>] registered readers
-      def readers
-        @readers ||= []
-      end
-
-      # Registers a reader class associated with specific file extensions.
-      #
-      # Registered class must provide a constructor with the following signature 
-      # `new(path_or_io, environment = nil, options = {})`. The registration 
-      # name must be a symbol which can safely be used as a ruby method name. 
-      # A factory method of that name and signature is automatically installed 
-      # on the Reader class.
-      #
-      # @param [Symbol] name a name for the kind of data decoded
-      # @param [Array] extensions file extensions mapped to the registered reader 
-      #                class (should include the '.', e.g. '.foo')
-      # @param [Class] class Reader subclass used to decode this kind of files
-      def register(name, extensions, clazz)
-        readers << [name, extensions, clazz]
-        (class << self; self; end).
-          send(:define_method, name) do |*args|
-            clazz.new(*args)
-          end
-      end
-
-      # When filepath looks like a String or a path, returns a reader instance 
-      # for the source it denotes. Otherwise, delegates the call to 
-      # `coerce(filepath)`.
-      #
-      # @param [:to_str|:to_path] filepath path to a file for which extension 
-      #        is recognized
-      # @param [Array] args optional additional arguments that must be passed at
-      #        reader's class new method.
-      # @return [Reader] a reader instance built from arguments
-      # @raise [ArgumentError] if `filepath` is not recognized or no reader can
-      #        be found for this extension.
-      def reader(filepath, *args)
-        if looks_a_path?(filepath)
-          ext = File.extname(filepath.to_s)
-          has_reader_for_ext!(ext).new(filepath.to_s, *args)
-        elsif args.empty?
-          coerce(filepath)
-        else
-          raise ArgumentError, "Unable to return a reader for #{filepath} and #{args}" 
-        end
-      end
-
-      # Coerces `arg` to a Reader instance, using an optional environment to 
-      # convert named datasets.
-      #
-      # This method automatically provides readers for Strings and Symbols 
-      # through `environment` (**not** through the reader factory) and for IO 
-      # objects through a Rash reader.
-      #
-      # @param [Object] arg any value to coerce to a Reader instance
-      # @param [Environment] environment to resolved named datasets (optional)
-      def coerce(arg, environment = nil)
-        case arg
-        when Reader
-          arg
-        when IO, StringIO
-          rash(arg, environment)
-        else
-          raise ArgumentError, "Unable to coerce #{arg.inspect} to a reader"
-        end
-      end
-
-      private
-
-      # Checks if `path` looks like a usable path
-      def looks_a_path?(path)
-        return false if path.is_a?(StringIO) 
-        path.respond_to?(:to_str) or path.respond_to?(:to_path)
-      end
-
-      # @return [Class] the reader class to use for `ext` file extension.
-      # @raise [ArgumentError] if no such reader class can be found
-      def has_reader_for_ext!(ext)
-        entry = readers.find{|r| r[1].include?(ext)}
-        return entry[2] if entry
-        raise ArgumentError, "No registered reader for #{ext}"
-      end
-
-    end # module ClassMethods
-    extend(ClassMethods)
-  end # class Reader
-end # module Alf