alf 0.9.0

data/lib/alf/loader.rb

@@ -0,0 +1 @@
+require "quickl"

data/lib/alf/renderer/text.rb

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,22 @@
+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/lib/alf/version.rb

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

data/spec/aggregator_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+module Alf
+  describe Aggregator do
+
+    let(:input){[
+      {:a => 1, :sign => -1},
+      {:a => 2, :sign => 1 },
+      {:a => 3, :sign => -1},
+      {:a => 1, :sign => -1},
+    ]}
+
+    it "should behave correctly on count" do
+      Aggregator.count(:a).aggregate(input).should == 4
+    end
+
+    it "should behave correctly on sum" do
+      Aggregator.sum(:a).aggregate(input).should == 7
+    end
+
+    it "should behave correctly on avg" do
+      Aggregator.avg(:a).aggregate(input).should == 7.0 / 4.0
+    end
+
+    it "should behave correctly on min" do
+      Aggregator.min(:a).aggregate(input).should == 1
+    end
+
+    it "should behave correctly on max" do
+      Aggregator.max(:a).aggregate(input).should == 3
+    end
+
+    it "should behave correctly on concat" do
+      Aggregator.concat(:a).aggregate(input).should == "1231"
+      Aggregator.concat(:a, :between => " ").aggregate(input).should == "1 2 3 1"
+      Aggregator.concat(:a, :before => "[", :after => "]").aggregate(input).should == "[1231]"
+      Aggregator.concat(:before => "[", :after => "]"){ a }.aggregate(input).should == "[1231]"
+    end
+
+    it "should behave correctly on collect" do
+      Aggregator.collect(:a).aggregate(input).should == [1, 2, 3, 1]
+      Aggregator.collect{ {:a => a, :sign => sign} }.aggregate(input).should == input
+    end
+
+    it "should behave correctly on group" do
+      Aggregator.group(:a).aggregate(input).should == [
+        {:a => 1},
+        {:a => 2},
+        {:a => 3},
+      ]
+      Aggregator.group(:a, :sign).aggregate(input).should == [
+        {:a => 1, :sign => -1},
+        {:a => 2, :sign => 1 },
+        {:a => 3, :sign => -1},
+      ]
+    end
+
+    it "should allow specific tuple computations" do
+      Aggregator.sum{ 1.0 * a * sign }.aggregate(input).should == -3.0
+    end
+
+  end
+end

data/spec/alf_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+describe Alf do
+  
+  let(:lispy){ Alf.lispy(Alf::Environment.examples) } 
+  
+  let(:expected){[
+    {:status => 20, :sid=>"S1", :name=>"Smith", :city=>"London"},
+    {:status => 20, :sid=>"S4", :name=>"Clark", :city=>"London"}
+  ]}
+  
+  it "should have a version number" do
+    Alf.const_defined?(:VERSION).should be_true
+  end
+  
+  it "should allow running a commandline like command" do
+    op = lispy.run(['restrict', 'suppliers', '--', "city == 'London'"])
+    op.to_a.should == expected
+  end
+  
+  it "should allow compiling lispy expressions" do
+    lispy.compile{
+      (restrict :suppliers, lambda{ city == 'London'})
+    }.to_a.should == expected
+  end
+
+  it "should allow defining temporary expressions" do
+    lispy.compile{
+      with(:sup => (dataset :suppliers)) do
+        (restrict :sup, lambda{ city == 'London'})
+      end
+    }.to_a.should == expected
+  end
+  
+  it "should allow reusing temporary expressions" do
+    op = lispy.compile do
+      (restrict :suppliers, lambda{ status > 20 })
+    end
+    projection = lispy.with(:kept_suppliers => op) do
+      (project :kept_suppliers, [:city])
+    end
+    projection.to_a.should == [
+      {:city => 'Paris'},
+      {:city => 'Athens'}
+    ]
+  end
+
+end

