alf 0.12.2 → 0.13.0

data/lib/alf/environment/instance_methods.rb

@@ -1,26 +0,0 @@
-module Alf
-  class Environment
-    #
-    # This methods provides base methods for implementing the Environment 
-    # contract. The Environment class already includes it and should be used
-    # as a superclass of specific implementations.
-    #
-    module InstanceMethods
-
-      # Returns a dataset whose name is provided.
-      #
-      # This method resolves named datasets to tuple enumerables. When the 
-      # dataset exists, this method must return an Iterator, typically a 
-      # Reader instance. Otherwise, it must throw a NoSuchDatasetError.
-      #
-      # @param [Symbol] name the name of a dataset
-      # @return [Iterator] an iterator, typically a Reader instance
-      # @raise [NoSuchDatasetError] when the dataset does not exists
-      def dataset(name)
-      end
-      undef :dataset
-
-    end # module InstanceMethods
-    include(InstanceMethods)
-  end # class Environment
-end # module Alf

data/lib/alf/errors.rb

@@ -1,5 +0,0 @@
-module Alf
-  class Error < StandardError; end
-  class NoSuchDatasetError < Error; end
-  class CoercionError < Error; end
-end

data/lib/alf/ext.rb

@@ -1,4 +0,0 @@
-unless defined?(ALF_NO_CORE_EXTENSIONS)
-  require 'alf/ext/relation'
-end
-

data/lib/alf/ext/relation.rb

@@ -1,4 +0,0 @@
-def Relation(*args)
-  Alf::Relation(*args)
-end
-

data/lib/alf/iterator.rb

@@ -1,28 +0,0 @@
-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_relation
-      Relation::new(self.to_set)
-    end
-    alias :to_rel :to_relation
-
-    require 'alf/iterator/class_methods'
-    require 'alf/iterator/proxy'
-  end # module Iterator
-end # module Alf

data/lib/alf/iterator/class_methods.rb

@@ -1,20 +0,0 @@
-module Alf
-  module Iterator
-    module ClassMethods
-
-      # Coerces something to an iterator
-      def coerce(arg, environment = nil)
-        case arg
-        when Iterator, Array
-          arg
-        when String, Symbol
-          Proxy.new(environment, arg.to_sym)
-        else
-          Reader.coerce(arg, environment)
-        end
-      end
-
-    end # module ClassMethods
-    extend(ClassMethods)
-  end # module Iterator
-end # module Alf

data/lib/alf/iterator/proxy.rb

@@ -1,27 +0,0 @@
-module Alf
-  module Iterator
-    class Proxy
-      include Iterator
-
-      # @return [Symbol] name of the dataset to request to environment
-      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, 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(@name).each(&block)
-      end
-
-    end # class Proxy
-  end # module Iterator
-end # module Alf

data/lib/alf/lispy.rb

@@ -1,24 +0,0 @@
-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/lispy/instance_methods.rb

@@ -1,157 +0,0 @@
-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)
-    #
-    # Example
-    #
-    #   # with a string
-    #   op = compile "(restrict :suppliers, lambda{ city == 'London' })"
-    #
-    #   # or with a block
-    #   op = compile {
-    #     (restrict :suppliers, lambda{ city == 'London' })
-    #   }
-    #
-    # @param [String] expr a Lispy expression to compile
-    # @return [Iterator] the iterator resulting from compilation
-    #
-    def compile(expr = nil, path = nil, &block)
-      if expr.nil? 
-        instance_eval(&block)
-      else 
-        b = _clean_binding
-        (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)
-    #
-    # Example:
-    #
-    #   # with a string
-    #   rel = evaluate "(restrict :suppliers, lambda{ city == 'London' })"
-    #
-    #   # or with a block
-    #   rel = evaluate {
-    #     (restrict :suppliers, lambda{ city == 'London' })
-    #   }
-    #
-    def evaluate(expr = nil, path = nil, &block)
-      compiled = compile(expr, path, &block)
-      case compiled
-      when Iterator
-        compiled.to_rel
-      else
-        compiled
-      end
-    end
-
-    #
-    # Coerces `h` to a valid tuple.
-    #
-    # @param [Hash] h, a hash mapping symbols to values
-    #
-    def Tuple(h)
-      unless h.keys.all?{|k| k.is_a?(Symbol)} &&
-             h.values.all?{|v| !v.nil?}
-        raise ArgumentError, "Invalid tuple literal #{h.inspect}"
-      end
-      h
-    end
-
-    #
-    # Coerces `args` to a valid relation.
-    #
-    def Relation(first, *args)
-      if args.empty?
-        if first.is_a?(Symbol)
-          environment.dataset(first).to_rel
-        elsif first.is_a?(Hash)
-          Alf::Relation[first]
-        else
-          raise ArgumentError, "Unable to coerce `#{first.inspect}` to a relation"
-        end
-      else
-        Alf::Relation[*args.unshift(first)] 
-      end
-    end
-
-    # 
-    # Install the DSL through iteration over defined operators
-    #
-    Operator.each do |op_class|
-      meth_name = Tools.ruby_case(Tools.class_name(op_class)).to_sym
-      if op_class.unary?
-        define_method(meth_name) do |child, *args|
-          child = Iterator.coerce(child, environment)
-          op_class.new([child], *args)
-        end
-      elsif op_class.binary?
-        define_method(meth_name) do |left, right, *args|
-          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)
-        end
-      else
-        raise "Unexpected operator #{op_class}"
-      end
-    end # Operators::each
-
-    # 
-    # Install the DSL through iteration over defined aggregators
-    #
-    Aggregator.each do |agg_class|
-      agg_name = Tools.ruby_case(Tools.class_name(agg_class)).to_sym
-      if method_defined?(agg_name)
-        raise "Unexpected method clash on Lispy: #{agg_name}"
-      else
-        define_method(agg_name) do |*args, &block|
-          agg_class.new(*args, &block)
-        end
-      end
-    end
-
-    def allbut(child, attributes)
-      (project child, attributes, :allbut => true)
-    end
-
-    # 
-    # Runs a command as in shell.
-    #
-    # Example:
-    #
-    #     lispy = Alf.lispy(Alf::Environment.examples)
-    #     op = lispy.run(['restrict', 'suppliers', '--', "city == 'Paris'"])
-    #
-    def run(argv, requester = nil)
-      argv = Quickl.parse_commandline_args(argv) if argv.is_a?(String)
-      argv = Quickl.split_commandline_args(argv, '|')
-      argv.inject(nil) do |cmd,arr|
-        arr.shift if arr.first == "alf"
-        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/operator.rb

