alf 0.12.2 → 0.13.0

data/lib/alf/types/tuple_computation.rb

@@ -1,136 +0,0 @@
-module Alf
-  module Types
-    # 
-    # Defines the computation of a tuple from expressions mapped to names.
-    #
-    # Example:
-    #   computation = TupleComputation[
-    #     :big? => lambda{ status > 20 }
-    #     :who  => lambda{ "#{first} #{last}" }
-    #   ]
-    #   computation.call(:last => "Jones", :first => "Bill", :status => 10)
-    #   # => {:big? => false, :who => "Bill Jones"}
-    #
-    class TupleComputation
-
-      # @return [Hash] a computation hash, mapping AttrName -> TupleExpression
-      attr_reader :computation
-
-      #
-      # Creates a TupleComputation instance
-      #
-      # @param [Hash] computation, a mappping AttrName -> TupleExpression
-      #
-      def initialize(computation)
-        @computation = computation
-      end
-
-      class << self
-
-        # Coerces `arg` to a tuple computation
-        #
-        # Implemented coercions are
-        # - TupleComputation    -> self
-        # - {name => expr, ...} -> {AttrName[name] => TupleExpression[expr], ...}
-        # - [name, expr, ...]   -> {AttrName[name] => TupleExpression[expr], ...}
-        #
-        # @param [Object] arg the value to coerce to a tuple computation
-        # @return [TupleComputation] the computation when the coercion succeeds
-        def coerce(arg)
-          case arg
-          when TupleComputation
-            arg
-          when Hash
-            TupleComputation.new Hash[arg.map{|k,v|
-              if AttrName === k
-                v = TupleExpression.coerce(v) if v.is_a?(Proc)
-                [k, v] 
-              else
-                [ Tools.coerce(k, AttrName), 
-                  Tools.coerce(v, TupleExpression) ]
-              end
-            }]
-          when Array
-            coerce(Hash[*arg])
-          else
-            raise ArgumentError, "Invalid argument `arg` for TupleComputation()"
-          end
-        end
-        alias :[] :coerce
-
-        # Convert commandline arguments to a tuple computation
-        #
-        # This method reuses `coerce(Array)` and therefore shares its spec.
-        #
-        # @param [Array] args commandline arguments
-        # @param [Hash] opts coercion options (not used).
-        # @return [TupleExpression] the expression if coercion succeeds
-        # @raise [ArgumentError] if the coercion fails.
-        def from_argv(argv, opts = {})
-          coerce(argv)
-        end
-
-      end # class << self
-
-      # Makes the computation in the context of a tuple
-      #
-      # This is a convenient method for the following, longer expression:
-      #
-      #     evaluate(TupleHandle.new.set(tuple))
-      # 
-      # Note, however, using a Handle as in the example above is much more 
-      # efficient when evaluating the same computation on multiple tuples
-      # in sequence.
-      #
-      # @param [Hash] tuple a Tuple instance
-      # @return [Object] the resulting tuple
-      def call(tuple)
-        evaluate(Tools::TupleHandle.new.set(tuple))
-      end
-      alias :[] :call
-
-      # Computes the resulting tuple when expressions are evaluated in the 
-      # context of `handle`
-      #
-      # @param [TupleHandle] handle a tuple handle instance.
-      # @return [Hash] the resulting tuple
-      def evaluate(handle = nil)
-        Tools.tuple_collect(@computation){|k,v| 
-          [k, v.is_a?(TupleExpression) ? v.evaluate(handle) : v]
-        }
-      end
-
-      # Returns a hash code.
-      #
-      # @return [Integer] a hash code for this expression
-      def hash
-        @computation.hash
-      end
-
-      # Checks equality with another computation
-      #
-      # @param [TupleComputation] another computation
-      # @return [Boolean] true if self and other are equal, false otherwise
-      def ==(other)
-        other.is_a?(TupleComputation) && (computation == other.computation)
-      end
-      alias :eql? :==
-
-      # Converts to an attribute list.
-      #
-      # @return [AttrList] a list of computed attribute names
-      def to_attr_list
-        AttrList.new(computation.keys)
-      end
-
-      # Returns a ruby literal for this expression.
-      #
-      # @return [String] a literal s.t. `eval(self.to_ruby_literal) == self`
-      def to_ruby_literal
-        "Alf::TupleComputation[#{Tools.to_ruby_literal(computation)}]"
-      end
-      alias :inspect :to_ruby_literal
-
-    end # class TupleComputation
-  end # module Types
-end # module Alf

