alf-core 0.13.0

data/lib/alf-types/alf/types/ordering.rb

@@ -0,0 +1,95 @@
+module Alf
+  module Types
+    #
+    # Defines an ordering on tuple attributes
+    #
+    class Ordering
+      extend Domain::Reuse.new(Array)
+
+      coercions do |c|
+        c.delegate :to_ordering
+        c.coercion(Array){|arg,_|
+          if arg.all?{|a| a.is_a?(Array)}
+            Ordering.new(arg)
+          else
+            symbolized = arg.map{|s| AttrName.coerce(s) }
+            sliced = symbolized.each_slice(2)
+            if sliced.all?{|a,o| [:asc,:desc].include?(o)}
+              Ordering.new sliced.to_a
+            else
+              Ordering.new symbolized.map{|a| [a, :asc]}
+            end
+          end
+        }
+      end
+
+      # @return [Proc] a Proc object that sorts tuples according to this
+      #         ordering.
+      attr_reader :sorter
+
+      # Creates an ordering instance
+      #
+      # @param [Array] ordering the underlying ordering info
+      def initialize(ordering = [])
+        super
+        @sorter = lambda{|t1,t2| compare(t1, t2)}
+      end
+
+      reuse :to_a
+
+      # Compares two tuples according to this ordering.
+      #
+      # Both t1 and t2 should have all attributes used by this ordering.
+      # Strange results may appear if it's not the case.
+      #
+      # @param [Tuple] t1 a tuple
+      # @param [Tuple] t2 another tuple
+      # @return [-1, 0 or 1] according to the classical ruby semantics of
+      #         `(t1 <=> t2)`
+      def compare(t1, t2)
+        reused_instance.each do |atr, dir|
+          x, y = t1[atr], t2[atr]
+          comp = x.respond_to?(:<=>) ? (x <=> y) : (x.to_s <=> y.to_s)
+          comp *= -1 if dir == :desc
+          return comp unless comp == 0
+        end
+        return 0
+      end
+
+      # Computes the union of this ordering with another one.
+      #
+      # The union is simply defined by extension of self with other's attributes
+      # and directions.
+      #
+      # @param [Ordering] other another Ordering (coercions will apply)
+      # @return [Ordering] the union ordering
+      def +(other)
+        Ordering.new(reused_instance + Ordering.coerce(other).reused_instance)
+      end
+
+      # Converts to an attribute list.
+      #
+      # @return [AttrList] a list of attribute names that participate to the
+      #         ordering
+      def to_attr_list
+        AttrList.new(reused_instance.map(&:first))
+      end
+
+      # Returns a lispy expression.
+      #
+      # @return [String] a lispy expression for this ordering
+      def to_lispy
+        Support.to_ruby_literal(to_a)
+      end
+
+      # Returns a ruby literal for this ordering.
+      #
+      # @return [String] a literal s.t. `eval(self.to_ruby_literal) == self`
+      def to_ruby_literal
+        "Alf::Ordering[#{Support.to_ruby_literal(reused_instance)}]"
+      end
+      alias :inspect :to_ruby_literal
+
+    end # class Ordering
+  end # module Types
+end # module Alf

data/lib/alf-types/alf/types/renaming.rb

