alf-core 0.14.0 → 0.15.0

data/lib/{alf-relvar/alf → alf}/relvar/virtual.rb

@@ -3,23 +3,6 @@ module Alf
     class Virtual
       include Relvar
 
-      def initialize(expr)
-        @expr = expr
-      end
-      attr_reader :expr
-
-      ### Static analysis & inference
-
-      def heading
-        expr.heading
-      end
-
-      def keys
-        expr.keys
-      end
-
-      ### Update
-
       # Inserts some tuples inside this relation variable.
       def insert(tuples)
         tuples = [ tuples ] if TupleLike===tuples
@@ -38,24 +21,10 @@ module Alf
 
       ### to_xxx
 
-      def to_cog
-        connection!.cog(expr)
-      end
-
-      def to_lispy
-        expr.to_lispy
-      end
-
       def to_s
         "Relvar::Virtual(#{expr})"
       end
 
-    private
-
-      def _self_operand
-        expr
-      end
-
     end # class Base
   end # module Relvar
 end # module Alf

data/lib/{alf-io/alf → alf}/renderer/yaml.rb

@@ -6,14 +6,14 @@ module Alf
     class YAML < ::Alf::Renderer
 
       def self.mime_type
-        "text/x-yaml"
+        "text/yaml"
       end
 
       def each
         return to_enum unless block_given?
         require "yaml"
         yield("---\n")
-        input.each do |tuple|
+        Engine::ToArray.new(input).each do |tuple|
           yield "-" << tuple.to_hash.to_yaml[4..-1].gsub(/^/, "  ")[1..-1]
         end
         yield("\n")

data/lib/{alf-support/alf → alf}/support.rb

@@ -15,7 +15,8 @@ require_relative 'support/to_lispy'
 require_relative 'support/scope'
 require_relative 'support/tuple_scope'
 require_relative 'support/miscellaneous'
-require_relative 'support/bindable'
 require_relative 'support/ordered_set'
 require_relative 'support/config'
 require_relative 'support/dot_utils'
+require_relative 'support/tree'
+require_relative 'support/csv_utils'

data/lib/{alf-support/alf → alf}/support/to_lispy.rb

@@ -1,6 +1,8 @@
 module Alf
   module Support
 
+    NOT_PROVIDED = Object.new.freeze
+
     # Converts `value` to a lispy expression.
     #
     # Example:
@@ -13,8 +15,11 @@ module Alf
     #
     # @param [Object] expr any ruby object denoting a lispy expression
     # @return [String] a lispy expression for `value`
-    def to_lispy(expr)
+    def to_lispy(expr, default = NOT_PROVIDED)
       ToLispy.apply(expr)
+    rescue NotSupportedError
+      raise if default == NOT_PROVIDED
+      default
     end
 
     # Myrrha rules for converting to ruby literals

data/lib/alf/support/tree.rb

@@ -0,0 +1,51 @@
+module Alf
+  module Support
+    class Tree
+
+      EMPTY_CHILDREN = [].freeze
+
+      def initialize(root)
+        @root = root
+      end
+      attr_reader :root
+
+      def label(node)
+        case node
+        when Sexpr                   then node.first.to_s
+        when Algebra::Operand::Proxy then label(node.subject)
+        when Relation::DUM           then "DUM"
+        when Relation::DEE           then "DEE"
+        when Relation                then "Relation(...)"
+        when Relvar                  then "#{node.class} ..."
+        else node.to_s
+        end
+      end
+
+      def children(node)
+        case node
+        when Sexpr             then node.sexpr_body
+        when Relvar            then [node.expr]
+        when Algebra::Operator then node.operands
+        when Algebra::Operand  then EMPTY_CHILDREN
+        when Engine::Cog       then node.children
+        else EMPTY_CHILDREN
+        end
+      end
+
+      def to_text(buffer = '', node = root, depth = 0, open = [])
+        depth.times do |i|
+          buffer << ((i==depth-1) ? "+-- " : (open[i] ? "|  " : '   '))
+        end
+        buffer << label(node) << "\n"
+        children = children(node)
+        children.each_with_index do |child, index|
+          open[depth] = (index != children.size-1)
+          to_text(buffer, child, depth+1, open)
+        end
+        buffer
+      end
+      alias :to_s :to_text
+
+    end # class Tree
+  end # module Support
+end # module Alf