data/lib/alf/types/tuple_expression.rb

@@ -1,152 +0,0 @@
-module Alf
-  module Types
-    #
-    # A tuple expression is a Ruby expression whose evaluates in the scope of a 
-    # specific tuple handle.
-    #
-    # Example:
-    #   expr = TupleExpression["status * 10"]
-    #   expr.call(:status => 20)
-    #   # => 200
-    #
-    class TupleExpression
-
-      # @return [Proc] the lambda expression
-      attr_reader :expr_lambda
-
-      # @return [String] the expression source code (may be nil)
-      attr_reader :source
-
-      # Creates a tuple expression from a Proc object
-      #
-      # @param [Proc] expr a Proc for the expression 
-      # @param [String] source the source code of the expression (optional)
-      def initialize(expr, source = nil)
-        @expr_lambda = expr
-        @source = source
-      end
-
-      class << self
-
-        # Coerces `arg` to a tuple expression.
-        #
-        # 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
-        # @return [TupleExpression] the expression if coercion succeeds
-        # @raise [ArgumentError] if the coercion fails
-        def coerce(arg)
-          case arg
-          when TupleExpression
-            arg
-          when Proc
-            TupleExpression.new(arg, nil)
-          when String, Symbol
-            TupleExpression.new(eval("lambda{ #{arg} }"), arg)
-          else
-            raise ArgumentError, "Invalid argument `#{arg}` for TupleExpression()"
-          end
-        end
-        alias :[] :coerce
-
-        # Convert commandline arguments to a tuple expression
-        #
-        # Arguments should either be empty or a singleton. In the former case,
-        # `opts[:default]` is used. In the latter case, the unique argument is
-        # taken as the expression source code and `coerce` is called on it.
-        #
-        # @param [Array] args commandline arguments
-        # @param [Hash] opts coercion options.
-        # @return [TupleExpression] the expression if coercion succeeds
-        # @raise [ArgumentError] if the coercion fails.
-        def from_argv(argv, opts = {})
-          raise ArgumentError if argv.size > 1
-          coerce(argv.first || opts[:default])
-        end
-
-      end # class << self
-
-      # Evaluates the expression in the context of a TupleHandle
-      #
-      # @param [TupleHandle] handle a tuple handle instance.
-      # @return [Object] the result of evaluating the expression in the context
-      #         of `handle`
-      def evaluate(handle = nil)
-        if RUBY_VERSION < "1.9"
-          handle.instance_eval(&@expr_lambda)
-        else
-          handle.instance_exec(&@expr_lambda)
-        end
-      end
-
-      # Evaluates the expression on a tuple
-      #
-      # This is a convenient method for the following, longer expression:
-      #
-      #     evaluate(TupleHandle.new.set(tuple))
-      # 
-      # Note, however, using a Handle as in the example above is much more 
-      # efficient when evaluating the same expression on multiple tuples
-      # in sequence.
-      #
-      # @param [Hash] tuple a Tuple instance
-      # @return [Object] the result of evaluating the expression on `tuple`
-      def call(tuple)
-        evaluate(Tools::TupleHandle.new.set(tuple))
-      end
-      alias :[] :call
-
-      # Returns a hash code.
-      #
-      # @return [Integer] a hash code for this expression
-      def hash
-        @source.nil? ? @expr_lambda.hash : @source.hash
-      end
-
-      # Checks equality with another expression
-      #
-      # @param [TupleExpression] another expression.
-      # @return [Boolean] true if self and other are equal, false otherwise
-      def ==(other)
-        return false unless other.is_a?(TupleExpression)
-        if source.nil? || other.source.nil?
-          expr_lambda == other.expr_lambda
-        else
-          source == other.source
-        end
-      end
-      alias :eql? :==
-
-      # Returns a ruby literal for this expression.
-      #
-      # @return [String] a literal s.t. `eval(self.to_ruby_literal) == self`
-      def to_ruby_literal
-        "Alf::#{Tools.class_name(self.class)}[#{Tools.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.
-      #
-      # @return [String] the source code when known
-      def has_source_code!
-        if source.nil?
-          raise NotImplementedError, "No known source code for this expression"
-        else
-          source
-        end
-      end
-
-    end # class TupleExpression
-  end # module Types
-end # module Alf