@@ -0,0 +1,74 @@
+module Alf
+  module Types
+    #
+    # Encapsulates a Renaming information
+    #
+    class Renaming
+      extend Domain::Reuse.new(Hash)
+
+      coercions do |c|
+        c.delegate :to_renaming
+        c.coercion(Hash){|arg,_|
+          Renaming.new Hash[arg.map{|k,v| [ AttrName.coerce(k), AttrName.coerce(v) ] }]
+        }
+        c.coercion(Array){|arg,_|
+          coerce(Hash[*arg])
+        }
+      end
+
+      reuse  :[], :to_hash
+      recoat :invert
+
+      # Returns a completed renaming with at least all attributes in `attr_list`
+      def complete(attr_list)
+        Renaming.new attr_list.to_a.each_with_object(reused_instance.dup){|k,h| h[k] ||= k}
+      end
+
+      # Renames a tuple according to this renaming pairs.
+      #
+      # The tuple should have all attributes defined in this renaming. Strange
+      # results may appear otherwise.
+      #
+      # @param [Hash] tuple a tuple to rename
+      # @return [Hash] the renamed tuple
+      def rename_tuple(tuple)
+        Hash[tuple.map{|k,v| [self[k] || k, v]}]
+      end
+
+      # Renames an attribute list.
+      #
+      # @param [AttrList] an attribute list
+      # @return [AttrList] the input list where attributes have been renamed
+      def rename_attr_list(attr_list)
+        AttrList.coerce(attr_list).map{|k| self[k] || k}
+      end
+
+      # Returns self
+      def to_renaming
+        self
+      end
+
+      # Returns a lispy expression.
+      #
+      # @return [String] a lispy expression for this renaming
+      def to_lispy
+        Support.to_ruby_literal(to_hash)
+      end
+
+      # Returns an attribute list with renaming keys
+      def to_attr_list
+        AttrList.new reused_instance.keys
+      end
+
+      # Returns a ruby literal for this renaming.
+      #
+      # @return [String] a literal s.t. `eval(self.to_ruby_literal) == self`
+      def to_ruby_literal
+        "Alf::Renaming[#{Support.to_ruby_literal(reused_instance)}]"
+      end
+      alias :inspect :to_ruby_literal
+      alias :to_s :to_ruby_literal
+
+    end # class Renaming
+  end # module Types
+end # module Alf

data/lib/alf-types/alf/types/size.rb

@@ -0,0 +1,15 @@
+module Alf
+  module Types
+    #
+    # Defines a Size domain, as a (non strictly) positive integer.
+    #
+    class Size < Integer
+      extend Domain::SByC.new(Integer){|i| i >= 0}
+
+      coercions do |c|
+        c.upon(Object){|s,t| new Support.coerce(s, Integer) }
+      end
+
+    end # Size
+ end # module Types
+end # module Alf

data/lib/alf-types/alf/types/summarization.rb

@@ -0,0 +1,101 @@
+module Alf
+  module Types
+    #
+    # Encapsulates a Summarization information.
+    #
+    class Summarization
+      extend Domain::Reuse.new(Hash)
+
+      coercions do |c|
+        c.delegate :to_summarization
+        c.coercion(Hash){|arg,_|
+          Summarization.new Hash[arg.map{|k,v| [ AttrName.coerce(k), Aggregator.coerce(v) ] }]
+        }
+        c.coercion(Array){|arg,_|
+          coerce(Hash[*arg])
+        }
+      end
+
+      reuse :map, :keys, :to_hash
+      private :keys
+
+      # Computes the least tuple.
+      #
+      # @return [Tuple] a tuple with least values for each attribute
+      def least
+        hmap{|k,v| v.least }
+      end
+
+      # Computes the resulting aggregation from aggs if tuple happens.
+      #
+      # @return [Support::TupleScope] a scope bound to the current tuple
+      def happens(aggs, scope)
+        hmap{|k,v| v.happens(aggs[k], scope) }
+      end
+
+      # Finalizes the summarization
+      #
+      # @return [Tuple] the finalized aggregated tuple
+      def finalize(aggs)
+        hmap{|k,v| v.finalize(aggs[k]) }
+      end
+
+      # Summarizes an enumeration of tuples.
+      #
+      # @param [Enumerable] enum an enumeration of tuples
+      # @returns [Tuple] The summarization of `enum`
+      def summarize(enum)
+        scope = Support::TupleScope.new
+        finalize(enum.inject(least){|m,t| happens(m, scope.__set_tuple(t))})
+      end
+
+      # Returns self
+      def to_summarization
+        self
+      end
+
+      # Converts to an Heading.
+      #
+      # @return [Heading] a heading
+      def to_heading
+        Heading.new hmap{|name,agg| agg.infer_type}
+      end
+
+      # Converts to an attribute list.
+      #
+      # @return [AttrList] a list of computed attribute names
+      def to_attr_list
+        AttrList.new(keys)
+      end
+
+      # Returns a lispy expression.
+      #
+      # @return [String] a lispy expression for this summarization
+      def to_lispy
+        "{" << map{|k,v| "#{k}: #{Support.to_lispy(v)}" }.join(', ') << "}"
+      end
+
+      # Returns a ruby literal for this expression.
+      #
+      # @return [String] a literal s.t. `eval(self.to_ruby_literal) == self`
+      def to_ruby_literal
+        map = hmap{|k,v| "#{v.has_source_code!}" }
+        "Alf::Summarization[#{Support.to_ruby_literal(map)}]"
+      end
+
+      # Returns a string representation of this expression
+      def inspect
+        to_ruby_literal
+      rescue NotImplementedError
+        super
+      end
+
+    private
+
+      def hmap(&bl)
+        map.each_with_object({}){|(k,v),h| h[k] = yield(k,v)}
+      end
+
+    end # class Summarization
+  end # module Types
+end # module Alf

