alf-core 0.14.0 → 0.15.0

data/lib/{alf-engine/alf → alf}/engine/wrap.rb

@@ -19,8 +19,8 @@ module Alf
       attr_reader :allbut
 
       # Creates a SetAttr instance
-      def initialize(operand, attributes, as, allbut, expr = nil)
-        super(expr)
+      def initialize(operand, attributes, as, allbut, expr = nil, compiler = nil)
+        super(expr, compiler)
         @operand = operand
         @attributes = attributes
         @as = as
@@ -36,6 +36,10 @@ module Alf
         end
       end
 
+      def arguments
+        [ attribute ]
+      end
+
     end # class Wrap
   end # module Engine
 end # module Alf

data/lib/{alf-core → alf}/errors.rb

@@ -10,7 +10,6 @@ module Alf
   class ReadOnlyError < Error; end
   class TypeCheckError < Error; end
   class IllegalStateError < Error; end
-
-  # deprecated
-  class UnsupportedError < Error; end
+  class SecurityError < Error; end
+  class UnsupportedMimeTypeError < Error; end
 end

data/lib/{alf-core → alf}/ext/domain/heading_based.rb

@@ -1,6 +1,8 @@
 module Domain
   class HeadingBased < Module
 
+    EMPTY_SET = Set.new.freeze
+
     def initialize(master_class)
       define_method(:new){|*args|
         raise "#{master_class}.new may not be called directly" if master_class==self
@@ -31,6 +33,9 @@ module Domain
         define_method(:generating_type){
           gt
         }
+        define_method(:dum){
+          @dum ||= new(EMPTY_SET)
+        }
         define_method(:<=>){|other|
           return 0 if self == other
           return nil unless other.ancestors.include?(master_class)

data/lib/alf/facade.rb

@@ -0,0 +1,53 @@
+module Alf
+  module Facade
+
+    def database(*args, &bl)
+      Alf::Database.new(*args, &bl)
+    end
+
+    def connect(*args, &bl)
+      Alf::Database.connect(*args, &bl)
+    end
+
+    def query(*args, &bl)
+      connect(*args) do |conn|
+        conn.query(&bl)
+      end
+    end
+
+    def examples_adapter
+      Path.backfind('examples/suppliers_and_parts')
+    end
+
+    def examples(&bl)
+      Alf::Database.connect examples_adapter, &bl
+    end
+
+    def reader(source, *args)
+      Alf::Reader.reader(source, *args)
+    end
+
+    def Relation(first, *rest, &bl)
+      if first.respond_to?(:to_relation) && rest.empty? && bl.nil?
+        return first.to_relation
+      else
+        Alf::Relation.coerce(*rest.unshift(first), &bl)
+      end
+    end
+
+    def Tuple(first, *rest, &bl)
+      if first.respond_to?(:to_tuple) && rest.empty? && bl.nil?
+        return first.to_tuple
+      else
+        tuple = Alf::Tuple.coerce(*rest.unshift(first))
+        tuple = tuple.remap(&bl) if bl
+        tuple
+      end
+    end
+
+    def Heading(*args, &bl)
+      Alf::Heading.coerce(*args, &bl)
+    end
+
+  end
+end

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

@@ -1,4 +1,4 @@
 require_relative 'lang/functional'
 require_relative 'lang/predicates'
 require_relative 'lang/object_oriented'
-require_relative 'lang/lispy'
+require_relative 'lang/parser'

data/lib/{alf-lang/alf → alf}/lang/functional.rb

@@ -37,10 +37,6 @@ module Alf
         def_operator_method(name, clazz)
       end
 
-      def allbut(operand, attributes)
-        project(operand, attributes, :allbut => true)
-      end
-
     private
 
       def _op_wrap(expr)

data/lib/{alf-lang/alf → alf}/lang/oo/aggregation_methods.rb

@@ -5,7 +5,7 @@ module Alf
 
         def self.def_aggregator_method(name, clazz)
           define_method(name) do |*args, &block|
-            clazz.new(*args, &block).aggregate(_self_operand)
+            clazz.new(*args, &block).aggregate(_self_operand.to_cog)
           end
         end
 

data/lib/{alf-lang/alf → alf}/lang/oo/algebra_methods.rb

@@ -14,14 +14,6 @@ module Alf
             # build the new expression
             expr = clazz.new(operands, *arguments)
 
-            # bind it if operands were bound
-            conns = operands.map(&:connection).uniq
-            if conns.size == 1
-              expr.connection = conns.first
-            elsif conns.size > 1
-              raise NotSupportedError, "Multiple connections unsupported"
-            end
-
             # let the abstraction have a chance to of decorating it
             _operator_output(expr)
           end
@@ -31,10 +23,6 @@ module Alf
           def_operator_method(name, clazz)
         end
 
-        def allbut(attributes)
-          project(attributes, :allbut => true)
-        end
-
         def +(other)
           union(other)
         end

data/lib/{alf-lang/alf → alf}/lang/oo/rendering_methods.rb

@@ -26,7 +26,7 @@ module Alf
         end
 
         def to_a(options = nil)
-          (options.nil? && defined?(super)) ? super() : to_array(options || {})
+          to_array(options || {})
         end
 
         Renderer.listen do |name,clazz|

data/lib/alf/lang/parser.rb

@@ -0,0 +1,9 @@
+module Alf
+  module Lang
+    module Parser
+
+    end # module Parser
+  end # module Lang
+end # module Alf
+require_relative 'parser/lispy'
+

data/lib/alf/lang/parser/lispy.rb

@@ -0,0 +1,63 @@
+module Alf
+  module Lang
+    module Parser
+      class Lispy
+        include Parser
+        include Functional
+        include Predicates
+
+        def initialize(helpers = [], connection = nil)
+          @connection = connection
+          @extensions = helpers
+          helpers.each do |helper|
+            helper.send(:extend_object, self)
+          end
+        end
+        attr_reader :connection
+
+        def connection!
+          connection.tap{|c|
+            ::Kernel.raise(UnboundError, "#{self} not bound") unless c
+          }
+        end
+
+        def parse(expr = nil, path = nil, line = nil, &block)
+          if (expr && block) || (expr.nil? and block.nil?)
+            raise ArgumentError, "Either `expr` or `block` should be specified"
+          end
+          expr = evaluate(expr, path, line, &block) if block or expr.is_a?(String)
+          expr = __send__(expr)                     if expr.is_a?(Symbol)
+          expr
+        end
+
+        def to_s
+          "Lispy(#{@extensions.map(&:name).compact.join(',')})"
+        end
+
+        def inspect
+          "Lispy(#{@extensions.inspect})"
+        end
+
+      private
+
+        def evaluate(expr = nil, path=nil, line=nil, &bl)
+          return instance_exec(&bl) if bl
+          instance_eval(expr, *[path, line].compact.map(&:to_s))
+        end
+
+      public
+
+        # Resolve DUM and DEE in ruby 1.9.2 context
+        def self.const_missing(name)
+          case name.to_s
+          when 'DEE' then ::Alf::Relation::DEE
+          when 'DUM' then ::Alf::Relation::DUM
+          else
+            super
+          end
+        end
+
+      end # class Lispy
+    end # module Parser
+  end # module Lang
+end # module Alf

data/lib/alf/lang/parser/safer.rb

@@ -0,0 +1,69 @@
+require 'ruby_cop'
+module Alf
+  module Lang
+    module Parser
+      class Safer
+        include Parser
+
+        def initialize(helpers = [], connection = nil)
+          @lispy = Lispy.new(helpers, connection)
+        end
+
+        def parse(expr = nil, *rest, &bl)
+          if expr.nil? and bl
+            raise SecurityError, "Parsing of ruby blocks forbidden"
+          end
+          return expr if expr.is_a?(Algebra::Operand)
+          check_safety!(expr.to_s)
+          @lispy.parse(expr.to_s, *rest, &bl)
+        end
+
+      private
+
+        def check_safety!(query)
+          policy = Policy.new
+          ast    = RubyCop::NodeBuilder.build(query)
+          unless ast.accept(policy)
+            raise SecurityError, "Forbidden for security reasons"
+          end
+          query
+        end
+
+        class Policy < RubyCop::Policy
+
+          ALF_CALL_BLACKLIST = %w[
+            gem
+            puts
+            to_cog
+            to_relvar
+            to_relation
+            insert
+            delete
+            update
+            affect
+            upsert
+          ].to_set.freeze
+
+          def visit_Call(node)
+            super && !ALF_CALL_BLACKLIST.include?(node.identifier.token.to_s)
+          end
+
+          ALF_CONSTANT_WHITELIST = %w[
+            DEE
+            DUM
+          ].to_set.freeze
+
+          def visit_Constant(node)
+            ALF_CONSTANT_WHITELIST.include?(node.token.to_s)
+          end
+
+          def visit_ConstantAssignment(node)
+            raise SecurityError, "Forbidden: constant assignment"
+          end
+
+        end # class Policy
+
+      end # class Safer
+    end # module Parser
+  end # module Lang
+end # module Alf

data/lib/{alf-lang/alf → alf}/lang/predicates.rb

@@ -3,7 +3,7 @@ module Alf
     module Predicates
 
       [ :tautology, :contradiction,
-        :in, :eq, :neq,
+        :among, :in, :eq, :neq,
         :lt, :lte, :gt, :gte, :between ].each do |m|
 
         define_method(m) do |*args|

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

@@ -1,4 +1,3 @@
-require_relative 'optimizer/restrict'
 module Alf
   class Optimizer
 
@@ -7,16 +6,23 @@ module Alf
     end
 
     def call(expr)
-      @processors.inject(expr) do |c, (p,k)|
-        Search.new(p, k).call(c)
-      end
+      @processors.inject(expr){|c,p| p.call(c) }
     end
 
-    def register(processor, interest)
-      @processors << [processor, interest]
+    def register(processor)
+      @processors << processor
       self
     end
 
+    class Base < Algebra::Rewriter
+      include Lang::Functional
+
+      def call(expr, search = nil)
+        return Search.new(self, search_predicate).call(expr) unless search
+        _call(expr, search)
+      end
+    end
+
     class Search < Algebra::Rewriter
 
       def initialize(processor, interest)
@@ -35,4 +41,6 @@ module Alf
     end # class Search
 
   end # class Optimizer
-end # module Alf
+end # module Alf
+require_relative 'optimizer/restrict'
+require_relative 'optimizer/project'

data/lib/alf/optimizer/project.rb

@@ -0,0 +1,182 @@
+module Alf
+  class Optimizer
+    class Project < Optimizer::Base
+
+    ###
+
+      def project(operand, attributes, options)
+        options[:allbut] ? allbut(operand, attributes) : super
+      end
+
+    ### overridings
+
+      def search_predicate
+        Algebra::Project
+      end
+
+      def _call(project, search)
+        apply(project.operand, project.attributes, project.allbut, search)
+      end
+
+      def apply(expr, attributes, allbut, search)
+        check_stop(expr, attributes, allbut, search){ super }
+      rescue NotSupportedError
+        project(expr, attributes, allbut)
+      end
+
+      def check_stop(expr, attributes, allbut, search)
+        return search.call(expr) if (allbut  && attributes.empty?)
+        return search.call(expr) if (!allbut && attributes==expr.attr_list)
+        yield
+      rescue NotSupportedError
+        yield
+      end
+
+    ### callbacks
+
+      def on_unoptimizable(expr, attributes, allbut, search)
+        project(search.call(expr), attributes, allbut: allbut)
+      end
+      alias :on_missing      :on_unoptimizable
+      alias :on_todo         :on_unoptimizable
+      alias :on_leaf_operand :on_unoptimizable
+
+    ###
+
+      alias :on_autonum :on_todo
+
+      def on_clip(expr, attributes, allbut, search)
+        inside, outside = expr.attributes, attributes
+        if expr.allbut != allbut
+          attributes = allbut ? inside - outside : outside - inside
+          allbut = false
+        else
+          attributes = allbut ? inside | outside : inside & outside
+        end
+        apply(expr.operand, attributes, allbut, search)
+      end
+
+      alias :on_coerce   :on_todo
+      alias :on_compact  :on_todo
+      alias :on_defaults :on_todo
+
+      def on_extend(expr, attributes, allbut, search)
+        ext = expr.ext.project(attributes, allbut)
+        if ext.empty?
+          apply(expr.operand, attributes, allbut, search)
+        else
+          op = search.call(expr.operand)
+          project(extend(op, ext), attributes, allbut: allbut)
+        end
+      end
+
+      alias :on_frame         :on_todo
+      alias :on_generator     :on_unoptimizable
+      alias :on_group         :on_todo
+      alias :on_hierarchize   :on_unoptimizable
+      alias :on_intersect     :on_unoptimizable
+
+      def on_join(expr, attributes, allbut, search)
+        commons = expr.left.attr_list & expr.right.attr_list
+
+        # compute actual projection attributes on left and right
+        proj_a  = allbut ? attributes - commons : attributes + commons
+        left_a  = expr.left.attr_list & proj_a
+        right_a = expr.right.attr_list & proj_a
+
+        # make both projections
+        left  = apply(expr.left, left_a, allbut, search)
+        right = apply(expr.right, right_a, allbut, search)
+
+        # re-apply the join
+        rw = join(left, right)
+
+        # add the outer projection unless the job has already been done
+        unless attributes == (left_a + right_a)
+          outside = allbut ? attributes - left_a - right_a : attributes
+          rw = project(rw, outside, allbut: allbut)
+        end
+
+        rw
+      end
+
+      def on_binary_splitable(expr, attributes, allbut, search)
+        commons = expr.left.attr_list & expr.right.attr_list
+
+        # compute inside and outside projection attributes such as preserving
+        # commons
+        inside  = allbut ? attributes - commons : attributes + commons
+        outside = allbut ? attributes - inside  : attributes
+
+        # apply on left operand with inside attributes
+        left  = apply(expr.left, inside, allbut, search)
+        right = expr.right
+
+        # rewrite it now
+        rw = expr.class.new([left, right])
+
+        # add the outside projection unless the job is already done by the
+        # inside projection
+        rw = project(rw, outside, allbut: allbut) unless inside == attributes
+
+        rw
+      end
+      alias :on_matching     :on_binary_splitable
+      alias :on_not_matching :on_binary_splitable
+      alias :on_minus        :on_unoptimizable
+      alias :on_page         :on_todo
+      alias :on_project      :on_clip
+      alias :on_quota        :on_todo
+      alias :on_rank         :on_todo
+
+      def on_rename(expr, attributes, allbut, search)
+        inside = expr.renaming.invert.rename_attr_list(attributes)
+
+        # project the operand on renamed attributes
+        rw = apply(expr.operand, inside, allbut, search)
+
+        # apply the renaming unless all attributes have been projected away
+        renaming = inside.project_tuple(expr.renaming.to_hash, allbut)
+        unless renaming.empty?
+          rw = rename(rw, renaming)
+        end
+
+        rw
+      end
+
+      alias :on_restrict :on_todo
+
+      def on_sort(expr, attributes, allbut, search)
+        sort_a = expr.ordering.to_attr_list
+
+        # compute inside projection attributes
+        inside = allbut ? attributes - sort_a : attributes + sort_a
+
+        # project the operand and sort the result
+        rw = apply(expr.operand, inside, allbut, search)
+        rw = sort(rw, expr.ordering)
+
+        # project unless the job has already been done
+        unless inside == attributes
+          outside = allbut ? attributes - inside : attributes
+          rw = project(rw, outside, allbut: allbut)
+        end
+
+        rw
+      end
+
+      alias :on_summarize :on_todo
+      alias :on_ungroup   :on_todo
+
+      def on_union(expr, attributes, allbut, search)
+        left  = apply(expr.left, attributes, allbut, search)
+        right = apply(expr.right, attributes, allbut, search)
+        union(left, right)
+      end
+
+      alias :on_unwrap :on_todo
+      alias :on_wrap   :on_todo
+
+    end # class Project
+  end # class Optimizer
+end # module Alf