alf-core 0.14.0 → 0.15.0

data/lib/{alf-predicate/alf → alf}/predicate/nodes/in.rb

@@ -7,7 +7,7 @@ module Alf
         80
       end
 
-      def var_ref
+      def identifier
         self[1]
       end
 
@@ -16,7 +16,7 @@ module Alf
       end
 
       def free_variables
-        @free_variables ||= var_ref.free_variables
+        @free_variables ||= identifier.free_variables
       end
 
       def constant_variables

data/lib/alf/predicate/nodes/native.rb

@@ -0,0 +1,32 @@
+module Alf
+  class Predicate
+    module Native
+      include Expr
+
+      def priority
+        90
+      end
+
+      def proc
+        self[1]
+      end
+
+      def to_ruby_code(scope = 't')
+        if proc.respond_to?(:source_code)
+          code = proc.source_code
+          return code if code
+        end
+        raise NotSupportedError
+      end
+
+      def to_proc(scope = 't')
+        proc
+      end
+
+      def free_variables
+        raise NotSupportedError
+      end
+
+    end
+  end
+end

data/lib/{alf-predicate/alf/predicate/nodes/native.rb → alf/predicate/nodes/qualified_identifier.rb}

@@ -1,18 +1,22 @@
 module Alf
   class Predicate
-    module Native
+    module QualifiedIdentifier
       include Expr
 
       def priority
-        90
+        100
       end
 
-      def to_proc(options = {})
+      def qualifier
         self[1]
       end
 
+      def name
+        self[2]
+      end
+
       def free_variables
-        raise NotSupportedError
+        @free_variables ||= AttrList[ name ]
       end
 
     end

data/lib/alf/predicate/processors.rb

@@ -0,0 +1,3 @@
+require_relative "processors/to_ruby_code"
+require_relative "processors/renamer"
+require_relative "processors/qualifier"

data/lib/alf/predicate/processors/qualifier.rb

@@ -0,0 +1,25 @@
+module Alf
+  class Predicate
+    class Qualifier < Sexpr::Rewriter
+
+      grammar Grammar
+
+      def initialize(qualifier)
+        @qualifier = qualifier
+      end
+      attr_reader :qualifier
+
+      def on_identifier(sexpr)
+        return sexpr unless q = qualifier[sexpr.name]
+        [:qualified_identifier, q, sexpr.name]
+      end
+
+      def on_native(sexpr)
+        raise NotSupportedError
+      end
+
+      alias :on_missing :copy_and_apply
+
+    end
+  end
+end

data/lib/alf/predicate/processors/renamer.rb

@@ -0,0 +1,27 @@
+module Alf
+  class Predicate
+    class Renamer < Sexpr::Rewriter
+
+      grammar Grammar
+
+      def on_identifier(sexpr)
+        return sexpr unless new_name = options[:renaming][sexpr.name]
+        return new_name if Sexpr===new_name
+        [:identifier, new_name]
+      end
+
+      def on_qualified_identifier(sexpr)
+        return sexpr unless new_name = options[:renaming][sexpr.name]
+        return new_name if Sexpr===new_name
+        [:qualified_identifier, sexpr.qualifier, new_name]
+      end
+
+      def on_native(sexpr)
+        raise NotSupportedError
+      end
+
+      alias :on_missing :copy_and_apply
+
+    end
+  end
+end

data/lib/{alf-predicate/alf → alf}/predicate/processors/to_ruby_code.rb

@@ -10,7 +10,11 @@ module Alf
         "false"
       end
 
-      def on_var_ref(sexpr)
+      def on_qualified_identifier(sexpr)
+        "#{sexpr.qualifier}.#{sexpr.name}"
+      end
+
+      def on_identifier(sexpr)
         if s = options[:scope]
           "#{s}.#{sexpr.last.to_s}"
         else
@@ -43,16 +47,7 @@ module Alf
       alias :on_gte :on_dyadic
 
       def on_in(sexpr)
-        "#{Support.to_ruby_literal(sexpr.values)}.include?(#{apply(sexpr.var_ref)})"
-      end
-
-      def on_native(sexpr)
-        proc = sexpr.to_proc
-        if proc.respond_to?(:to_ruby_literal) &&
-           (proc.to_ruby_literal =~ /^\s*lambda{\s*(.*?)\s*}\s*$/)
-          return $1
-        end
-        raise NotSupportedError
+        "#{Support.to_ruby_literal(sexpr.values)}.include?(#{apply(sexpr.identifier)})"
       end
 
       def on_literal(sexpr)

data/lib/{alf-io/alf → alf}/reader.rb

@@ -130,7 +130,12 @@ module Alf
       end
     end
 
-    protected
+    # Returns a string representation
+    def to_s
+      "#{self.class.name}(#{Path(input_path).basename || '...'})"
+    end
+
+  protected
 
     # @return the input file path, or nil if this Reader is bound to an IO
     # directly.
@@ -145,7 +150,10 @@ module Alf
     def with_input_io(&bl)
       case input
       when IO, StringIO
-        input.rewind unless input.pos==0
+        begin
+          input.rewind unless input.pos==0
+        rescue Errno::ESPIPE => ex
+        end
         yield input
       when String, Path
         Path(input).open('r', &bl)