data/lib/alf-types/alf/types/tuple_computation.rb

@@ -0,0 +1,104 @@
+module Alf
+  module Types
+    #
+    # Defines the computation of a tuple from expressions mapped to names.
+    #
+    # Example:
+    #   computation = TupleComputation[
+    #     :big? => lambda{ status > 20 }
+    #     :who  => lambda{ "#{first} #{last}" }
+    #   ]
+    #   computation.call(:last => "Jones", :first => "Bill", :status => 10)
+    #   # => {:big? => false, :who => "Bill Jones"}
+    #
+    class TupleComputation
+      extend Domain::Reuse.new(Hash)
+
+      coercions do |c|
+        c.delegate :to_tuple_computation
+        c.upon(lambda{|v,_| v.respond_to?(:to_hash)}){|arg,_|
+          TupleComputation.new Hash[arg.to_hash.map{|k,v|
+            if AttrName === k
+              [ k, v.is_a?(Proc) ? TupleExpression.coerce(v) : v ]
+            else
+              [ AttrName.coerce(k), TupleExpression.coerce(v) ]
+            end
+          }]
+        }
+        c.upon(Array){|arg,_|
+          coerce(Hash[*arg])
+        }
+      end
+
+      reuse :to_hash, :map
+
+      # Makes the computation in the context of a tuple
+      #
+      # This is a convenient method for the following, longer expression:
+      #
+      #     evaluate(TupleScope.new(tuple))
+      #
+      # Note, however, using a scope as in the example above is much more
+      # efficient when evaluating the same computation on multiple tuples
+      # in sequence.
+      #
+      # @param [Hash] tuple a Tuple instance
+      # @return [Object] the resulting tuple
+      def call(tuple)
+        evaluate(Support::TupleScope.new(tuple))
+      end
+      alias :[] :call
+
+      # Computes the resulting tuple when expressions are evaluated in the
+      # context of `scope`
+      #
+      # @param [TupleScope] scope a tuple scope instance.
+      # @return [Hash] the resulting tuple
+      def evaluate(scope = nil)
+        hmap{|_,v| v.is_a?(TupleExpression) ? v.evaluate(scope) : v }
+      end
+
+      # Returns self
+      def to_tuple_computation
+        self
+      end
+
+      # Converts to a heading.
+      #
+      # @return [AttrList] a computed heading from static analysis of expressions
+      def to_heading
+        Heading.new hmap{|_,v| v.is_a?(TupleExpression) ? v.infer_type : v.class}
+      end
+
+      # Converts to an attribute list.
+      #
+      # @return [AttrList] a list of computed attribute names
+      def to_attr_list
+        AttrList.new(reused_instance.keys)
+      end
+
+      # Returns a lispy expression.
+      #
+      # @return [String] a lispy expression for this tuple computation
+      def to_lispy
+        "{" << map{|k,v| "#{k}: #{Support.to_lispy(v)}" }.join(', ') << "}"
+      end
+
+      # Returns a ruby literal for this expression.
+      #
+      # @return [String] a literal s.t. `eval(self.to_ruby_literal) == self`
+      def to_ruby_literal
+        "Alf::TupleComputation[#{Support.to_ruby_literal(reused_instance)}]"
+      end
+      alias :inspect :to_ruby_literal
+      alias :to_s :to_ruby_literal
+
+    private
+
+      def hmap(&bl)
+        map.each_with_object({}){|(k,v),h| h[k] = yield(k,v)}
+      end
+
+    end # class TupleComputation
+  end # module Types
+end # module Alf

