alf 0.12.2 → 0.13.0

data/lib/alf/tools/to_relation.rb

@@ -1,54 +0,0 @@
-module Alf
-  class Relation; end
-  module Tools
-
-    # Converts `value` to a Relation.
-    #
-    # Example:
-    #
-    #     Tools.to_relation(:name => "Alf")
-    #     # => (Relation {:name => "Alf"})
-    #
-    # @param [Object] expr any ruby object to convert to a Relation
-    # @return [Relation] a relation for `expr`
-    def to_relation(expr)
-      ToRelation.apply(expr)
-    end
-
-    # Myrrha rules for converting objects to relations
-    ToRelation = Myrrha::coercions do |r|
-      r.main_target_domain = Relation
-
-      # Delegate to #to_relation if it exists
-      rel_able = lambda{|v,rd| v.respond_to?(:to_relation)}
-      r.upon(rel_able) do |v,_|
-        v.to_relation
-      end
-
-      # to_relation(:name => ["...", "..."])
-      list_of_values = lambda{|v,_|
-        v.is_a?(Hash) and v.size == 1 and v.values.first.is_a?(Array)
-      }
-      r.upon(list_of_values) do |v,_|
-        key, values = v.to_a.first
-        tuples      = values.map{|value| {key => value}}.to_set
-        Relation.new(tuples)
-      end
-
-      # Tuple to singleton Relation
-      r.upon(Hash) do |v,_|
-        Relation.new(Set.new << v)
-      end
-
-      # From enumerable of tuples to Relation
-      enum_of_tuples = lambda{|v,_|
-        v.is_a?(Enumerable) and v.all?{|t| t.is_a?(Hash)}
-      }
-      r.upon(enum_of_tuples) do |v,_|
-        Relation.new(v.to_set)
-      end
-
-    end # ToRelation
-
-  end # module Tools
-end # module Alf

data/lib/alf/tools/to_ruby_literal.rb

@@ -1,31 +0,0 @@
-module Alf
-  module Tools
-
-    # Converts `value` to a ruby literal
-    #
-    # This method is provided for code generation mechanisms used by Alf in
-    # various places (such as .rash files). The to_ruby_literal contract is
-    # such that the following invariant holds:
-    #
-    #     eval(to_ruby_literal(value)) == value
-    #
-    # This contract is ensured by Myrrha::ToRubyLiteral for various ruby values.
-    # Myrrha delegates the job to `value.to_ruby_literal` provided this method 
-    # exists. In such case, the implementation must be such that the invariant
-    # above is met.
-    #
-    # In every case, an invocation to this method only makes sense provided that
-    # `value` denotes a pure value, with the obvious semantics (from TTM).
-    #
-    # @param [Object] value any ruby object that denotes a pure value.
-    # @return [String] a ruby literal for `value`
-    def to_ruby_literal(value)
-      ToRubyLiteral.apply(value)
-    end
-
-    # Myrrha rules for converting to ruby literals
-    ToRubyLiteral = Myrrha::ToRubyLiteral.dup.append do
-    end
-
-  end # module Tools
-end # module Alf

data/lib/alf/tools/tuple_handle.rb

@@ -1,60 +0,0 @@
-module Alf
-  module Tools
-    #
-    # Provides a handle for implementing a flyweight design pattern on tuples.
-    #
-    # This class works hand-in-hand with TupleExpression as it provides a scope
-    # for their evaluation on tuples.
-    #
-    # Example:
-    #
-    #   handle = TupleHandle.new
-    #   expr   = TupleExpression["status > 10"]
-    #   relation.each do |tuple|
-    #     expr.evaluate(handle.set(tuple))
-    #   end
-    #
-    class TupleHandle
-
-      # Creates a handle instance
-      def initialize
-        @tuple = nil
-      end
-
-      # Sets the next tuple to use.
-      #
-      # On first call, this method installs the handle as a side effect.
-      #
-      # @param [Tuple] tuple the current iterated tuple
-      # @return [TupleHandle] self
-      def set(tuple)
-        build(tuple) if @tuple.nil?
-        @tuple = tuple
-        self
-      end
-
-      # Evaluates a tuple expression on the current tuple.
-      # 
-      # @param [Object] expr a tuple expression (coercions apply)
-      # @return [Object] the result of evaluting `expr` on self
-      def evaluate(expr)
-        TupleExpression.coerce(expr).evaluate(self)
-      end
-
-      private
-
-      # Builds this handle with a tuple.
-      #
-      # This method should be called only once and installs instance methods on 
-      # the handle with keys of _tuple_.
-      def build(tuple)
-        tuple.keys.each do |k|
-          (class << self; self; end).send(:define_method, k) do
-            @tuple[k]
-          end
-        end
-      end
-
-    end # class TupleHandle
-  end # module Tools
-end # module Alf

data/lib/alf/types.rb

