alf-core 0.15.0 → 0.16.0

data/CHANGELOG.md

@@ -1,4 +1,15 @@
-# 0.15.0 / FIX ME
+# 0.16.0 / 2014-02-18
+
+* Fixed Tuple(), it now accepts no argument and returns an empty tuple.
+* Fixed inference of common super type when TrueClass/FalseClass/Boolean are
+  involved (for Relation#heading when infered from data).
+* Fixed compilation of shortcut operators involving complex expressions.
+* Make Ordering#compare robust to the presence of `nil`.
+* Ensured Engine::Leaf correctly symbolize tuple keys of its input operand.
+* Selection now also accepts non-array selections from Symbol and String.
+* Relation#to_hash now accepts any Selection-able `from` and `to` args.
+
+# 0.15.0 / 2013-11-01
 
 * Compiler infrastructure entirely rewritten in alf-compiler
 * Changed signature of `Adapter::Connection#cog` and associated `#to_cog`

data/Gemfile

@@ -10,7 +10,6 @@ end
 group :test do
   gem "rake", "~> 10.1"
   gem "rspec", "~> 2.14"
-  gem "ruby_cop", "~> 1.0"
 end
 
 group :release do
@@ -20,4 +19,5 @@ end
 
 group :extra do
   gem "highline", "~> 1.6"
+  gem "ruby_cop", "~> 1.0"
 end

data/lib/alf-core.rb

@@ -1,39 +1 @@
-require_relative 'alf/core/loader'
-require_relative 'alf/core/version'
-require_relative 'alf/errors'
-require_relative 'alf/ext'
-require_relative 'alf/facade'
-
-module Alf
-  TupleLike    = lambda{|t| t.is_a?(Hash) || t.is_a?(Tuple) }
-  RelationLike = lambda{|r| Relation===r || Engine::Cog===r || Reader===r || Relvar===r }
-end
-
-require_relative 'alf/predicate'
-require_relative 'alf/support'
-require_relative 'alf/types'
-require_relative 'alf/aggregator'
-require_relative 'alf/algebra'
-require_relative 'alf/compiler'
-require_relative "alf/engine"
-require_relative 'alf/reader'
-require_relative 'alf/renderer'
-require_relative 'alf/lang'
-require_relative 'alf/relation'
-require_relative 'alf/relvar'
-require_relative 'alf/optimizer'
-require_relative 'alf/update'
-require_relative 'alf/adapter'
-require_relative 'alf/viewpoint'
-require_relative 'alf/database'
-require_relative 'alf/adapter/fs'
-
-module Alf
-  extend Facade
-
-  DUM = Relation::DUM
-  DEE = Relation::DEE
-end
-
-require_relative 'alf/dsl'
-include Alf::Dsl unless defined?(ALF_NO_CORE_EXTENSIONS)
+require_relative "alf/core"

data/lib/alf/algebra/operator/hierarchize.rb

@@ -6,7 +6,7 @@ module Alf
       signature do |s|
         s.argument :id,     AttrList, [:id]
         s.argument :parent, AttrList, [:parent]
-        s.argument :as,     AttrName, [:children]
+        s.argument :as,     AttrName, :children
       end
 
       def heading

data/lib/alf/algebra/operator/unwrap.rb

@@ -11,8 +11,11 @@ module Alf
 
       def heading
         @heading ||= begin
-          op_h = operand.heading
-          op_h.allbut([attribute]).merge(op_h[attribute].heading)
+          op_h   = operand.heading
+          type   = op_h[attribute]
+          raise NotSupportedError unless type.respond_to?(:heading)
+          down_h = type.heading
+          op_h.allbut([attribute]).merge(down_h)
         end
       end
 

data/lib/alf/algebra/shortcut.rb

@@ -38,3 +38,4 @@ module Alf
   end # module Algebra
 end # module Alf
 require_relative 'shortcut/allbut'
+require_relative 'shortcut/image'

data/lib/alf/algebra/shortcut/image.rb

@@ -0,0 +1,33 @@
+module Alf
+  module Algebra
+    class Image
+      include Shortcut
+      include Binary
+
+      signature do |s|
+        s.argument :name, AttrName, []
+      end
+
+      def keys
+        left.keys
+      end
+
+      def expand
+        grouped = join(left, group(right, common_attrs, name, allbut: true))
+        missing = extend(not_matching(left, right), name => group_type.empty)
+        union(grouped, missing)
+      end
+
+    private
+
+      def common_attrs
+        left.attr_list & right.attr_list
+      end
+
+      def group_type
+        @group_type ||= Relation[right.heading.allbut(common_attrs)]
+      end
+
+    end # class Image
+  end # module Algebra
+end # module Alf

data/lib/alf/compiler.rb

@@ -22,7 +22,7 @@ module Alf
     end
 
     def on_shortcut(plan, expr, *compiled)
-      plan.recompile(*compiled){|p| expr.expand }
+      plan.__compile{|p| expr.expand }
     end
 
     def on_missing(plan, expr, *compiled)

data/lib/alf/compiler/cog.rb

@@ -30,8 +30,15 @@ module Alf
         Support::Tree.new(self).to_text
       end
 
+      def relation_type
+        @relation_type ||= Relation[heading]
+      end
+
       def to_relation
-        Relation.coerce(each.to_set)
+        raise NotSupportedError unless expr
+        relation_type.new(each)
+      rescue NotSupportedError
+        Relation.coerce(each)
       end
 
     end # module Cog

data/lib/alf/core.rb

@@ -0,0 +1,39 @@
+require_relative 'core/loader'
+require_relative 'core/version'
+require_relative 'errors'
+require_relative 'ext'
+require_relative 'facade'
+
+module Alf
+  TupleLike    = lambda{|t| t.is_a?(Hash) || t.is_a?(Tuple) }
+  RelationLike = lambda{|r| Relation===r || Engine::Cog===r || Reader===r || Relvar===r }
+end
+
+require_relative 'predicate'
+require_relative 'support'
+require_relative 'types'
+require_relative 'aggregator'
+require_relative 'algebra'
+require_relative 'compiler'
+require_relative 'engine'
+require_relative 'reader'
+require_relative 'renderer'
+require_relative 'lang'
+require_relative 'relation'
+require_relative 'relvar'
+require_relative 'optimizer'
+require_relative 'update'
+require_relative 'adapter'
+require_relative 'viewpoint'
+require_relative 'database'
+require_relative 'adapter/fs'
+
+module Alf
+  extend Facade
+
+  DUM = Relation::DUM
+  DEE = Relation::DEE
+end
+
+require_relative 'dsl'
+include Alf::Dsl unless defined?(ALF_NO_CORE_EXTENSIONS)

data/lib/alf/core/version.rb

@@ -3,7 +3,7 @@ module Alf
     module Version
 
       MAJOR = 0
-      MINOR = 15
+      MINOR = 16
       TINY  = 0
 
       def self.to_s

data/lib/alf/database/connection.rb

@@ -41,7 +41,7 @@ module Alf
       ### logical level
 
       def parse(*args, &bl)
-        parser.parse(*args, &bl)
+        Algebra::Operand.coerce parser.parse(*args, &bl)
       end
 
       def optimize(*args, &bl)

data/lib/alf/engine/group/hash.rb

@@ -33,7 +33,7 @@ module Alf
         atr, alb = @attributes, @allbut
         index = Materialize::Hash.new(operand, atr, !alb, expr)
         index.each_pair do |k,v|
-          grouped = Clip.new(v, atr, alb, expr).to_relation
+          grouped = Clip.new(v, atr, alb).to_relation
           yield k.merge(@as => grouped)
         end
       end

data/lib/alf/engine/leaf.rb

@@ -16,8 +16,10 @@ module Alf
       end
 
       # (see Cog#each)
-      def _each(&block)
-        operand.each(&block)
+      def _each
+        operand.each do |tuple|
+          yield(symbolize(tuple))
+        end
       end
 
       def to_s

data/lib/alf/engine/ungroup.rb

@@ -21,7 +21,10 @@ module Alf
         operand.each do |tuple|
           tuple = tuple.dup
           tuple = tuple.to_hash unless tuple.is_a?(Hash)
-          tuple.delete(@attribute).each do |subtuple|
+          unless rva = tuple.delete(@attribute)
+            raise "No such RVA `#{@attribute}` on #{tuple.inspect}"
+          end
+          rva.each do |subtuple|
             subtuple = symbolize(subtuple)
             yield tuple.merge(subtuple)
           end

data/lib/alf/ext.rb

@@ -1 +1,2 @@
 require_relative 'ext/domain/heading_based'
+require_relative 'ext/yaml'

data/lib/alf/ext/domain/heading_based.rb

@@ -54,11 +54,17 @@ module Domain
           other.to_heading==to_heading
         }
         define_method(:coerce){|arg|
+          return arg if self==arg.class
           master_class.coercions.apply(arg, self)
         }
         define_method(:to_heading){
           @heading ||= Alf::Heading.coerce(generating_type)
         }