data/lib/{alf-support/alf → alf}/support/tuple_scope.rb

@@ -55,6 +55,14 @@ module Alf
           @tuple[what]
         end
 
+        def to_tuple
+          Tuple(@tuple)
+        end
+
+        def to_relation
+          Relation(@tuple)
+        end
+
         def to_s
           @tuple.to_s
         end
@@ -67,7 +75,7 @@ module Alf
 
       # Creates a scope instance
       def initialize(tuple = nil, extensions = [], parent = nil)
-        super [ OwnMethods ] + extensions, parent
+        super [ OwnMethods, ::Alf::Dsl ] + extensions, parent
         __build(@tuple = tuple) if tuple
       end
 

data/lib/{alf-relation/alf → alf}/tuple.rb

@@ -29,7 +29,7 @@ module Alf
     def check_internal_representation!
       error = lambda{|msg| raise TypeError, msg }
       error["Hash expected for representation"] unless reused_instance.is_a?(Hash)
-      TypeCheck.new(heading, true).check!(reused_instance)
+      TypeCheck.new(self.class.heading, true).check!(reused_instance)
       self
     rescue TypeCheck::Error => ex
       error[ex.message]

data/lib/{alf-types/alf → alf}/types/attr_list.rb

@@ -105,14 +105,14 @@ module Alf
         c = set_compare(other)
         c and (c >= (proper ? 1 : 0))
       end
-      alias :supersetOf? :superset?
+      alias :supserset_of? :superset?
 
       # Returns true if self is a (proper) subset of `other`
       def subset?(other, proper = false)
         c = set_compare(other)
         c and (c <= (proper ? -1 : 0))
       end
-      alias :subsetOf? :subset?
+      alias :subset_of? :subset?
 
       # Returns true if self intersects another attribute list
       def intersect?(other)

data/lib/{alf-types/alf → alf}/types/ordering.rb

@@ -122,7 +122,7 @@ module Alf
       # @return [Ordering]
       def total(keys, &bl)
         list = to_attr_list
-        if k = keys.to_a.find{|k| k.to_attr_list.subsetOf?(list) }
+        if k = keys.to_a.find{|k| k.to_attr_list.subset_of?(list) }
           self
         elsif k = keys.first
           merge(k.to_ordering){|k,d1,d2| d1 }
@@ -150,6 +150,12 @@ module Alf
         reused_instance.map(&:first)
       end
 
+      # Check if this ordering subsumes another one.
+      def <=(other)
+        size = reused_instance.size
+        reused_instance == other.to_a[0...size]
+      end
+
       # Converts to an attribute list.
       #
       # @return [AttrList] a list of attribute names that participate to the

data/lib/{alf-types/alf → alf}/types/tuple_computation.rb

@@ -30,7 +30,7 @@ module Alf
         }
       end
 
-      reuse :to_hash, :map
+      reuse :to_hash, :map, :empty?
 
       # Makes the computation in the context of a tuple
       #
@@ -54,8 +54,17 @@ module Alf
       #
       # @param [TupleScope] scope a tuple scope instance.
       # @return [Hash] the resulting tuple
-      def evaluate(scope = nil, connection = nil)
-        hmap{|_,v| v.is_a?(TupleExpression) ? v.evaluate(scope, connection) : v }
+      def evaluate(scope = nil)
+        hmap{|_,v| v.is_a?(TupleExpression) ? v.evaluate(scope) : v }
+      end
+
+      # Projects this tuple computation on specified attribute names.
+      #
+      # @param [AttrList] attributes some attribute names.
+      # @param [Boolean] allbut apply a allbut projection?
+      def project(attributes, allbut = false)
+        TupleComputation.new\
+          AttrList.coerce(attributes).project_tuple(reused_instance, allbut)
       end
 
       # Returns self
@@ -88,7 +97,7 @@ module Alf
       #
       # @return [String] a literal s.t. `eval(self.to_ruby_literal) == self`
       def to_ruby_literal
-        "Alf::TupleComputation[#{Support.to_ruby_literal(reused_instance)}]"
+        "Alf::TupleComputation[#{to_lispy[1...-1]}]"
       end
       alias :inspect :to_ruby_literal
       alias :to_s :to_ruby_literal

