alf 0.10.1 → 0.11.0

data/lib/alf/types.rb

@@ -0,0 +1,49 @@
+module Alf
+  #
+  # This module defines a namespace for useful datatypes as well as a few 
+  # typing tools. Defined types are automatically defined as constants on the 
+  # Alf module itself.
+  #
+  module Types
+    require 'alf/types/boolean'
+    require 'alf/types/size'
+    require 'alf/types/attr_name'
+    require 'alf/types/attr_list'
+    require 'alf/types/heading'
+    require 'alf/types/ordering'
+    require 'alf/types/renaming'
+    require 'alf/types/summarization'
+    require 'alf/types/tuple_expression'
+    require 'alf/types/tuple_predicate'
+    require 'alf/types/tuple_computation'
+
+    # Returns the (least) common super type of c1 and c2.
+    #
+    # The least common super type is defined as the lowest ancestor shared 
+    # between c1 and c2.
+    #
+    # Examples:
+    #
+    #     Types.common_super_type(String, String)  # => String
+    #     Types.common_super_type(Integer, Float)  # => Numeric
+    #     Types.common_super_type(Integer, String) # => Object
+    #
+    # @param [Class] c1 a data type, respresented by a ruby class
+    # @param [Class] c2 a data type, respresented by a ruby class
+    # @return [Class] the least common super type of c1 and c2
+    def common_super_type(c1, c2)
+      return c1 if c1 == c2
+      ancestors = [c1, c2].map{|c| 
+        c.ancestors.select{|a| a.is_a?(Class)}
+      }
+      (ancestors[0] & ancestors[1]).first
+    end
+    module_function :common_super_type
+
+    # Install all types on Alf now
+    constants.each do |s|
+      Alf.const_set(s, const_get(s))
+    end
+
+  end # module Types
+end # module Alf

data/lib/alf/version.rb

@@ -1,14 +1,14 @@
 module Alf
   module Version
-  
+
     MAJOR = 0
-    MINOR = 10
-    TINY  = 1
-  
+    MINOR = 11
+    TINY  = 0
+
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')
     end
-  
-  end 
+
+  end
   VERSION = Version.to_s
 end

data/lib/alf-csv/alf/csv/commons.rb

@@ -0,0 +1,36 @@
+module Alf
+  module CSV
+    #
+    # Provides common tooling to CSV renderer and readers
+    #
+    module Commons
+
+      DEFAULT_OPTIONS = {
+        :headers => true
+      }
+
+      private
+
+      # Returns CSV in ruby 1.9 and FasterCSV for ruby < 1.9.
+      # This method handles require as well.
+      def get_csv_class
+        if RUBY_VERSION >= "1.9"
+          require 'csv'
+          ::CSV
+        else
+          ::Alf::Tools::friendly_require('fastercsv')
+          ::FasterCSV
+        end
+      end
+
+      # Returns a CSV instance bound to a given io and options
+      def get_csv(io)
+        csv_class = get_csv_class
+        def_opts = csv_class.const_get(:DEFAULT_OPTIONS)
+        csv_opts = options.delete_if{|k,v| !def_opts.has_key?(k)}
+        csv_class.new(io, csv_opts)
+      end
+
+    end # module Commons
+  end # module CSV
+end # module Alf

data/lib/alf-csv/alf/csv/reader.rb

@@ -0,0 +1,33 @@
+module Alf
+  module CSV
+    #
+    # Implements Alf::Reader contract for reading CSV files.
+    #
+    class Reader < Alf::Reader
+      include CSV::Commons
+
+      def each
+        with_input_io do |io|
+          block = Proc.new{|row|
+            next if row.header_row?
+            yield(symbolize_keys(row.to_hash))
+          }
+          case io
+          when StringIO
+            get_csv_class.parse(io.string, options, &block) 
+          else
+            get_csv(io).each(&block)
+          end
+        end
+      end
+
+      private
+
+      def symbolize_keys(h)
+        Hash[h.collect{|k,v| [k.to_sym,v] }]
+      end
+
+      Alf::Reader.register(:csv, [".csv"], self)
+    end # class Reader
+  end # module CSV
+end # module Alf

data/lib/alf-csv/alf/csv/renderer.rb

