alf 0.9.3 → 0.10.0

data/lib/alf/types/heading.rb

@@ -0,0 +1,96 @@
+module Alf
+  module Types
+    #
+    # Defines a Heading, that is, a set of attribute (name,domain) pairs.
+    #
+    class Heading
+      
+      #
+      # Creates a Heading instance
+      #
+      # @param [Hash] a hash of attribute (name, type) pairs where name is
+      #        a Symbol and type is a Class
+      #
+      def self.[](attributes)
+        Heading.new(attributes) 
+      end
+  
+      # @return [Hash] a (freezed) hash of (name, type) pairs  
+      attr_reader :attributes
+      
+      #
+      # Creates a Heading instance
+      #
+      # @param [Hash] a hash of attribute (name, type) pairs where name is
+      #        a Symbol and type is a Class
+      #
+      def initialize(attributes)
+        @attributes = attributes.dup.freeze
+      end
+      
+      #
+      # Coerces `attributes` to a Heading instance
+      #
+      def self.coerce(attributes)
+        case attributes
+        when Array
+          h = Tools.tuple_collect(attributes.each_slice(2)) do |k,v|
+            [ Tools.coerce(k, Symbol), Tools.coerce(v, Module) ]
+          end
+          Heading.new(h)
+        when Hash
+          Heading.new(attributes)
+        else
+          raise ArgumentError, "Unable to coerce #{attributes.inspect} to a Heading"
+        end
+      end
+      
+      def self.from_argv(argv, opts = {})
+        coerce(argv)
+      end
+      
+      #
+      # Returns heading's cardinality
+      #
+      def cardinality
+        attributes.size
+      end
+      alias :size  :cardinality
+      alias :count :cardinality
+      
+      #
+      # Returns heading's hash code
+      # 
+      def hash
+        @hash ||= attributes.hash
+      end
+      
+      #
+      # Checks equality with other heading
+      #
+      def ==(other)
+        other.is_a?(Heading) && (other.attributes == attributes) 
+      end
+      alias :eql? :==
+      
+      #
+      # Converts this heading to a Hash of (name,type) pairs
+      # 
+      def to_hash
+        attributes.dup
+      end
+      
+      # 
+      # Returns a Heading literal
+      #
+      def to_ruby_literal
+        attributes.empty? ?
+          "Alf::Heading::EMPTY" :
+          "Alf::Heading[#{Tools.to_ruby_literal(attributes)[1...-1]}]"
+      end
+      alias :inspect :to_ruby_literal
+      
+      EMPTY = Heading.new({})
+    end # class Heading    
+  end # module Types
+end # module Alf

data/lib/alf/types/ordering.rb

@@ -0,0 +1,93 @@
+module Alf
+  module Types
+    #
+    # Encapsulates tools for computing orders on tuples
+    #
+    class Ordering
+    
+      attr_reader :ordering
+    
+      def initialize(ordering = [])
+        @ordering = ordering
+        @sorter = nil
+      end
+    
+      # 
+      # Coerces `arg` to an ordering key. 
+      #
+      # Implemented coercions are:
+      # * Array of symbols (all attributes in ascending order)
+      # * Array of [Symbol, :asc|:desc] pairs (obvious semantics)
+      # * AttrList (all its attributes in ascending order)
+      # * Ordering (self)
+      #
+      # @return [Ordering]
+      # @raises [ArgumentError] when `arg` is not recognized
+      #
+      def self.coerce(arg)
+        case arg
+        when Ordering
+          arg
+        when AttrList
+          arg.to_ordering
+        when Array
+          if arg.all?{|a| a.is_a?(Array)}
+            Ordering.new(arg)
+          else
+            symbolized = arg.collect{|s| Tools.coerce(s, Symbol)}
+            sliced = symbolized.each_slice(2) 
+            if sliced.all?{|a,o| [:asc,:desc].include?(o)}
+              Ordering.new sliced.to_a
+            else
+              Ordering.new symbolized.collect{|a| [a, :asc]}
+            end
+          end
+        else
+          raise ArgumentError, "Unable to coerce #{arg} to an ordering key"
+        end
+      end
+
+      def self.from_argv(argv, opts = {})
+        coerce(argv)
+      end
+          
+      def attributes
+        @ordering.collect{|arg| arg.first}
+      end
+    
+      def order_by(attr, order = :asc)
+        @ordering << [attr, order]
+        @sorter = nil
+        self
+      end
+    
+      def order_of(attr)
+        @ordering.find{|arg| arg.first == attr}.last
+      end
+    
+      def compare(t1,t2)
+        @ordering.each do |attr,order|
+          x, y = t1[attr], t2[attr]
+          comp = x.respond_to?(:<=>) ? (x <=> y) : (x.to_s <=> y.to_s)
+          comp *= -1 if order == :desc
+          return comp unless comp == 0
+        end
+        return 0
+      end
+    
+      def sorter
+        @sorter ||= lambda{|t1,t2| compare(t1, t2)}
+      end
+    
+      def +(other)
+        other = Ordering.coerce(other)
+        Ordering.new(@ordering + other.ordering)
+      end
+    
+      def ==(other)
+        other.is_a?(Ordering) && (other.ordering == ordering)
+      end
+      
+    end # class Ordering
+  end # module Types
+end # module Alf

