alf 0.12.2 → 0.13.0

data/lib/alf/types/heading.rb

@@ -1,135 +0,0 @@
-module Alf
-  module Types
-    #
-    # Defines a Heading, that is, a set of attribute (name,domain) pairs.
-    #
-    class Heading
-      include Enumerable
-
-      # @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
-      #        an AttrName and type is a Class
-      def initialize(attributes)
-        @attributes = attributes.dup.freeze
-      end
-
-      class << self
-
-        # Coerces `arg` to a Heading.
-        #
-        # Implemented coercions are:
-        # - Array: [AttrName, Module, ..., AttrName, Module]
-        # - Hash:  {AttrName => Module, ..., AttrName => Module}
-        #
-        # @param [Object] arg value to coerce to a Heading
-        # @return [Heading] a heading instance when coercion succeeds
-        # @raise [ArgumentError] is coercion fails
-        def coerce(arg)
-          case arg
-          when Heading
-            arg
-          when Array
-            Heading.new Hash[arg.each_slice(2).map{|k,v|
-              [ Tools.coerce(k, Symbol), 
-                Tools.coerce(v, Module) ]
-            }]
-          when Hash
-            Heading.new Hash[arg.map{|k,v|
-              [ Tools.coerce(k, Symbol), 
-                Tools.coerce(v, Module) ]
-            }]
-          else
-            raise ArgumentError, "Unable to coerce #{arg.inspect} to a Heading"
-          end
-        end
-        alias :[] :coerce
-
-        # Coerces commandline arguments to a Heading.
-        #
-        # This method simply reuses `coerce(Array)` and therefore shares its 
-        # spec.
-        #
-        # @param [Array] argv commandline arguments
-        # @param [Hash] opts options (unused)
-        # @return [Heading] a heading instance when coercion succeeds
-        # @raise [ArgumentError] is coercion fails
-        def from_argv(argv, opts = {})
-          coerce(argv)
-        end
-
-      end # class << self
-
-      # Yields each (name,domain) pair in turn.
-      def each(&block)
-        attributes.each(&block)
-      end
-
-      # Returns heading's cardinality, i.e. the number of (name,type) pairs.
-      #
-      # @return [Integer] the number of pairs
-      def cardinality
-        attributes.size
-      end
-      alias :size  :cardinality
-      alias :count :cardinality
-
-      # Computes the union of this heading with `other`.
-      #
-      # When self and other have no common attribute names, compute the 
-      # classical set union on pairs. Otherwise, the type of a common attribute
-      # is returned as the common super type (see `Types.common_super_type`).
-      #
-      # @param [Heading] other another heading
-      # @return [Heading] the union of this heading with `other`
-      def union(other)
-        Heading.new attributes.merge(other.attributes){|k,t1,t2|
-          Types.common_super_type(t1, t2)
-        }
-      end
-      alias :+ :union
-      alias :join :union
-
-      # Returns heading's hash code
-      #
-      # @return [Integer] the heading's hash code
-      def hash
-        attributes.hash
-      end
-
-      # Checks equality with other heading
-      #
-      # Classical set equality applies to headings.
-      #
-      # @param [Heading] other another heading
-      # @return [Boolean] true if other is the same heading than self, false
-      #         otherwise
-      def ==(other)
-        other.is_a?(Heading) && (attributes == other.attributes) 
-      end
-      alias :eql? :==
-      
-      # Converts this heading to a Hash of (name,type) pairs
-      #
-      # @return [Hash] this heading as a Hash of (name, type) pairs
-      def to_h
-        attributes.dup
-      end
-
-      # Returns a Heading literal
-      #
-      # @return [String] 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