data/lib/alf/types/tuple_predicate.rb

@@ -1,73 +0,0 @@
-module Alf
-  module Types
-    # 
-    # Specialization of TupleExpression to boolean expressions.
-    #
-    class TuplePredicate < TupleExpression
-
-      class << self
-
-        # Coerces `arg` to a TuplePredicate
-        #
-        # Implemented coercions are:
-        # - TuplePredicate    -> self
-        # - TupleExpression   -> Renewed on this class
-        # - true and false    -> true and false predicates
-        # - Proc              -> TuplePredicate(arg, nil)
-        # - String and Symbol -> as for TupleExpression
-        # - empty Array       -> coerce(true)
-        # - singleton Array   -> coerce(arg.first)
-        # - {"attr" => "value", ...} -> equal predicate with coercions
-        # - {:attr  => ...value..., ...} -> equal predicate without coercions
-        #
-        # @param [Object] arg the value to coerce to a TuplePredicate
-        # @return [TuplePredicate] the predicate if coercion succeeds
-        # @raise [ArgumentError] if coercion fails
-        def coerce(arg)
-          case arg
-          when TuplePredicate
-            arg
-          when TupleExpression
-            TuplePredicate.new arg.expr_lambda, arg.source
-          when TrueClass, FalseClass
-            TuplePredicate.new lambda{ arg }, arg.to_s
-          when Proc
-            TuplePredicate.new arg, nil
-          when String, Symbol
-            TuplePredicate.new eval("lambda{ #{arg} }"), arg
-          when Hash
-            h = Hash[arg.map{|k,v|
-              (AttrName === k) ? 
-                [k,v] : [Tools.coerce(k, AttrName), Kernel.eval(v)]
-            }]
-            source = h.map{|k,v|
-              "(self.#{k} == #{Tools.to_ruby_literal(v)})"
-            }.join(" && ")
-            TuplePredicate.new eval("lambda{ #{source} }"), source
-          when Array
-            (arg.size <= 1) ?
-              coerce(arg.first || true) :
-              coerce(Hash[*arg])
-          else
-            raise ArgumentError, "Invalid argument `#{arg}` for TupleExpression()"
-          end
-        end
-        alias :[] :coerce
-
-        # Convert commandline arguments to a tuple predicate
-        #
-        # This method reuses `coerce(Array)` and therefore shares its spec.
-        #
-        # @param [Array] args commandline arguments
-        # @param [Hash] opts coercion options (not used).
-        # @return [TuplePredicate] the predicate if coercion succeeds
-        # @raise [ArgumentError] if the coercion fails.
-        def from_argv(argv)
-          coerce(argv)
-        end
-
-      end # class << self
-
-    end # class TuplePredicate
-  end # module Types
-end # module Alf

data/spec/integration/__database__/group.alf

@@ -1,3 +0,0 @@
-#!/usr/bin/env alf
-(group :supplies, [:pid, :qty], :supplying)
-(group :supplies, [:sid], :supplying, :allbut => true)