@@ -0,0 +1,38 @@
+module Alf
+  module CSV
+    #
+    # Implements Alf::Renderer contract for outputting CSV files. 
+    #
+    class Renderer < Alf::Renderer
+      include CSV::Commons
+
+      protected
+
+      # (see Renderer#render)
+      def render(input, output)
+        csv = get_csv(output)
+        header = nil
+        input.each do |tuple|
+          unless header 
+            header = extract_header(tuple)
+            csv << header.collect{|k| k.to_s}
+          end
+          csv << extract_row(tuple, header)
+        end
+        output
+      end
+
+      private
+
+      def extract_header(tuple)
+        tuple.keys
+      end
+
+      def extract_row(tuple, header)
+        header.collect{|k| tuple[k]}
+      end
+
+      Alf::Renderer.register(:csv, "as a csv file", self)
+    end # class Renderer
+  end # module CSV
+end # module Alf

data/lib/alf-csv/alf/csv.rb

@@ -0,0 +1,3 @@
+require_relative 'csv/commons'
+require_relative 'csv/reader'
+require_relative 'csv/renderer'

data/lib/alf-engine/alf/engine/aggregate.rb

@@ -0,0 +1,44 @@
+module Alf
+  module Engine
+    #
+    # Aggregates the whole operand according to a Summarization. The resulting
+    # iterator contains only one tuple.
+    #
+    # Example:
+    #
+    #   res = [
+    #     {:name => "Jones", :price => 12.0, :id => 1},
+    #     {:name => "Smith", :price => 10.0, :id => 2}
+    #   ]
+    #   agg = Summarization[:size  => "count", 
+    #                       :total => "sum{ price }"]
+    #   Aggregate.new(res, agg).to_a
+    #   # => [
+    #   #      {:size => 2, :total => 22.0}
+    #   #    ]
+    #
+    class Aggregate < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [Summarization] The summarization to use
+      attr_reader :summarization
+
+      # Creates an Aggregate instance
+      def initialize(operand, summarization)
+        @operand = operand
+        @summarization = summarization
+      end
+
+      # (see Cog#each)
+      def each
+        agg = operand.inject(@summarization.least) do |memo,tuple|
+          @summarization.happens(memo, tuple)
+        end
+        yield @summarization.finalize(agg)
+      end
+
+    end # class Aggregate
+  end # Engine
+end # module Alf

data/lib/alf-engine/alf/engine/autonum.rb

@@ -0,0 +1,45 @@
+module Alf
+  module Engine
+    #
+    # Autonumbers input tuples under a new `as` attribute. Autonumbering starts
+    # at 0.
+    #
+    # Example:
+    #
+    #     operand = [
+    #       {:name => "Jones"}, 
+    #       {:name => "Smith"}
+    #     ]
+    #     Autonum.new(operand, :id).to_a
+    #     # => [
+    #     #      {:name => "Jones", :id => 0}, 
+    #     #      {:name => "Smith", :id => 1}
+    #     #    ]
+    #
+    class Autonum < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [Symbol] Name of the autonum attribute
+      attr_reader :as
+
+      # Creates an Autonum instance
+      def initialize(operand, as)
+        @operand = operand
+        @as = as
+      end
+
+      # (see Cog#each)
+      def each
+        autonum = 0
+        @operand.each do |tuple|
+          yield tuple.merge(@as => autonum)
+          autonum += 1
+        end
+      end
+
+    end # class Autonum
+  end # module Engine
+end # module Alf
+

data/lib/{alf/operator → alf-engine/alf/engine}/cesure.rb

@@ -1,27 +1,27 @@
 module Alf
-  module Operator
-    #
-    # Specialization of Operator for implementing operators that rely on a 
-    # cesure algorithm.
-    #
+  module Engine
     module Cesure
-      include Unary
-      
+
+      # (see Cog#each)
+      def each(&receiver)
+        dup._each(&receiver)
+      end
+
       protected
 
-      # (see Operator#_each)
-      def _each
-        receiver, prev_key = Proc.new, nil
-        each_input_tuple do |tuple|
+      # (see Cog#each)
+      def _each(&receiver)
+        prev_key = nil
+        operand.each do |tuple|
           cur_key = project(tuple)
           if cur_key != prev_key