@@ -1,146 +0,0 @@
-module Alf
-  module Types
-    #
-    # Defines an ordering on tuple attributes
-    #
-    class Ordering
-
-      # @return [Array] underlying ordering as an array `[[attr1, dir1], ...]`
-      attr_reader :ordering
-
-      # @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 = [])
-        @ordering = ordering
-        @sorter = lambda{|t1,t2| compare(t1, t2)}
-      end
-
-      class << self
-
-        # Coerces `arg` to an ordering.
-        #
-        # Implemented coercions are:
-        # * Ordering (self)
-        # * Array of AttrName (all attributes in ascending order)
-        # * Array of [AttrName, :asc|:desc] pairs (obvious semantics)
-        # * AttrList (all its attributes in ascending order)
-        #
-        # @param [Object] arg the value to coerce as an Ordering
-        # @return [Ordering] when coercion succeeds
-        # @raises [ArgumentError] when coercion fails
-        def coerce(arg)
-          case arg
-          when Ordering
-            arg
-          when AttrList
-            arg.to_ordering(:asc)
-          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.map{|a| [a, :asc]}
-              end
-            end
-          else
-            raise ArgumentError, "Unable to coerce #{arg} to an ordering key"
-          end
-        end
-        alias :[] :coerce
-
-        # Converts commandline arguments to an ordering.
-        #
-        # This method reuses the `coerce(Array)` coercion heuristics and 
-        # therefore shares its spec.
-        #
-        # @param [Array] argv commandline arguments
-        # @param [Hash] opts options (not used)
-        # @return [Ordering] when coercion succeeds
-        # @raises [ArgumentError] when coercion fails
-        def from_argv(argv, opts = {})
-          coerce(argv)
-        end
-
-      end # class << self
-
-      # Returns the ordering attributes
-      #
-      # @return [Array<AttrName>] the list of attribute names
-      def attributes
-        @ordering.map{|arg| arg.first}
-      end
-
-      # 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)
-        ordering.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(ordering + Ordering.coerce(other).ordering)
-      end
-
-      # Returns the ordering hash code.
-      #
-      # @return [Integer] a hash code for this ordering.
-      def hash
-        ordering.hash
-      end
-
-      # Checks equality with another ordering.
-      #
-      # @param [Ordering] other another Ordering instance 
-      # @return [Boolean] true if both orderings are the same, false otherwise
-      def ==(other)
-        other.is_a?(Ordering) && (other.ordering == ordering)
-      end
-      alias :eql? :==
-
-      # Converts to an attribute list.
-      #
-      # @return [AttrList] a list of attribute names that participate to the 
-      #         ordering
-      def to_attr_list
-        AttrList.new(attributes)
-      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[#{Tools.to_ruby_literal(ordering)}]"
-      end
-      alias :inspect :to_ruby_literal
-
-    end # class Ordering
-  end # module Types
-end # module Alf

data/lib/alf/types/renaming.rb

@@ -1,97 +0,0 @@
-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 
-
-      class << self
-
-        # Coerces `arg` to a renaming
-        #
-        # Implemented coercions are:
-        # - Renaming: self
-        # - {old1 => new1, ...} with AttrName coercions on olds and news
-        # - [old1, new1, ...] with AttrName coercions on olds and news
-        #
-        # @param [Object] arg the value to coerce to a Renaming
-        def coerce(arg)
-          case arg
-          when Renaming
-            arg
-          when Hash
-            Renaming.new Hash[arg.map{|k,v|
-              [ Tools.coerce(k, AttrName), 
-                Tools.coerce(v, AttrName) ]
-            }]
-          when Array
-            coerce(Hash[*arg])
-          else
-            raise ArgumentError, "Invalid argument `#{arg}` for Renaming()"
-          end
-        end
-        alias :[] :coerce
-
-        # Converts commandline arguments to a renaming.
-        #
-        # This method reuses the `coerce(Array)` coercion heuristics and 
-        # therefore shares its spec.
-        #
-        # @param [Array] argv commandline arguments
-        # @param [Hash] opts options (not used)
-        # @return [Ordering] when coercion succeeds
-        # @raises [ArgumentError] when coercion fails
-        def from_argv(argv, opts = {})
-          coerce(argv)
-        end
-
-      end # class << self
-
-      # 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)
-        Tools.tuple_collect(tuple){|k,v| [@renaming[k] || k, v]}
-      end
-
-      # Returns the ordering hash code.
-      #
-      # @return [Integer] a hash code for this renaming
-      def hash
-        renaming.hash
-      end
-
-      # Checks equality with another Renaming instance.
-      #
-      # @param [Renaming] other another renaming instance
-      # @return [Boolean] true if self and other are equal, false otherwise
-      def ==(other)
-        other.is_a?(Renaming) && (other.renaming == renaming)
-      end
-      alias :eql? :==
-
-      # 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[#{Tools.to_ruby_literal(renaming)}]"
-      end
-      alias :inspect :to_ruby_literal
-
-    end # class Renaming
-  end # module Types
-end # module Alf

data/lib/alf/types/size.rb

@@ -1,57 +0,0 @@
-module Alf
-  module Types
-    #
-    # Defines a Size domain, as a (non strictly) positive integer.
-    #
-    class Size < Integer
-      extend Myrrha::Domain
-
-      # The size predicate
-      PREDICATE = lambda{|i| i >= 0}
-
-      class << self
-
-        # Returns the domain predicate.
-        #
-        # @return [Proc] the domain predicate as a Proc object
-        def predicate
-          PREDICATE
-        end
-
-        # Coerces `arg` to a size
-        #
-        # @param [Object] arg any value coercable to an Integer
-        # @return [Size] the coerced size when success
-        # @raise [ArgumentError] if the coercion fails
-        def coerce(arg)
-          res = Tools.coerce(arg, Integer)
-          if self === res
-            res
-          else
-            raise ArgumentError, "Invalid value `#{arg}` for Size()" 
-          end
-        rescue Alf::CoercionError
-          raise ArgumentError, "Invalid value `#{arg}` for Size()"
-        end
-
-        # Coerces commandline arguments to a Size.
-        #
-        # The `argv` must be empty or a singleton. When empty, `opts[:default]`
-        # is used, which defaults to 0.
-        #
-        # @param [Array<String>] argv commandline arguments
-        # @param [Hash] opts coercion options
-        # @return [Size] coerced size as specified on commandline
-        # @raise [ArgumentError] if the size cannot be coerced from argv
-        def from_argv(argv, opts = {:default => 0})
-          if argv.size > 1
-            raise ArgumentError, "Invalid value #{argv.inspect} for Size()" 
-          end
-          coerce(argv.first || opts[:default])
-        end
-
-      end # class << self
-
-    end # Size
- end # module Types
-end # module Alf

data/lib/alf/types/summarization.rb

@@ -1,138 +0,0 @@
-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
-
-      class << self
-
-        # Coerces `arg` to an Summarization
-        #
-        # Implemented coercions are:
-        # - Summarization        -> self
-        # - [attr1, agg1, ...]   -> {AttrName(attr1) -> Aggregator(agg1), ...}
-        # - {attr1 => agg1, ...} -> {AttrName(attr1) -> Aggregator(agg1), ...}
-        # 
-        # @param [Object] arg any ruby object to coerce to an Summarization
-        # @return [Summarization] the coerced summarization
-        # @raise [ArgumentError] is the coercion fails
-        def coerce(arg)
-          case arg
-          when Summarization
-            arg
-          when Array
-            coerce(Hash[*arg])
-          when Hash
-            Summarization.new Hash[arg.map{|k,v|
-              [ Tools.coerce(k, AttrName), 
-                Tools.coerce(v, Aggregator) ]
-            }]
-          else
-            raise ArgumentError, "Invalid arg `#{arg}` for Summarization()"
-          end
-        end
-        alias :[] :coerce
-
-        # Coerces commandline arguments to a Summarization
-        #
-        # This method reuses `coerce(Array)` and therefore shares its spec.
-        #
-        # @params [Array<String>] argv commandline arguments
-        # @params [Hash] opts coercion options (not used)
-        # @return [Summarization] the coerced summarization
-        # @raise [ArgumentError] is the coercion fails
-        def from_argv(argv, opts = {})
-          coerce(argv)
-        end
-
-      end
-
-      # Computes the least tuple.
-      #
-      # @return [Tuple] a tuple with least values for each attribute
-      def least
-        Hash[@aggregations.map{|k,v| 
-          [k, v.least]
-        }]
-      end
-
-      # Computes the resulting aggregation from aggs if tuple happens.
-      #
-      # @return [Tuple] the new aggregated tuple
-      def happens(aggs, tuple)
-        Hash[@aggregations.map{|k,v|
-          [k, v.happens(aggs[k], tuple)]
-        }]
-      end
-
-      # Finalizes the summarization
-      #
-      # @return [Tuple] the finalized aggregated tuple
-      def finalize(aggs)
-        Hash[@aggregations.map{|k,v|
-          [k, 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)
-        finalize(enum.inject(least){|m,t| happens(m,t)})
-      end
-
-      # Returns a hash code.
-      #
-      # @return [Integer] a hash code for this expression
-      def hash
-        aggregations.hash
-      end
-
-      # Checks equality with another summarization
-      #
-      # @param [Summarization] another summariation
-      # @return [Boolean] true is self and other are equal, false otherwise
-      def ==(other)
-        other.is_a?(Summarization) && (other.aggregations == aggregations)
-      end
-      alias :eql? :==
-
-      # Converts to an attribute list.
-      #
-      # @return [AttrList] a list of computed attribute names
-      def to_attr_list
-        AttrList.new(aggregations.keys)
-      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 = Hash[aggregations.map{|k,v| 
-          [k.to_s, "#{v.has_source_code!}"]
-        }]
-        "Alf::Summarization[#{Tools.to_ruby_literal(map)}]"
-      end
-
-      # Returns a string representation of this expression
-      def inspect
-        to_ruby_literal
-      rescue NotImplementedError
-        super
-      end
-
-    end # class Summarization
-  end # module Types
-end # module Alf