data/spec/integration/__database__/parts.rash

@@ -1,6 +0,0 @@
-{:pid => 'P1', :name => 'Nut',   :color => 'Red',   :weight => 12.0, :city => 'London'}
-{:pid => 'P2', :name => 'Bolt',  :color => 'Green', :weight => 17.0, :city => 'Paris'}
-{:pid => 'P3', :name => 'Screw', :color => 'Blue',  :weight => 17.0, :city => 'Oslo'}
-{:pid => 'P4', :name => 'Screw', :color => 'Red',   :weight => 14.0, :city => 'London'}
-{:pid => 'P5', :name => 'Cam',   :color => 'Blue',  :weight => 12.0, :city => 'Paris'}
-{:pid => 'P6', :name => 'Cog',   :color => 'Red',   :weight => 19.0, :city => 'London'}

data/spec/integration/__database__/suppliers.rash

@@ -1,5 +0,0 @@
-{:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'}
-{:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'}
-{:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
-{:sid => 'S4', :name => 'Clark', :status => 20, :city => 'London'}
-{:sid => 'S5', :name => 'Adams', :status => 30, :city => 'Athens'}

data/spec/integration/__database__/suppliers_csv.csv

@@ -1,6 +0,0 @@
-sid,name,status,city
-S1,Smith,20,London
-S2,Jones,10,Paris
-S3,Blake,30,Paris
-S4,Clark,20,London
-S5,Adams,30,Athens

data/spec/integration/__database__/supplies.rash

@@ -1,12 +0,0 @@
-{:sid => 'S1', :pid => 'P1', :qty => 300}
-{:sid => 'S1', :pid => 'P2', :qty => 200}
-{:sid => 'S1', :pid => 'P3', :qty => 400}
-{:sid => 'S1', :pid => 'P4', :qty => 200}
-{:sid => 'S1', :pid => 'P5', :qty => 100}
-{:sid => 'S1', :pid => 'P6', :qty => 100}
-{:sid => 'S2', :pid => 'P1', :qty => 300}
-{:sid => 'S2', :pid => 'P2', :qty => 400}
-{:sid => 'S3', :pid => 'P2', :qty => 200}
-{:sid => 'S4', :pid => 'P2', :qty => 200}
-{:sid => 'S4', :pid => 'P4', :qty => 300}
-{:sid => 'S4', :pid => 'P5', :qty => 400}

data/spec/integration/alf/example.rash

@@ -1 +0,0 @@
-{:name => "Jones"}

data/spec/integration/alf/test_Relation.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe "Relation" do
-
-    let(:expected){ Alf::Relation.new([ {:name => "Jones"} ].to_set) }
-
-    it 'works as expected on a tuple' do
-      Alf::Relation(:name => "Jones").should eq(expected)
-    end
-
-    it 'works as expected on a Reader' do
-      File.open(File.expand_path("../example.rash", __FILE__), "r") do |io|
-        reader = Alf::Reader.rash(io)
-        rel    = Alf::Relation(reader)
-        rel.should eq(expected)
-      end
-    end
-
-    it 'works as expected on an Operator' do
-      op = Alf.lispy.compile{
-        extend(Relation::DEE, :name => lambda{ "Jones" })
-      }
-      def op.each(*args, &bl)
-        raise if defined?(@already_called)
-        @already_called = true
-        super
-      end
-      Alf::Relation(op).should eq(expected)
-    end
-
-  end
-end

data/spec/integration/ext/test_relation.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-describe "Relation()" do
-
-  it 'returns a Relation' do
-    Relation(:name => "Alf").should be_a(Alf::Relation)
-  end
-
-  it 'helps building a singleton' do
-    Relation(:name => "Alf").cardinality.should eq(1)
-  end
-
-  it 'helps building a list if values' do
-    Relation(:name => ["Alf", "Myrrha"]).cardinality.should eq(2)
-  end
-
-end