@@ -1,49 +0,0 @@
-module Alf
-  #
-  # This module defines a namespace for useful datatypes as well as a few 
-  # typing tools. Defined types are automatically defined as constants on the 
-  # Alf module itself.
-  #
-  module Types
-    require 'alf/types/boolean'
-    require 'alf/types/size'
-    require 'alf/types/attr_name'
-    require 'alf/types/attr_list'
-    require 'alf/types/heading'
-    require 'alf/types/ordering'
-    require 'alf/types/renaming'
-    require 'alf/types/summarization'
-    require 'alf/types/tuple_expression'
-    require 'alf/types/tuple_predicate'
-    require 'alf/types/tuple_computation'
-
-    # Returns the (least) common super type of c1 and c2.
-    #
-    # The least common super type is defined as the lowest ancestor shared 
-    # between c1 and c2.
-    #
-    # Examples:
-    #
-    #     Types.common_super_type(String, String)  # => String
-    #     Types.common_super_type(Integer, Float)  # => Numeric
-    #     Types.common_super_type(Integer, String) # => Object
-    #
-    # @param [Class] c1 a data type, respresented by a ruby class
-    # @param [Class] c2 a data type, respresented by a ruby class
-    # @return [Class] the least common super type of c1 and c2
-    def common_super_type(c1, c2)
-      return c1 if c1 == c2
-      ancestors = [c1, c2].map{|c| 
-        c.ancestors.select{|a| a.is_a?(Class)}
-      }
-      (ancestors[0] & ancestors[1]).first
-    end
-    module_function :common_super_type
-
-    # Install all types on Alf now
-    constants.each do |s|
-      Alf.const_set(s, const_get(s))
-    end
-
-  end # module Types
-end # module Alf

data/lib/alf/types/attr_list.rb

@@ -1,160 +0,0 @@
-module Alf
-  module Types
-    #
-    # An attribute list is an ordered collection of attribute names (see 
-    # AttrName).
-    #
-    # Example:
-    #
-    #     list = AttrList[:name, :city]
-    #
-    class AttrList
-
-      # @return [Array<AttrName>] the list of attribute names
-      attr_accessor :attributes
-
-      # Creates an AttrList instance.
-      #
-      # @param [Array<AttrName>] the list of attribute names
-      def initialize(attributes)
-        @attributes = attributes
-      end
-
-      class << self
-
-        # Coerces `arg` to an AttrList.
-        #
-        # Recognizes coercions are:
-        # - AttrList -> self
-        # - Ordering -> the underlying list of attributes
-        # - Array    -> through AttrName coercion of its elements
-        #
-        # @param [Object] arg the value to coerce to an AttrList
-        # @return [AttrList] an attribute list if coercion succeeds
-        # @raise [ArgumentError] if the coercion fails
-        def coerce(arg)
-          return arg.to_attr_list if arg.respond_to?(:to_attr_list)
-          case arg
-          when Array
-            AttrList.new(arg.collect{|s| Tools.coerce(s, AttrName)})
-          else
-            raise ArgumentError, "Unable to coerce #{arg} to a projection key"
-          end
-        end
-
-        # Coerces a list of names to an AttrList.
-        #
-        # @param [Array] args a list of names (Symbol or String)
-        # @return [AttrList] an attribute list
-        def [](*args)
-          coerce(args)
-        end
-
-        # Builds an AttrList from commandline arguments.
-        #
-        # This method relies on `coerce` and therefore shares its spec.
-        #
-        # @param [Array] argv an array of commandline arguments
-        # @param [Hash] opts convertion options (unused)
-        # @return [AttrList] an attribute list if coercion succeeds
-        # @raise [ArgumentError] if the coercion fails
-        def from_argv(argv, opts = {})
-          coerce(argv)
-        end
-
-      end # class << self
-
-      # Converts this attribute list to an ordering.
-      #
-      # @param [Symbol] :asc or :desc for ordering direction
-      # @return [Ordering] an ordering instance
-      def to_ordering(order = :asc)
-        Ordering.new attributes.map{|arg| [arg, order]}
-      end
-
-      # Splits a tuple in two parts according `allbut`.
-      #
-      # Example:
-      #   list = AttrList.new([:name])
-      #   tuple = {:name => "Jones", :city => "London"}
-      #
-      #   list.split_tuple(tuple)
-      #   # => [{:name => "Jones"}, {:city => "London"}]
-      #
-      #   list.split_tuple(tuple, true)
-      #   # => [{:city => "London"}, {:name => "Jones"}]
-      #
-      # @param [Hash] tuple a tuple to split
-      # @param [Boolean] allbut unknown attributes as first result?
-      # @return [Array<Hash>] an array containing two tuples, according to known
-      #         attributes and `allbut`
-      def split_tuple(tuple, allbut = false)
-        projection, rest = {}, tuple.dup
-        attributes.each do |a|
-          projection[a] = tuple[a]
-          rest.delete(a)
-        end
-        allbut ? [rest, projection] : [projection, rest]
-      end
-
-      # Projects `tuple` on known (or unknown) attributes.
-      # 
-      # Example:
-      #   list = AttrList.new([:name])
-      #   tuple = {:name => "Jones", :city => "London"}
-      #
-      #   list.project_tuple(tuple)
-      #   # => {:name => "Jones"}
-      #
-      #   list.project_tuple(tuple, true)
-      #   # => {:city => "London"}
-      #
-      # @param [Hash] tuple a tuple to project
-      # @param [Boolean] allbut projection?
-      # @return Hash the projected tuple
-      def project_tuple(tuple, allbut = false)
-        split_tuple(tuple, allbut).first
-      end
-
-      # Checks equality with another attribute list.
-      #
-      # @param [Object] other another attribute list
-      # @return [Boolean] true if `other` is an attribute list and contains
-      #         the same attributes, in the same order
-      def ==(other)
-        other.is_a?(AttrList) && (other.attributes == attributes)
-      end
-      alias :eql? :==
-
-      # Returns an hash code.
-      #
-      # @return [Integer] an hash code for this attribute list
-      def hash
-        attributes.hash
-      end
-
-      # Converts to an array of attribute names.
-      #
-      # @return [Array<AttrName>] and array of attribute names
-      def to_a
-        attributes.dup
-      end
-
-      # Converts to an attribute list.
-      #
-      # @return [AttrList] return self
-      def to_attr_list
-        self
-      end
-
-      # Returns a ruby literal for this attribute list.
-      #
-      # @return [String] a literal s.t. `eval(self.to_ruby_literal) == self`
-      def to_ruby_literal
-        "Alf::AttrList#{Tools.to_ruby_literal(attributes)}"
-      end
-      alias :inspect :to_ruby_literal
-
-    end # class AttrList
-  end # module Types
-end # module Alf