@@ -1,68 +0,0 @@
-module Alf
-  #
-  # Namespace for all operators, relational and non-relational ones.
-  # 
-  module Operator
-    include Iterator, Tools
-
-    require 'alf/operator/class_methods'
-    require 'alf/operator/signature'
-    require 'alf/operator/instance_methods'
-    require 'alf/operator/nullary'
-    require 'alf/operator/unary'
-    require 'alf/operator/binary'
-    require 'alf/operator/experimental'
-
-    # Namespace for non relational operators
-    module NonRelational
-      require 'alf/operator/non_relational/autonum'
-      require 'alf/operator/non_relational/defaults'
-      require 'alf/operator/non_relational/compact'
-      require 'alf/operator/non_relational/sort'
-      require 'alf/operator/non_relational/clip'
-      require 'alf/operator/non_relational/coerce'
-      require 'alf/operator/non_relational/generator'
-
-      # Yields the block with each operator module in turn
-      def self.each
-        constants.each do |c|
-          val = const_get(c)
-          yield(val) if val.ancestors.include?(Operator::NonRelational)
-        end
-      end
-    end # NonRelational
-    
-    #
-    # Marker module and namespace for relational operators
-    #
-    module Relational
-      require 'alf/operator/relational/extend'
-      require 'alf/operator/relational/project'
-      require 'alf/operator/relational/restrict'
-      require 'alf/operator/relational/rename'
-      require 'alf/operator/relational/union'
-      require 'alf/operator/relational/minus'
-      require 'alf/operator/relational/intersect'
-      require 'alf/operator/relational/join'
-      require 'alf/operator/relational/matching'
-      require 'alf/operator/relational/not_matching'
-      require 'alf/operator/relational/wrap'
-      require 'alf/operator/relational/unwrap'
-      require 'alf/operator/relational/group'
-      require 'alf/operator/relational/ungroup'
-      require 'alf/operator/relational/summarize'
-      require 'alf/operator/relational/rank'
-      require 'alf/operator/relational/quota'
-      require 'alf/operator/relational/heading'
-
-      # Yields the block with each operator module in turn
-      def self.each
-        constants.each do |c|
-          val = const_get(c)
-          yield(val) if val.ancestors.include?(Operator::Relational)
-        end
-      end
-    end # module Relational
-    
-  end # module Operator
-end # module Alf

data/lib/alf/operator/binary.rb

@@ -1,21 +0,0 @@
-module Alf
-  module Operator
-    # 
-    # Specialization of Operator for operators that work on a binary input
-    #
-    module Binary
-      include Operator 
-
-      # Returns the left operand
-      def left
-        operands.first
-      end
-
-      # Returns the right operand
-      def right
-        operands.last
-      end
-
-    end # module Binary
-  end # module Operator
-end # module Alf

data/lib/alf/operator/class_methods.rb

@@ -1,82 +0,0 @@
-module Alf
-  module Operator
-    # 
-    # Encapsulates method that allows making operator introspection, that is,
-    # knowing operator cardinality and similar stuff.
-    # 
-    module ClassMethods
-
-      # Returns the ruby case name of this operator
-      def rubycase_name 
-        Tools.ruby_case(Tools.class_name(self))
-      end
-
-      ########################################################### Query methods
-
-      # @return true if this is a relational operator, false otherwise
-      def relational?
-        ancestors.include?(Relational)
-      end
-
-      # @return true if this is an experimental operator, false otherwise
-      def experimental?
-        ancestors.include?(Experimental)
-      end
-
-      # @return true if this is a non relational operator, false otherwise
-      def non_relational?
-        ancestors.include?(NonRelational)
-      end
-
-      # @return true if this operator is a zero-ary operator, false otherwise
-      def nullary?
-        ancestors.include?(Operator::Nullary)
-      end
-
-      # @return true if this operator is an unary operator, false otherwise
-      def unary?
-        ancestors.include?(Operator::Unary)
-      end
-
-      # @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
-        else
-          @signature ||= Signature.new(self)
-        end
-      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)
-    
-  end # module Operator
-end # module Alf