alf 0.9.0 → 0.9.1

data/alf.noespec

@@ -7,19 +7,22 @@ variables:
   upper:
     Alf
   version:
-    0.9.0
+    0.9.1
   summary: |-
-    Classy data-manipulation dressed in a DSL (+ commandline)
+    Relational Algebra at your fingertips
   description: |-
-    Alf is a commandline tool and Ruby library to manipulate data with all the 
-    power of a truly relational algebra approach. 
+    Alf brings the relational algebra both in Shell and in Ruby. In Shell, because 
+    manipulating any relation-like data source should be as straightforward as a 
+    one-liner. In Ruby, because I've never understood why programming languages 
+    provide data structures like arrays, hashes, sets, trees and graphs but not 
+    _relations_... Let's stop the segregation ;-)
   authors: 
     - {name: Bernard Lambeau, email: blambeau@gmail.com}
   links:
     - http://rubydoc.info/github/blambeau/alf/master/frames
     - http://github.com/blambeau/alf
   dependencies: 
-    - {name: rake,         version: "~> 0.8.7",  groups: [development]}
+    - {name: rake,         version: "~> 0.9.2",  groups: [development]}
     - {name: bundler,      version: "~> 1.0",    groups: [development]}
     - {name: rspec,        version: "~> 2.6.0",  groups: [development]}
     - {name: yard,         version: "~> 0.7.2",  groups: [development]}
@@ -27,4 +30,6 @@ variables:
     - {name: wlang,        version: "~> 0.10.1", groups: [development]}
     - {name: noe,          version: "~> 1.3.0",  groups: [development]}
     - {name: quickl,       version: "~> 0.2.1",  groups: [runtime]}
-
+  rake_tasks:
+    spec_test:
+      pattern: "spec/**/test_*.rb"

data/examples/pseudo-with.alf

@@ -0,0 +1,7 @@
+kept_suppliers = (restrict :suppliers, lambda{ status > 10 })
+with_countries = (join kept_suppliers, :cities)
+supplying      = (join with_countries, :supplies)
+(summarize supplying,
+           [:country],
+           :which => Agg::group(:pid),
+           :total => Agg::sum{ qty })

data/examples/runall.sh

@@ -13,8 +13,8 @@ alf --text extend            supplies  -- sp 'sid + "/" + pid' big "qty > 100 ?
 alf --text rename            suppliers -- name supplier_name city supplier_city
 alf --text restrict          suppliers -- "status > 20"
 alf --text restrict          suppliers -- city "'London'"
-alf --text nest              suppliers -- city status loc_and_status
-alf --text unnest            suppliers -- loc_and_status
+alf --text wrap              suppliers -- city status loc_and_status
+alf --text unwrap            suppliers -- loc_and_status
 alf --text group             supplies  -- pid qty supplying
 alf --text group --allbut    supplies  -- sid supplying
 alf --text ungroup           group     -- supplying

data/examples/unwrap.alf

@@ -0,0 +1,4 @@
+#!/usr/bin/env alf 
+(unwrap \
+  (wrap :suppliers, [:city, :status], :loc_and_status), 
+  :loc_and_status)

data/examples/wrap.alf

@@ -0,0 +1,2 @@
+#!/usr/bin/env alf
+(wrap :suppliers, [:city, :status], :loc_and_status)

data/lib/alf/relation.rb

@@ -0,0 +1,118 @@
+module Alf
+  #
+  # Defines an in-memory relation 
+  #
+  class Relation
+    include Iterator
+    
+    protected
+    
+    # @return [Set] the set of tuples
+    attr_reader :tuples
+    
+    public
+    
+    #
+    # Creates a Relation instance.
+    #
+    # @param [Set] tuples a set of tuples
+    #
+    def initialize(tuples)
+      raise ArgumentError unless tuples.is_a?(Set)
+      @tuples = tuples
+    end
+    
+    #
+    # Coerces `val` to a relation
+    #
+    def self.coerce(val)
+      case val
+      when Relation
+        val
+      when Set
+        Relation.new(val)
+      when Array
+        Relation.new val.to_set
+      when Iterator
+        Relation.new val.to_set
+      else
+        raise ArgumentError, "Unable to coerce #{val} to a Relation"
+      end
+    end
+    
+    # (see Relation.coerce)
+    def self.[](*tuples)
+      coerce(tuples)
+    end
+    
+    #
+    # (see Iterator#each)
+    #
+    def each(&block)
+      tuples.each(&block)
+    end
+    
+    #
+    # Returns relation's cardinality (number of tuples)
+    # 
+    def cardinality
+      tuples.size
+    end
+    alias :size :cardinality
+    alias :count :cardinality
+    
+    # 
+    # Install the DSL through iteration over defined operators
+    #
+    Operator::each do |op_class|
+      meth_name = Tools.ruby_case(Tools.class_name(op_class)).to_sym
+      if op_class.unary?
+        define_method(meth_name) do |*args|
+          op = op_class.new(*args).pipe(self)
+          Relation.coerce(op)
+        end
+      elsif op_class.binary?
+        define_method(meth_name) do |right, *args|
+          op = op_class.new(*args).pipe([self, Iterator.coerce(right)])
+          Relation.coerce(op)
+        end
+      else
+        raise "Unexpected operator #{op_class}"
+      end
+    end # Operators::each
+      
+    alias :+ :union
+    alias :- :minus
+        
+    #
+    # (see Object#hash)
+    #
+    def hash
+      @tuples.hash
+    end
+    
+    #
+    # (see Object#==)
+    #
+    def ==(other)
+      return nil unless other.is_a?(Relation)
+      other.tuples == self.tuples
+    end
+    alias :eql? :==
+    
+    #
+    # Returns a textual representation of this relation
+    #
+    def to_s
+      Alf::Renderer.text(self).execute("")
+    end
+    
+    #
+    # Returns a  literal representation of this relation
+    #
+    def inspect
+      "Alf::Relation[" << @tuples.collect{|t| t.inspect}.join(',') << "]"
+    end
+
+  end # class Relation
+end # module Alf

data/lib/alf/version.rb

@@ -3,7 +3,7 @@ module Alf
   
     MAJOR = 0
     MINOR = 9
-    TINY  = 0
+    TINY  = 1
   
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')