data/lib/alf/types/attr_name.rb

@@ -1,66 +0,0 @@
-module Alf
-  module Types
-    #
-    # Attribute name.
-    #
-    # Attribute names are ruby symbols that match the following regular 
-    # expression:
-    #
-    #     /^[a-zA-Z0-9_]+[?!]?$/
-    #
-    # Example:
-    #
-    #     AttrName["city"]
-    #     # => :city
-    #
-    class AttrName < Symbol
-      extend Myrrha::Domain
-
-      class << self
-
-        # The domain predicate
-        PREDICATE = lambda{|s| s.to_s =~ /^[a-zA-Z0-9_]+[?!]?$/}
-
-        # Returns the domain predicate.
-        #
-        # @return [Proc] the domain predicate as a Proc obbject
-        def predicate
-          PREDICATE
-        end
-
-        # Coerces `arg` to an AttrName.
-        #
-        # All objects that respond to :to_sym and match PREDICATE are
-        # valid coercion arguments.
-        #
-        # @param [Object] arg and argument to coerce to an AttrName
-        # @return [AttrName] an AttrName instance
-        # @raise [ArgumentError] is the coercion fails
-        def coerce(arg)
-          if arg.respond_to?(:to_sym)
-            sym = arg.to_sym
-            return sym if self.===(sym) 
-          end
-          raise ArgumentError, "Unable to coerce `#{arg.inspect}` to AttrName"
-        end
-        alias :[] :coerce
-
-        # Converts commandline arguments to an AttrName.
-        #
-        # This method requires `argv` to be either empty or a singleton array.
-        # When empty, `opts[:default]` is used. The value must be coercable
-        # with `coerce` for this method to suceed.
-        #
-        # @param [Array] argv commandline arguments
-        # @params [Hash] opts options (not used)
-        # @raise [ArgumentError] is the coercion fails
-        def from_argv(argv, opts = {})
-          raise ArgumentError if argv.size > 1
-          coerce(argv.first || opts[:default]) 
-        end
-
-      end
-
-    end # class AttrName
-  end # module Types
-end # module Alf

data/lib/alf/types/boolean.rb

@@ -1,25 +0,0 @@
-module Alf
-  module Types
-
-    # Defines the Boolean type which is missing to ruby.
-    Boolean = Myrrha::Boolean
-
-    # Converts commandline arguments to a Boolean.
-    #
-    # This method requires `argv` to be either empty or a singleton array.
-    # When empty, `opts[:default]` is used. The value must be coercable
-    # to a Boolean, according to Myrrha::Boolean coercions.
-    #
-    # @param [Array] argv commandline arguments
-    # @params [Hash] opts options (not used)
-    # @raise [ArgumentError] is the coercion fails
-    def Boolean.from_argv(argv, opts={})
-      raise ArgumentError if argv.size > 1
-      value = argv.first || opts[:default] || false
-      Tools.coerce(value, Boolean)
-    rescue CoercionError
-      raise ArgumentError, "Unable to coerce `#{value.inspect}` to Boolean"
-    end
-
-  end
-end