data/lib/alf/types/renaming.rb

@@ -0,0 +1,57 @@
+module Alf
+  module Types
+    #
+    # Encapsulates a Renaming information 
+    #
+    class Renaming
+      
+      # @return [Hash] a renaming mapping as AttrName -> AttrName
+      attr_reader :renaming     
+      
+      # 
+      # Creates a renaming instance
+      #
+      # @param [Hash] a renaming mapping as AttrName -> AttrName 
+      #
+      def initialize(renaming)
+        @renaming = renaming
+      end 
+      
+      # 
+      # Coerces `arg` to a renaming
+      # 
+      def self.coerce(arg)
+        case arg
+        when Renaming
+          arg
+        when Hash
+          h = Tools.tuple_collect(arg){|k,v|
+            [Tools.coerce(k, AttrName), Tools.coerce(v, AttrName)]
+          }
+          Renaming.new(h)
+        when Array
+          coerce(Hash[*arg])
+        else
+          raise ArgumentError, "Invalid argument `#{arg}` for Renaming()"
+        end
+      end
+
+      def self.from_argv(argv, opts = {})
+        coerce(argv)
+      end
+            
+      #
+      # Applies renaming to a a given tuple
+      #
+      def apply(tuple)
+        Tools.tuple_collect(tuple){|k,v| [@renaming[k] || k, v]}
+      end
+      
+      # Checks if this renaming is equal to `other`
+      def ==(other)
+        other.is_a?(Renaming) && (other.renaming == renaming)
+      end
+      
+    end # class Renaming
+  end # module Types
+end # module Alf

data/lib/alf/types/summarization.rb

@@ -0,0 +1,76 @@
+module Alf
+  module Types
+    #
+    # Encapsulates a Summarization information
+    #
+    class Summarization
+      
+      # @return [Hash] the hash of aggregations, AttrName -> Aggregators
+      attr_reader :aggregations
+      
+      #
+      # Creates a Summarization instance
+      #
+      # @param [Hash] aggs, aggregations as a mapping AttrName -> Aggregators
+      #
+      def initialize(aggs)
+        @aggregations = aggs
+      end
+      
+      #
+      # Coerces `arg` to an Aggregator
+      #
+      def self.coerce(arg)
+        case arg
+        when Summarization
+          arg
+        when Array
+          coerce(Hash[*arg])
+        when Hash
+          h = Tools.tuple_collect(arg) do |k,v|
+            [Tools.coerce(k, AttrName), Tools.coerce(v, Aggregator)]
+          end
+          Summarization.new(h)
+        else
+          raise ArgumentError, "Invalid arg `#{arg}` for Summarization()"
+        end
+      end
+      
+      def self.from_argv(argv, opts = {})
+        coerce(argv)
+      end
+      
+      #
+      # Computes the least tuple
+      #
+      def least
+        Tools.tuple_collect(@aggregations){|k,v| 
+          [k, v.least]
+        }
+      end
+      
+      #
+      # Computes the resulting aggregation from aggs if tuple happens. 
+      #
+      def happens(aggs, tuple)
+        Tools.tuple_collect(@aggregations){|k,v|
+          [k, v.happens(aggs[k], tuple)]
+        }
+      end
+      
+      #
+      # Finalizes the summarization `aggs` 
+      #
+      def finalize(aggs)
+        Tools.tuple_collect(@aggregations){|k,v|
+          [k, v.finalize(aggs[k])]
+        }
+      end
+      
+      def ==(other)
+        other.is_a?(Summarization) && (other.aggregations == aggregations)
+      end
+      
+    end # class Summarization
+  end # module Types
+end # module Alf

data/lib/alf/types/tuple_computation.rb