data/lib/{alf-types/alf → alf}/types/tuple_expression.rb

@@ -33,7 +33,6 @@ module Alf
         # 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
@@ -45,8 +44,8 @@ module Alf
             arg
           when Proc
             TupleExpression.new(arg, nil)
-          when String, Symbol
-            TupleExpression.new(eval("lambda{ #{arg} }"), arg)
+          when AttrName
+            TupleExpression.new(eval("->(t){ t.#{arg} }"), "t.#{arg}")
           else
             raise ArgumentError, "Invalid argument `#{arg}` for TupleExpression()"
           end
@@ -60,18 +59,13 @@ module Alf
       # @param [TupleScope] scope a tuple scope instance.
       # @return [Object] the result of evaluating the expression in the context
       #         of `scope`
-      def evaluate(scope = nil, connection = nil)
+      def evaluate(scope = nil)
         result = if @expr_lambda.arity == 1
           @expr_lambda.call(scope)
         else
           scope.instance_exec(&@expr_lambda)
         end
-        if looks_an_expression?(result)
-          result = result.bind(connection) unless result.bound?
-          result.to_relation
-        else
-          result
-        end
+        looks_an_expression?(result) ? result.to_relation : result
       end
 
       # Infers the resulting type.
@@ -106,9 +100,9 @@ module Alf
       #
       # @return [String] a lispy expression for this tuple expression
       def to_lispy
-        "->{ #{has_source_code!} }"
+        "->(t){ #{has_source_code!} }"
       rescue NotImplementedError => ex
-        "->{ [code unavailable] }"
+        "->(t){ [code unavailable] }"
       end
 
       # Returns a ruby literal for this expression.
@@ -118,13 +112,6 @@ module Alf
         "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.
       #

data/lib/{alf-types/alf → alf}/types/type_check.rb

@@ -9,6 +9,7 @@ module Alf
         @attr_list = heading.to_attr_list
         @strict    = strict
       end
+      attr_reader :heading
 
       def strict?
         @strict

data/lib/{alf-update/alf → alf}/update/deleter.rb

@@ -45,7 +45,6 @@ module Alf
       end
 
       alias :on_generator  :not_supported
-      alias :on_type_safe :not_supported
 
       alias :on_sort :on_unary_delegate
 
@@ -59,8 +58,6 @@ module Alf
         apply_and_split(expr, predicate, AttrList[expr.as])
       end
 
-      alias :on_infer_heading :not_supported
-
       def on_intersect(expr, predicate)
         apply(expr.left, predicate)
         apply(expr.right, predicate)

data/lib/{alf-update/alf → alf}/update/inserter.rb

@@ -16,7 +16,7 @@ module Alf
       ### leaf Operand, recursion end :-)
 
       def on_leaf_operand(expr, inserted)
-        inserted = Engine::Compiler.new.call(inserted)
+        inserted = inserted.to_cog if inserted.respond_to?(:to_cog)
         expr.to_relvar.insert(inserted)
       end
 
@@ -46,10 +46,6 @@ module Alf
         apply(expr.operand, sort(inserted, expr.ordering))
       end
 
-      def on_type_safe(expr, inserted)
-        apply(expr.operand, type_safe(inserted, expr.type_safe_heading, strict: expr.strict))
-      end
-
       ### relational
 
       def on_extend(expr, inserted)
@@ -60,8 +56,6 @@ module Alf
         apply(expr.operand, ungroup(inserted, expr.as))
       end
 
-      alias :on_infer_heading :not_supported
-
       def on_intersect(expr, inserted)
         apply(expr.left, inserted)
         apply(expr.right, inserted)

data/lib/{alf-update/alf → alf}/update/updater.rb

@@ -23,13 +23,11 @@ module Alf
       alias :on_defaults   :not_supported
       alias :on_generator  :not_supported
       alias :on_sort       :not_supported
-      alias :on_type_safe :not_supported
 
       ### relational
 
       alias :on_extend        :not_supported
       alias :on_group         :not_supported
-      alias :on_infer_heading :not_supported
       alias :on_intersect     :not_supported
       alias :on_join          :not_supported
       alias :on_matching      :not_supported