alf 0.9.2 → 0.9.3

data/examples/runall.sh

@@ -1,26 +0,0 @@
-alf --text autonum           suppliers
-alf --text autonum           suppliers -- unique_id
-alf --text defaults          suppliers -- country "'Belgium'"
-alf --text defaults --strict suppliers -- country "'Belgium'"
-alf --text compact           suppliers
-alf --text sort              suppliers -- name asc
-alf --text sort              suppliers -- city desc name asc
-alf --text clip              suppliers -- name city
-alf --text clip              suppliers --allbut -- name city
-alf --text project           suppliers -- name city
-alf --text project --allbut  suppliers -- name city
-alf --text extend            supplies  -- sp 'sid + "/" + pid' big "qty > 100 ? true : false"
-alf --text rename            suppliers -- name supplier_name city supplier_city
-alf --text restrict          suppliers -- "status > 20"
-alf --text restrict          suppliers -- city "'London'"
-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
-alf --text summarize         supplies  -- --by=sid total_qty "sum(:qty)"
-alf --text quota             supplies  -- --by=sid --order=qty position count sum_qty "sum(:qty)"
-alf --text join              suppliers supplies
-alf --text union             suppliers suppliers
-alf --text intersect         suppliers suppliers
-alf --text minus             suppliers suppliers

data/lib/alf/relation.rb

@@ -1,118 +0,0 @@
-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/renderer/text.rb

@@ -1,153 +0,0 @@
-class Alf::Renderer
-  class Text < Alf::Renderer
-
-    module Utils
-
-      def looks_a_relation?(value)
-        value.is_a?(Alf::Iterator) or
-          (value.is_a?(Array) && !value.empty? && value.all?{|v| v.is_a?(Hash)})
-      end
-
-      def max(x, y)
-        return y if x.nil?
-        return x if y.nil?
-        x > y ? x : y
-      end
-
-    end
-    include Utils
-
-    class Cell
-      include Utils
-
-      def initialize(value)
-        @value = value
-      end
-
-      def min_width
-        @min_width ||= rendering_lines.inject(0) do |maxl,line|
-          max(maxl,line.size)
-        end
-      end
-
-      def rendering_lines(size = nil)
-        if size.nil?
-          text_rendering.split(/\n/)
-        elsif @value.is_a?(Numeric)
-          rendering_lines(nil).collect{|l| "%#{size}s" % l}
-        else
-          rendering_lines(nil).collect{|l| "%-#{size}s" % l}
-        end
-      end
-
-      def text_rendering
-        @text_rendering ||= case (value = @value)
-          when NilClass
-            "[nil]"
-          when Symbol
-            value.inspect
-          when Float
-            "%.7f" % value
-          when Hash
-            value.inspect
-          when Alf::Iterator
-            Text.render(value, "")
-          when Array
-            array_rendering(value)
-          else
-            value.to_s
-        end
-      end
-      
-      def array_rendering(value)
-        if looks_a_relation?(value) 
-          Text.render(value, "")
-        elsif value.empty?
-          "[]"
-        else
-          values = value.collect{|x| Cell.new(x).text_rendering}
-          if values.inject(0){|memo,s| memo + s.size} < 20
-            "[" + values.join(", ") + "]"
-          else
-            "[" + values.join(",\n ") + "]"
-          end 
-        end
-      end
-
-    end # class Cell
-
-    class Row
-      include Utils        
-
-      def initialize(values)
-        @cells = values.collect{|v| Cell.new(v)}
-      end
-
-      def min_widths
-        @cells.collect{|cell| cell.min_width}
-      end
-
-      def rendering_lines(sizes = min_widths)
-        nb_lines = 0
-        by_cell = @cells.zip(sizes).collect do |cell,size|
-          lines = cell.rendering_lines(size)
-          nb_lines = max(nb_lines, lines.size)
-          lines
-        end
-        grid = (0...nb_lines).collect do |line_i|
-          "| " + by_cell.zip(sizes).collect{|cell_lines, size|
-            cell_lines[line_i] || " "*size
-          }.join(" | ") + " |"
-        end
-        grid.empty? ? ["|  |"] : grid
-      end
-
-    end # class Row
-
-    class Table
-      include Utils
-
-      def initialize(records, attributes)
-        @header = Row.new(attributes)
-        @rows = records.collect{|r| Row.new(r)}
-      end
-
-      def render(buffer = "")
-        sizes = @rows.inject(@header.min_widths) do |memo,row|
-          memo.zip(row.min_widths).collect{|x,y| max(x,y)}
-        end
-        sep = '+-' << sizes.collect{|s| '-' * s}.join('-+-') << '-+'
-        buffer << sep << "\n"
-        buffer << @header.rendering_lines(sizes).first << "\n"
-        buffer << sep << "\n"
-        @rows.each do |row|
-          row.rendering_lines(sizes).each do |line|
-            buffer << line << "\n"
-          end
-        end
-        buffer << sep << "\n"
-        buffer
-      end
-
-    end # class Table
-
-    protected
-    
-    def render(input, output)
-      relation = input.to_a
-      attrs = relation.inject([]){|memo,t| 
-        memo | t.keys
-      }
-      records = relation.collect{|t|
-        attrs.collect{|a| t[a]}
-      }
-      Table.new(records, attrs).render(output)
-    end
-    
-    def self.render(input, output)
-      new(input).execute(output)
-    end
-    
-    Alf::Renderer.register(:text, "as a text table",  self)
-  end # class Text
-end # class Alf

data/lib/alf/renderer/yaml.rb

@@ -1,22 +0,0 @@
-require "yaml"
-module Alf
-  module Iterator
-    
-    def to_yaml(*args, &block)
-      to_a.to_yaml(*args, &block)
-    end
-    
-  end
-  class Renderer::YAML < Renderer
-    
-    protected 
-    
-    # (see Alf::Renderer#render)
-    def render(input, output)
-      output << input.to_a.to_yaml << "\n"
-      output
-    end
-
-    Renderer.register(:yaml, "as a yaml output",  self)
-  end # class YAML
-end # module Alf

data/spec/integration/test_alf_specs.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-describe "Alf's integration tests" do
-  
-  module Helpers
-    
-    def rel_equal(x, y)
-      x.to_rel == y.to_rel
-    end
-    
-    def specify(message, x)
-      raise message unless x
-    end
-    
-  end
-  
-  shared_examples_for "An integration file" do
-    
-    let(:lispy){
-      lispy = Alf.lispy(Alf::Environment.examples)
-      lispy.ruby_extend(Helpers)
-    }
-
-    it "should work when executed with a Alf" do
-      lispy.compile(File.read(subject))
-    end
-    
-  end # An example
-  
-  
-  Dir["#{File.expand_path('../src', __FILE__)}/**/*.alf"].each do |file|
-    describe file do
-      subject{ file }
-      it_should_behave_like "An integration file"
-    end
-  end
-  
-end