-            flush_cesure(prev_key, receiver) unless prev_key.nil?
+            flush_cesure(prev_key, receiver) if prev_key
             start_cesure(cur_key, receiver)
             prev_key = cur_key
           end
           accumulate_cesure(tuple, receiver)
         end
-        flush_cesure(prev_key, receiver) unless prev_key.nil?
+        flush_cesure(prev_key, receiver) if prev_key
       end
 
       # Projects a given tuple and returns it's cesure projection

data/lib/alf-engine/alf/engine/clip.rb

@@ -0,0 +1,53 @@
+module Alf
+  module Engine
+    #
+    # Clips input tuples keeping (all but) specific attributes only.
+    #
+    # Example:
+    #
+    #     operand = [
+    #       {:name => "Jones", :city => "London"}, 
+    #       {:name => "Smith", :city => "Paris"}
+    #     ]
+    #     
+    #     Clip.new(operand, AttrList[:name], false).to_a
+    #     # => [
+    #     #      {:name => "Jones"}, 
+    #     #      {:name => "Smith"}
+    #     #    ]
+    #
+    #     Clip.new(operand, AttrList[:name], true).to_a
+    #     # => [
+    #     #      {:city => "London"}, 
+    #     #      {:city => "Paris"}
+    #     #    ]
+    #
+    class Clip < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrList] List of attributes for clipping
+      attr_reader :attributes
+
+      # @return [Boolean] Clip *all but* attributes?
+      attr_reader :allbut
+
+      # Creates an Clip instance
+      def initialize(operand, attributes, allbut)
+        @operand = operand
+        @attributes = attributes
+        @allbut = allbut
+      end
+
+      # (see Cog#each)
+      def each
+        @operand.each do |tuple|
+          yield @attributes.project_tuple(tuple, @allbut)
+        end
+      end
+
+    end # class Clip
+  end # module Engine
+end # module Alf
+

data/lib/alf-engine/alf/engine/coerce.rb

@@ -0,0 +1,46 @@
+module Alf
+  module Engine
+    #
+    # Coerce input tuples according to a Heading. Attributes that do not belong
+    # to the heading are simply ignored but are kept in the output.
+    #
+    # Example:
+    #
+    #     operand = [
+    #       {:name => "Jones", :price => "10.0"}, 
+    #       {:name => "Smith", :price => "-12.0"}
+    #     ]
+    #     
+    #     Coerce.new(operand, Heading[:price => Float]).to_a
+    #     # => [
+    #     #      {:name => "Jones", :price => 10.0}, 
+    #     #      {:name => "Smith", :price => -12.0}
+    #     #    ]
+    #
+    class Coerce < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [Heading] Heading for coercion
+      attr_reader :heading
+
+      # Creates an Coerce instance
+      def initialize(operand, heading)
+        @operand = operand
+        @heading = heading
+      end
+
+      # (see Cog#each)
+      def each
+        @operand.each do |tuple|
+          yield tuple.merge(Hash[@heading.map{|k,d|
+            [k, Tools.coerce(tuple[k], d)]
+          }])
+        end
+      end
+
+    end # class Coerce
+  end # module Engine
+end # module Alf
+

data/lib/alf-engine/alf/engine/cog.rb

@@ -0,0 +1,7 @@
+module Alf
+  module Engine
+    class Cog
+      include Enumerable
+    end # module Cog
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/compact/set.rb

@@ -0,0 +1,23 @@
+module Alf
+  module Engine
+    #
+    # Remove duplicate tuples through an in-memory `to_set` heuristics.
+    #
+    class Compact::Set < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # Creates a Compact::Set instance
+      def initialize(operand)
+        @operand = operand
+      end
+
+      # (see Cog#each)
+      def each(&block)
+        operand.to_set.each(&block)
+      end
+
+    end # class Compact::Set
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/compact/uniq.rb

@@ -0,0 +1,23 @@
+module Alf
+  module Engine
+    #
+    # Remove duplicate tuples through an in-memory `to_a.uniq` heuristics.
+    #
+    class Compact::Uniq < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # Creates a Compact::Uniq instance
+      def initialize(operand)
+        @operand = operand
+      end
+
+      # (see Cog#each)
+      def each(&block)
+        operand.to_a.uniq.each(&block)
+      end
+
+    end # class Compact::Uniq
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/compact.rb