@@ -187,3 +195,4 @@ require_relative 'reader/rash'
 require_relative 'reader/csv'
 require_relative 'reader/json'
 require_relative 'reader/ruby'
+require_relative 'reader/yaml'

data/lib/alf/reader/yaml.rb

@@ -0,0 +1,25 @@
+module Alf
+  class Reader
+    #
+    # Implements Alf::Reader contract for reading YAML input.
+    #
+    class YAML < Reader
+
+      def self.mime_type
+        "text/yaml"
+      end
+
+      def each
+        return to_enum unless block_given?
+        require 'yaml'
+        p = ::YAML.load(input_text)
+        p = [p] if TupleLike===p
+        p.each do |t|
+          yield Support.symbolize_keys(t)
+        end
+      end
+
+      Alf::Reader.register(:yaml, [".yaml", ".yml"], self)
+    end # class YAML
+  end # class Reader
+end # module Alf

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

@@ -83,18 +83,28 @@ module Alf
       self.class.heading
     end
 
+    # Returns the relation keys
+    def keys
+      Keys[to_attr_list]
+    end
+
     # Returns the attribute list.
     def to_attr_list
       heading.to_attr_list
     end
 
+    # Returns self
+    def to_relation
+      self
+    end
+
     # Returns a ReadOnly relvar
     def to_relvar
       Relvar::ReadOnly.new(self)
     end
 
     # Returns an engine Cog
-    def to_cog
+    def to_cog(plan = nil)
       Engine::Leaf.new(self, self)
     end
 
@@ -132,7 +142,7 @@ module Alf
   private
 
     def _operator_output(op)
-      Engine::Compiler.new.call(op).to_relation
+      op.to_relation
     end
 
     def _self_operand

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

@@ -1,32 +1,25 @@
 module Alf
   module Relvar
+    extend Forwardable
     include Algebra::Operand
     include Lang::ObjectOriented
 
-    def connection
-      expr.connection
+    def initialize(expr = nil)
+      @expr = expr
     end
+    attr_reader :expr
 
-    def connection=(conn)
-      expr.connection = conn
-    end
-
-    def connection!
-      expr.connection!
-    end
-
-    def bind(connection)
-      expr.bind(connection)
-    end
-
-    def bound?
-      expr.bound?
-    end
+    def_delegators :expr, :heading,
+                          :keys,
+                          :to_cog,
+                          :to_lispy
 
     def type
       @type ||= Relation[heading]
     end
 
+    ###
+
     def each(&bl)
       to_cog.each(&bl)
     end
@@ -83,10 +76,6 @@ module Alf
       self
     end
 
-    def to_lispy
-      raise NotImplementedError
-    end
-
     def to_relation
       type.new(to_cog.to_set)
     rescue NotSupportedError
@@ -95,6 +84,10 @@ module Alf
 
   private
 
+    def _self_operand
+      expr
+    end
+
     def _operator_output(expr)
       Relvar::Virtual.new(expr)
     end

data/lib/alf/relvar/base.rb

@@ -0,0 +1,35 @@
+module Alf
+  module Relvar
+    class Base
+      extend Forwardable
+      include Relvar
+
+      def_delegators :expr, :connection,
+                            :connection!
+
+      ### Update
+
+      def lock(mode = :exclusive, &bl)
+        connection!.lock(expr.name, mode, &bl)
+      end
+
+      def insert(tuples)
+        tuples = [ tuples ] if TupleLike===tuples
+        connection!.insert(expr.name, tuples)
+      end
+
+      def delete(predicate = Predicate.tautology)
+        connection!.delete(expr.name, predicate)
+      end
+
+      def update(updating, predicate = Predicate.tautology)
+        connection!.update(expr.name, updating, predicate)
+      end
+
+      def to_s
+        "Relvar::Base(#{expr.name.inspect})"
+      end
+
+    end # class Base
+  end # module Relvar
+end # module Alf

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

@@ -4,10 +4,11 @@ module Alf
       include Relvar
 
       def initialize(expr, heading)
-        @expr = expr
+        super(expr)
         @heading = Heading.coerce(heading)
+        @connection = connection
       end
-      attr_reader :expr, :heading
+      attr_reader :heading
 
       def insert(tuples)
         @inserted_tuples = tuples.to_a

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

@@ -4,22 +4,14 @@ module Alf
       include Relvar
 
       def initialize(value)
-        @value = value
+        unless value.is_a?(Algebra::Operand::Proxy)
+          value = Algebra::Operand::Proxy.new(value)
+        end
+        super(value)
       end
-      attr_reader :value
 
-      ### Static analysis & inference
-
-      def type
-        value.class
-      end
-
-      def heading
-        value.heading
-      end
-
-      def keys
-        value.keys
+      def to_relation
+        expr.subject
       end
 
       ### Update
@@ -42,26 +34,10 @@ module Alf
 
       ### to_xxx
 
-      alias_method :to_relation, :value
-
-      def to_cog
-        value.to_cog
-      end
-
-      def to_lispy
-        value.to_lispy
-      end
-
       def to_s
         "Relvar::ReadOnly(#{value.to_s})"
       end
 
-    private
-
-      def _self_operand
-        value
-      end
-
     end # class Base
   end # module Relvar
 end # module Alf