data/lib/alf-types/alf/types/tuple_expression.rb

@@ -0,0 +1,132 @@
+module Alf
+  module Types
+    #
+    # A tuple expression is a Ruby expression whose evaluates in the scope of a specific
+    # tuple.
+    #
+    # Example:
+    #   expr = TupleExpression["status * 10"]
+    #   expr.call(:status => 20)
+    #   # => 200
+    #
+    class TupleExpression
+
+      # @return [Proc] the lambda expression
+      attr_reader :expr_lambda
+
+      # @return [String] the expression source code (may be nil)
+      attr_reader :source
+
+      # Creates a tuple expression from a Proc object
+      #
+      # @param [Proc] expr a Proc for the expression
+      # @param [String] source the source code of the expression (optional)
+      def initialize(expr, source = nil)
+        @expr_lambda = expr
+        @source = source
+      end
+
+      class << self
+
+        # Coerces `arg` to a tuple expression.
+        #
+        # Implemented coercions are:
+        # - TupleExpression -> self
+        # - Proc            -> TupleExpression.new(arg, nil)
+        # - String          -> TupleExpression.new(..., arg)
+        # - Symbol          -> TupleExpression.new(..., arg)
+        #
+        # @param [Object] arg a value to convert to a tuple expression
+        # @return [TupleExpression] the expression if coercion succeeds
+        # @raise [ArgumentError] if the coercion fails
+        def coerce(arg)
+          case arg
+          when TupleExpression
+            arg
+          when Proc
+            TupleExpression.new(arg, nil)
+          when String, Symbol
+            TupleExpression.new(eval("lambda{ #{arg} }"), arg)
+          else
+            raise ArgumentError, "Invalid argument `#{arg}` for TupleExpression()"
+          end
+        end
+        alias :[] :coerce
+
+      end # class << self
+
+      # Evaluates the expression in the context of a TupleScope
+      #
+      # @param [TupleScope] scope a tuple scope instance.
+      # @return [Object] the result of evaluating the expression in the context
+      #         of `scope`
+      def evaluate(scope = nil)
+        scope.instance_exec(&@expr_lambda)
+      end
+
+      # Infers the resulting type.
+      #
+      # @return [Class] the type inferred from expression source code
+      def infer_type
+        Object
+      end
+
+      # Returns a hash code.
+      #
+      # @return [Integer] a hash code for this expression
+      def hash
+        @source.nil? ? @expr_lambda.hash : @source.hash
+      end
+
+      # Checks equality with another expression
+      #
+      # @param [TupleExpression] another expression.
+      # @return [Boolean] true if self and other are equal, false otherwise
+      def ==(other)
+        return false unless other.is_a?(TupleExpression)
+        if source.nil? || other.source.nil?
+          expr_lambda == other.expr_lambda
+        else
+          source == other.source
+        end
+      end
+      alias :eql? :==
+
+      # Returns a lispy expression.
+      #
+      # @return [String] a lispy expression for this tuple expression
+      def to_lispy
+        "->{ #{has_source_code!} }"
+      rescue NotImplementedError => ex
+        "->{ [code unavailable] }"
+      end
+
+      # Returns a ruby literal for this expression.
+      #
+      # @return [String] a literal s.t. `eval(self.to_ruby_literal) == self`
+      def to_ruby_literal
+        "Alf::#{Support.class_name(self.class)}[#{Support.to_ruby_literal(has_source_code!)}]"
+      end
+
+      # Returns a string representation of this expression
+      def inspect
+        to_ruby_literal
+      rescue NotImplementedError
+        super
+      end
+
+      # Asserts that this expression knows its source code or raises a
+      # NotImplementedError.
+      #
+      # @return [String] the source code when known
+      def has_source_code!
+        if source.nil?
+          raise NotImplementedError, "No known source code for this expression"
+        else
+          source
+        end
+      end
+
+    end # class TupleExpression
+  end # module Types
+end # module Alf