data/spec/assumptions_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+describe :instance_eval do
+
+  let(:bar){ lambda{10} }
+  let(:foo) { Object.new }
+
+  if RUBY_VERSION <= "1.9"
+    subject{ foo.instance_eval(&bar) }
+    it { should == 10 }
+  else
+    subject{ foo.instance_exec(&bar) }
+    it { should == 10 }
+  end
+
+end

data/spec/environment/explicit_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module Alf
+  describe Environment::Explicit do
+    
+    it "should allow branching easily" do
+      env = Environment::Explicit.new(:hello => "world")
+      env.dataset(:hello).should == "world"
+      env = env.branch(:hello => "world2")
+      env.dataset(:hello).should == "world2"
+      env = env.unbranch
+      env.dataset(:hello).should == "world"
+    end
+    
+  end
+end

data/spec/environment/folder_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Alf
+  describe Environment::Folder do
+    
+    let(:path){ File.expand_path('../../../examples', __FILE__) }
+    let(:env){ Environment::Folder.new(path) }
+      
+    describe "dataset" do
+      
+      subject{ env.dataset(name) }
+      
+      describe "when called on explicit file" do
+        let(:name){ "suppliers.rash" }
+        it{ should be_a(Reader::Rash) }
+      end
+      
+      describe "when called on existing" do
+        let(:name){ "suppliers" }
+        it{ should be_a(Reader::Rash) }
+      end
+      
+      describe "when called on unexisting" do
+        let(:name){ "notavalidone" }
+        specify{ lambda{ subject }.should raise_error }
+      end
+      
+    end
+    
+  end
+end

data/spec/examples_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Alf
+  describe "Alf's examples" do
+    
+    shared_examples_for "An example" do
+      
+      let(:env){ Environment.examples }
+
+      it "should work when executed with a Alf" do
+        lambda{ 
+          Alf.lispy(env).compile(File.read(subject)).to_a 
+        }.should_not raise_error
+      end
+      
+    end # An example
+    
+    
+    Dir["#{File.expand_path('../../examples', __FILE__)}/**/*.alf"].each do |file|
+      describe file do
+        subject{ file }
+        it_should_behave_like "An example"
+      end
+    end
+    
+  end
+end 

data/spec/lispy_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+module Alf
+  describe Lispy do
+    include Lispy
+
+    let(:input){[
+      {:tested => 1,  :other => "b"},
+      {:tested => 30, :other => "a"},
+    ]}
+
+    let(:expected){[
+      {:tested => 30, :other => "a", :upcase => "A"},
+    ]}
+
+    it "should allow chaining operators 'ala' LISP" do
+      operator = (extend \
+                   (restrict input, lambda{ tested > 10 }),
+                   :upcase => lambda{ other.upcase })
+      operator.to_a.should == expected
+    end
+
+  end
+end

data/spec/operator/command_methods_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  describe Operator::CommandMethods do
+    
+    let(:cmd){ Object.new.extend(Operator::CommandMethods) }
+    
+    describe "split_command_args" do
+    
+      subject{ cmd.send(:split_command_args, args) }
+
+      describe "when applied to both operands and args" do
+        let(:args)    { %w{op1 op2 -- a b c} }
+        let(:expected){ [ %w{op1 op2}, %w{a b c} ] }
+        it { should == expected }
+      end
+      
+      describe "when applied to one operand only" do
+        let(:args)    { %w{op1} }
+        let(:expected){ [ %w{op1}, %w{} ] }
+        it { should == expected }
+      end
+      
+      describe "when applied to two operands only" do
+        let(:args)    { %w{op1 op2} }
+        let(:expected){ [ %w{op1 op2}, %w{} ] }
+        it { should == expected }
+      end
+      
+      describe "when applied to args only" do
+        let(:args)    { %w{-- a b c} }
+        let(:expected){ [ [$stdin], %w{a b c} ] }
+        it { should == expected }
+      end
+      
+    end
+      
+  end
+end