@@ -0,0 +1,26 @@
+module Alf
+  module Engine
+    #
+    # Remove duplicate tuples from its operand.
+    #
+    class Compact < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # Creates a Compact instance
+      def initialize(operand)
+        @operand = operand
+      end
+
+      # (see Cog#each)
+      def each(&block)
+        Compact::Uniq.new(operand).each(&block)
+      end
+
+    end # class Compact
+  end # module Engine
+end # module Alf
+require_relative 'compact/uniq'
+require_relative 'compact/set'
+

data/lib/alf-engine/alf/engine/concat.rb

@@ -0,0 +1,25 @@
+module Alf
+  module Engine
+    #
+    # Concat tuples from multiple operands.
+    #
+    class Concat < Cog
+
+      # @return [Array] operands to concatenate
+      attr_reader :operands
+
+      # Creates a Concat instance
+      def initialize(operands)
+        @operands = operands
+      end
+
+      # (see Cog#each)
+      def each(&block)
+        operands.each do |op|
+          op.each(&block)
+        end
+      end
+
+    end # class Concat
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/defaults.rb

@@ -0,0 +1,43 @@
+module Alf
+  module Engine
+    #
+    # Replace missing attributes and nil by default, computed values.
+    #
+    # Example:
+    #
+    #     rel = [
+    #       {:id => 1, :name => "Jones"},
+    #       {:id => 2, :name => nil}
+    #     ]
+    #     Defaults.new(rel, TupleComputation[:name => "Smith"]).to_a
+    #     # => [
+    #     #      {:id => 1, :name => "Jones"},
+    #     #      {:id => 2, :name => "Smith"}
+    #     #    ]
+    #
+    class Defaults < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [TupleComputation] The default values
+      attr_reader :defaults
+
+      # Creates a Defaults instance
+      def initialize(operand, defaults)
+        @operand = operand
+        @defaults = defaults
+      end
+
+      # (see Cog#each)
+      def each
+        handle = Tools::TupleHandle.new
+        operand.each do |tuple|
+          defs = @defaults.evaluate(handle.set(tuple))
+          yield tuple.merge(defs){|k,v1,v2| (v1.nil? ? v2 : v1)}
+        end
+      end
+
+    end # class Defaults
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/filter.rb

@@ -0,0 +1,41 @@
+module Alf
+  module Engine
+    #
+    # Filters operand using a tuple predicate.
+    #
+    # Example
+    #
+    #     rel = [
+    #       {:name => "Smith"},
+    #       {:name => "Jones"}
+    #     ]
+    #     Filter.new(rel, TuplePredicate["name =~ /^J/"]).to_a
+    #     # => [
+    #     #      {:name => "Jones"}
+    #     #    ]
+    #
+    class Filter < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [TuplePredicate] Filtering predicate
+      attr_reader :predicate
+
+      # Creates a Filter instance
+      def initialize(operand, predicate)
+        @operand = operand
+        @predicate = predicate
+      end
+
+      # (see Cog#each)
+      def each
+        handle = Tools::TupleHandle.new
+        operand.each do |tuple|
+          yield(tuple) if @predicate.evaluate(handle.set(tuple))
+        end
+      end
+
+    end # class Filter
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/generator.rb

@@ -0,0 +1,50 @@
+module Alf
+  module Engine
+    #
+    # Generates tuples with an integer attributes, with an initial offset and
+    # a step.
+    #
+    # Example:
+    #
+    #     Generator.new(3, :id, 10, 5).to_a
+    #     # => [
+    #     #      {:id => 10},
+    #     #      {:id => 15},
+    #     #      {:id => 20}
+    #     #    ]
+    #
+    class Generator < Cog
+
+      # @return [Symbol] Name of the autonum attribute
+      attr_reader :as
+
+      # @return [Integer] Initial offset
+      attr_reader :offset
+
+      # @return [Integer] Generation step
+      attr_reader :step
+
+      # @return [Integer] Count number of tuples to generate
+      attr_reader :count
+
+      # Creates an Generator instance
+      def initialize(as, offset, step, count)
+        @as = as
+        @offset = offset
+        @step = step
+        @count = count
+      end
+
+      # (see Cog#each)
+      def each
+        cur = offset
+        count.times do |i|
+          yield(@as => cur)
+          cur += step
+        end
+      end
+
+    end # class Generator
+  end # module Engine
+end # module Alf
+