@@ -0,0 +1,61 @@
+module Alf
+  module Types
+    # 
+    # Encapsulates a tuple computation from other tuples expressions
+    #
+    class TupleComputation
+      
+      # @return [Hash] a computation hash, mapping AttrName -> TupleExpression
+      attr_reader :computation
+      
+      #
+      # Creates a TupleComputation instance
+      #
+      # @param [Hash] computation, a mappping AttrName -> TupleExpression
+      #
+      def initialize(computation)
+        @computation = computation
+      end
+      
+      # 
+      # Coerces `arg` to a tuple computation
+      #
+      def self.coerce(arg)
+        case arg
+        when TupleComputation
+          arg
+        when Hash
+          h = Tools.tuple_collect(arg){|k,v|
+            if AttrName === k
+              v = TupleExpression.coerce(v) if v.is_a?(Proc)
+              [k, v] 
+            else
+              [Tools.coerce(k, AttrName), Tools.coerce(v, TupleExpression)]
+            end
+          }
+          TupleComputation.new(h)
+        when Array
+          coerce(Hash[*arg])
+        else
+          raise ArgumentError, "Invalid argument `arg` for TupleComputation()"
+        end
+      end
+      
+      # Coerce from ARGV
+      def self.from_argv(argv, opts = {})
+        coerce(argv)
+      end
+      
+      #
+      # Computes the result, given `tuple` as context and `handle` to
+      # evaluate expressions. 
+      #
+      def evaluate(obj = nil)
+        Tools.tuple_collect(@computation){|k,v| 
+          [k, v.is_a?(TupleExpression) ? v.evaluate(obj) : v]
+        }
+      end
+      
+    end # class TupleComputation
+  end # module Types
+end # module Alf

data/lib/alf/types/tuple_expression.rb

@@ -0,0 +1,61 @@
+module Alf
+  module Types
+    #
+    # Encapsulates the notion of tuple expression, which is a Ruby expression
+    # whose evaluates in the context and scope of a specific tuple.
+    #
+    class TupleExpression
+      
+      # @return [Proc] the lambda expression
+      attr_reader :expr_lambda
+      
+      # @return [String] the expression source code 
+      attr_reader :source
+      
+      #
+      # Creates a tuple expression from a Proc object
+      #
+      # @param [Proc] expr a Proc for the expression 
+      #
+      def initialize(expr, source = nil)
+        @expr_lambda = expr
+        @source = source
+      end
+      
+      # 
+      # Coerces `arg` to a tuple expression
+      # 
+      def self.coerce(arg)
+        case arg
+        when TupleExpression
+          arg
+        when Proc
+          TupleExpression.new(arg, nil)
+        when String, Symbol
+          lamb = eval("lambda{ #{arg} }")
+          TupleExpression.new(lamb, arg.to_s)
+        else
+          raise ArgumentError, "Invalid argument `#{arg}` for TupleExpression()"
+        end
+      end
+
+      # Coerces from ARGV 
+      def self.from_argv(argv, options = {})
+        raise ArgumentError if argv.size > 1
+        coerce(argv.first || options[:default])
+      end
+
+      #
+      # Evaluates in the context of obj
+      #
+      def evaluate(obj = nil)
+        if RUBY_VERSION < "1.9"
+          obj.instance_eval(&@expr_lambda)
+        else
+          obj.instance_exec(&@expr_lambda)
+        end
+      end
+      
+    end # class TupleExpression
+  end # module Types
+end # module Alf

data/lib/alf/types/tuple_predicate.rb

@@ -0,0 +1,49 @@
+module Alf
+  module Types
+    # 
+    # Specialization of TupleExpression to boolean expressions 
+    # specifically
+    #
+    class TuplePredicate < TupleExpression
+      
+      # 
+      # Coerces `arg` to a TuplePredicate
+      #
+      def self.coerce(arg)
+        case arg
+        when TuplePredicate
+          arg
+        when TupleExpression
+          TuplePredicate.new arg.expr_lambda, arg.source
+        when TrueClass, FalseClass
+          TuplePredicate.new lambda{ arg }, arg.to_s
+        when Proc
+          TuplePredicate.new arg, nil
+        when String, Symbol
+          l = eval("lambda{ #{arg} }")
+          TuplePredicate.new l, arg.to_s
+        when Hash
+          h = Tools.tuple_collect(arg){|k,v|
+            (AttrName === k) ? 
+              [k,v] : [Tools.coerce(k, AttrName), Kernel.eval(v)]
+          }
+          source = h.each_pair.collect{|k,v|
+            "(self.#{k} == #{Tools.to_ruby_literal(v)})"
+          }.join(" && ")
+          coerce(source.empty? ? true : source)
+        when Array
+          (arg.size <= 1) ?
+            coerce(arg.first || true) :
+            coerce(Hash[*arg])
+        else
+          raise ArgumentError, "Invalid argument `#{arg}` for TupleExpression()"
+        end
+      end
+      
+      def self.from_argv(argv)
+        coerce(argv)
+      end
+      
+    end # class TuplePredicate
+  end # module Types
+end # module Alf

data/lib/alf/version.rb

@@ -2,8 +2,8 @@ module Alf
   module Version
   
     MAJOR = 0
-    MINOR = 9
-    TINY  = 3
+    MINOR = 10
+    TINY  = 0
   
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')