+        define_method(:to_tuple_type){
+          return self if Alf::Tuple==master_class
+          return gt   if gt.is_a?(Class) && gt < Alf::Tuple
+          @tuple_type ||= Alf::Tuple[to_heading]
+        }
         define_method(:recursive?){
           h = to_heading
           h.to_attr_list.any?{|a| h[a] == self}

data/lib/alf/ext/yaml.rb

@@ -0,0 +1,35 @@
+module Psych
+  module Visitors
+    class YAMLTree
+
+      def visit_Alf_Tuple o
+        @emitter.start_mapping(nil, nil, true, Psych::Nodes::Mapping::BLOCK)
+        o.to_hash.each do |k,v|
+          accept k.to_s
+          accept v
+        end
+        @emitter.end_mapping
+      end
+
+      def visit_Alf_Relation o
+        @emitter.start_sequence(nil, nil, true, Nodes::Sequence::BLOCK)
+        o.each { |c| accept c }
+        @emitter.end_sequence
+      end
+
+      def visit_Alf_Renderer_YAML o
+        @emitter.start_sequence(nil, nil, true, Nodes::Sequence::BLOCK)
+        o.input.each{|tuple|
+          @emitter.start_mapping(nil, nil, true, Psych::Nodes::Mapping::BLOCK)
+          tuple.to_hash.each do |k,v|
+            accept k.to_s
+            accept v
+          end
+          @emitter.end_mapping
+        }
+        @emitter.end_sequence
+      end
+
+    end
+  end
+end

data/lib/alf/facade.rb

@@ -35,8 +35,10 @@ module Alf
       end
     end
 
-    def Tuple(first, *rest, &bl)
-      if first.respond_to?(:to_tuple) && rest.empty? && bl.nil?
+    def Tuple(first = nil, *rest, &bl)
+      if first.nil? or (first.is_a?(Hash) && first.empty?)
+        Alf::Tuple::EMPTY
+      elsif first.respond_to?(:to_tuple) && rest.empty? && bl.nil?
         return first.to_tuple
       else
         tuple = Alf::Tuple.coerce(*rest.unshift(first))

data/lib/alf/reader/rash.rb

@@ -27,6 +27,11 @@ module Alf
         end
       end
 
+      # Register .rash files for Relation loading
+      Path.register_loader('.rash'){|file|
+        Alf::Reader::Rash.new(file).to_a
+      }
+
       Reader.register(:rash, [".rash"], self)
     end # class Rash
   end # class Reader

data/lib/alf/relation.rb

@@ -24,7 +24,8 @@ module Alf
     include Lang::ObjectOriented
 
     def initialize(tuples)
-      super(tuples.map{|x| Tuple.coerce(x)}.to_set)
+      tuple_type = self.class.to_tuple_type
+      super(tuples.map{|x| tuple_type.coerce(x) }.to_set)
     end
 
     coercions do |c|
@@ -42,8 +43,7 @@ module Alf
       end
       c.coercion(Enumerable) do |v,rt|
         rt = Relation[Engine::InferHeading.new(v).first] if Relation==rt
-        tt = rt.generating_type.is_a?(Class) ? rt.generating_type : Tuple[rt.heading]
-        rt.new(v.map{|t| tt.coerce(t) }.to_set).check_internal_representation!
+        rt.new(v).check_internal_representation!
       end
     end
 
@@ -110,11 +110,12 @@ module Alf
 
     def to_hash(from, to=nil)
       if from.is_a?(Hash) and to.nil?
-        raise ArgumentError "Hash of size 1 expected. " unless from.size==1
+        raise ArgumentError "Hash of size 1 expected." unless from.size==1
         to_hash(from.keys.first, from.values.first)
       else
+        from, to = Selection.coerce(from), Selection.coerce(to)
         each.each_with_object({}) do |tuple, hash|
-          key, value = tuple[from], tuple[to]
+          key, value = from.select(tuple), to.select(tuple)
           if hash.has_key?(key) and hash[key] != value
             raise "Key expected for `#{from}`, divergence found on `#{key}`"
           else

data/lib/alf/relvar.rb

@@ -77,9 +77,7 @@ module Alf
     end
 
     def to_relation
-      type.new(to_cog.to_set)
-    rescue NotSupportedError
-      Relation.coerce(to_cog.each.to_a)
+      to_cog.to_relation
     end
 
   private

data/lib/alf/relvar/read_only.rb

@@ -11,7 +11,7 @@ module Alf
       end
 
       def to_relation
-        expr.subject
+        Relation.coerce(expr.subject)
       end
 
       ### Update

data/lib/alf/renderer/text.rb

@@ -128,8 +128,7 @@ module Alf
         end
 
         def each_line(pretty = options[:pretty])
-          if pretty
-            trim = options[:trim_at]
+          if pretty && trim = options[:trim_at]
             each_line(false) do |line|
               yield(line[0..trim])
             end

data/lib/alf/renderer/yaml.rb

@@ -9,6 +9,13 @@ module Alf
         "text/yaml"
       end
 
+      def execute(output = $stdout)
+        require "psych"
+        visitor = Psych::Visitors::YAMLTree.new
+        visitor << self
+        output << visitor.tree.to_yaml
+      end
+
       def each
         return to_enum unless block_given?
         require "yaml"

data/lib/alf/support/miscellaneous.rb

@@ -56,5 +56,14 @@ module Alf
       tuple.each_with_object({}){|(k,v),h| h[k.to_s] = v}
     end
 
+    # Compare `x` and `y` in a robust way, that is, by handling `nil` without
+    # failure.
+    def robust_compare(x, y)
+      return 0  if x==y
+      return -1 if x.nil?
+      return 1  if y.nil?
+      x.respond_to?(:<=>) ? (x <=> y) : (x.to_s <=> y.to_s)
+    end
+
   end # module Support
 end # module Alf