piglet 0.1.0

data/spec/piglet/field_spec.rb

@@ -0,0 +1,130 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+
+describe Piglet::Field do
+
+  before do
+    @field = Piglet::Field.new('field')
+  end
+  
+  describe '#to_s' do
+    it 'returns a string with the field name (as a string)' do
+      @field.to_s.should eql("field")
+    end
+    
+    it 'returns a string with the field name (as a symbol)' do
+      @field = Piglet::Field.new(:field)
+      @field.to_s.should eql("field")
+    end
+  end
+
+  context 'eval/aggregate functions' do
+    %w(avg count diff max min size sum tokenize).each do |function_name|
+      it "supports \"#{function_name.upcase}\" through ##{function_name}" do
+        @field.send(function_name).to_s.should eql("#{function_name.upcase}(field)")
+      end
+    end
+  
+    it 'supports "IsEmpty" through #empty?' do
+      @field.empty?.to_s.should eql("IsEmpty(field)")
+    end
+  end
+  
+  context 'nested expressions' do
+    it 'handles nested expressions' do
+      @field.max.min.avg.empty?.tokenize.to_s.should eql("TOKENIZE(IsEmpty(AVG(MIN(MAX(field)))))")
+    end
+  end
+  
+  context 'field renaming' do
+    it 'supports renaming a field' do
+      @field.as('x').to_s.should eql('field AS x')
+    end
+    
+    it 'supports renaming a derived field' do
+      @field.x.y.z.as('b').to_s.should eql('field.x.y.z AS b')
+    end
+    
+    it 'supports renaming a calculated field' do
+      @field.max.as('m').to_s.should eql('MAX(field) AS m')
+    end
+  end
+  
+  context 'infix and unary operators' do
+    before do
+      @field1 = Piglet::Field.new('field1')
+      @field2 = Piglet::Field.new('field2')
+    end
+    
+    [:==, :>, :<, :>=, :<=, :%, :+, :-, :*, :/].each do |op|
+      it "supports #{op} on a field" do
+        @field1.send(op, @field2).to_s.should eql("field1 #{op} field2")
+      end
+
+      it "supports #{op} on an expression" do
+        (@field1 + (@field1.send(op, @field2))).to_s.should eql("field1 + (field1 #{op} field2)")
+      end
+    end
+    
+    it 'supports != through #ne on a field' do
+      @field1.ne(@field2).to_s.should eql("field1 != field2")
+    end
+    
+    it 'supports != through #ne on an expression' do
+      (@field1 + (@field1.ne(@field2))).to_s.should eql("field1 + (field1 != field2)")
+    end
+    
+    it 'supports "matches" on a field with a regex' do
+      @field1.matches(/.*\.pig$/).to_s.should eql("field1 matches '.*\\.pig$'")
+    end
+    
+    it 'supports "matches" on a field with a string' do
+      @field1.matches('.*\.pig$').to_s.should eql("field1 matches '.*\\.pig$'")
+    end
+    
+    it 'supports "matches" on an expression' do
+      (@field1 + @field2).matches(/.*\.pig$/).to_s.should eql("(field1 + field2) matches '.*\\.pig$'")
+    end
+    
+    it 'supports "is null" on a field' do
+      @field1.null?.to_s.should eql("field1 is null")
+    end
+    
+    it 'supports "is null" on an expression' do
+      (@field1 + @field2).null?.to_s.should eql("(field1 + field2) is null")
+    end
+    
+    it 'supports "is not null" on a field' do
+      @field1.not_null?.to_s.should eql("field1 is not null")
+    end
+    
+    it 'supports "is not null" on an expression' do
+      (@field1 + @field2).not_null?.to_s.should eql("(field1 + field2) is not null")
+    end
+    
+    it 'supports "NOT" on a field' do
+      @field1.not.to_s.should eql("NOT field1")
+    end
+    
+    it 'supports "NOT" on an expression' do
+      (@field1 == @field2).not.to_s.should eql("NOT (field1 == field2)")
+    end
+    
+    it 'supports unary - through #neg on a field' do
+      @field1.neg.to_s.should eql("-field1")
+    end
+
+    it 'supports unary - through #neg on an expression' do
+      (@field1 + @field2).neg.to_s.should eql("-(field1 + field2)")
+    end
+    
+    it 'supports casts on a field' do
+      @field1.cast(:chararray).to_s.should eql("(chararray) field1")
+    end
+    
+    it 'supports casts on an expression' do
+      (@field1 + @field2).cast(:chararray).to_s.should eql("(chararray) (field1 + field2)")
+    end
+  end
+  
+end

data/spec/piglet/interpreter_spec.rb

@@ -0,0 +1,413 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+
+describe Piglet::Interpreter do
+
+  before do
+    @interpreter = Piglet::Interpreter.new
+  end
+
+  context 'basic usage' do
+    it 'interprets a block given to #new' do
+      output = Piglet::Interpreter.new { store(load('some/path'), 'out') }
+      output.to_pig_latin.should_not be_empty
+    end
+  
+    it 'interprets a block given to #interpret' do
+      output = @interpreter.interpret { store(load('some/path'), 'out') }
+      output.to_pig_latin.should_not be_empty
+    end
+
+    it 'does nothing with no commands' do
+      @interpreter.interpret.to_pig_latin.should be_empty
+    end
+  end
+    
+  context 'load & store operators:' do
+    describe 'LOAD' do
+      it 'outputs a LOAD statement' do
+        @interpreter.interpret { store(load('some/path'), 'out') }
+        @interpreter.to_pig_latin.should include("LOAD 'some/path'")
+      end
+    
+      it 'outputs a LOAD statement without a USING clause if none specified' do
+        @interpreter.interpret { store(load('some/path'), 'out') }
+        @interpreter.to_pig_latin.should_not include('USING')
+      end
+  
+      it 'outputs a LOAD statement with a USING clause with a specified function' do
+        @interpreter.interpret { store(load('some/path', :using => 'XYZ'), 'out') }
+        @interpreter.to_pig_latin.should include("LOAD 'some/path' USING XYZ;")
+      end
+  
+      Piglet::LoadAndStore::LOAD_STORE_FUNCTIONS.each do |symbolic_name, function|
+        it "knows that the load method :#{symbolic_name} means #{function}" do
+          @interpreter.interpret { store(load('some/path', :using => symbolic_name), 'out') }
+          @interpreter.to_pig_latin.should include("LOAD 'some/path' USING #{function};")
+        end
+      end
+  
+      it 'outputs a LOAD statement with an AS clause' do
+        @interpreter.interpret { store(load('some/path', :schema => %w(a b c)), 'out') }
+        @interpreter.to_pig_latin.should include("LOAD 'some/path' AS (a, b, c);")
+      end
+  
+      it 'outputs a LOAD statement with an AS clause with types' do
+        @interpreter.interpret { store(load('some/path', :schema => [:a, [:b, :chararray], :c]), 'out') }
+        @interpreter.to_pig_latin.should include("LOAD 'some/path' AS (a, b:chararray, c);")
+      end
+  
+      it 'outputs a LOAD statement with an AS clause with types specified as both strings and symbols' do
+        @interpreter.interpret { store(load('some/path', :schema => [:a, %w(b chararray), :c]), 'out') }
+        @interpreter.to_pig_latin.should include("LOAD 'some/path' AS (a, b:chararray, c);")
+      end
+    end
+
+    describe 'STORE' do
+      it 'outputs a STORE statement' do
+        @interpreter.interpret { store(load('some/path'), 'out') }
+        @interpreter.to_pig_latin.should match(/STORE \w+ INTO 'out'/)
+      end
+    
+      it 'outputs a STORE statement without a USING clause if none specified' do
+        @interpreter.interpret { store(load('some/path'), 'out') }
+        @interpreter.to_pig_latin.should_not include("USING")
+      end
+    
+      it 'outputs a STORE statement with a USING clause with a specified function' do
+        @interpreter.interpret { store(load('some/path'), 'out', :using => 'XYZ') }
+        @interpreter.to_pig_latin.should match(/STORE \w+ INTO 'out' USING XYZ/)
+      end
+  
+      it 'knows that the load method :pig_storage means PigStorage' do
+        @interpreter.interpret { store(load('some/path'), 'out', :using => :pig_storage) }
+        @interpreter.to_pig_latin.should match(/STORE \w+ INTO 'out' USING PigStorage/)
+      end
+    end
+
+    describe 'DUMP' do
+      it 'outputs a DUMP statement' do
+        @interpreter.interpret { dump(load('some/path')) }
+        @interpreter.to_pig_latin.should match(/DUMP \w+/)
+      end
+    end
+  end
+  
+  context 'diagnostic operators:' do
+    describe 'ILLUSTRATE' do
+      it 'outputs an ILLUSTRATE statement' do
+        @interpreter.interpret { illustrate(load('some/path')) }
+        @interpreter.to_pig_latin.should match(/ILLUSTRATE \w+/)
+      end
+    end
+  
+    describe 'DESCRIBE' do
+      it 'outputs a DESCRIBE statement' do
+        @interpreter.interpret { describe(load('some/path')) }
+        @interpreter.to_pig_latin.should match(/DESCRIBE \w+/)
+      end
+    end
+  
+    describe 'EXPLAIN' do
+      it 'outputs an EXPLAIN statement' do
+        @interpreter.interpret { explain(load('some/path')) }
+        @interpreter.to_pig_latin.should match(/EXPLAIN \w+/)
+      end
+    
+      it 'outputs an EXPLAIN statement without an alias' do
+        @interpreter.interpret { explain }
+        @interpreter.to_pig_latin.should match(/EXPLAIN;/)
+      end
+    end
+  end
+  
+  context 'relation operators:' do
+    describe 'GROUP' do
+      it 'outputs a GROUP statement with one grouping field' do
+        @interpreter.interpret { store(load('in').group(:a), 'out') }
+        @interpreter.to_pig_latin.should match(/GROUP \w+ BY a/)
+      end
+    
+      it 'outputs a GROUP statement with more than one grouping field' do
+        @interpreter.interpret { store(load('in').group(:a, :b, :c), 'out') }
+        @interpreter.to_pig_latin.should match(/GROUP \w+ BY \(a, b, c\)/)
+      end
+    
+      it 'outputs a GROUP statement with a PARALLEL clause' do
+        @interpreter.interpret { store(load('in').group([:a, :b, :c], :parallel => 3), 'out') }
+        @interpreter.to_pig_latin.should match(/GROUP \w+ BY \(a, b, c\) PARALLEL 3/)
+      end
+    end
+    
+    describe 'DISTINCT' do
+      it 'outputs a DISTINCT statement' do
+        @interpreter.interpret { store(load('in').distinct, 'out') }
+        @interpreter.to_pig_latin.should match(/DISTINCT \w+/)
+      end
+    
+      it 'outputs a DISTINCT statement with a PARALLEL clause' do
+        @interpreter.interpret { store(load('in').distinct(:parallel => 4), 'out') }
+        @interpreter.to_pig_latin.should match(/DISTINCT \w+ PARALLEL 4/)
+      end
+    end
+
+    describe 'CROSS' do
+      it 'outputs a CROSS statement with two relations' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = a.cross(b)
+          dump(c)
+        end
+        @interpreter.to_pig_latin.should match(/CROSS \w+, \w+/)
+      end
+      
+      it 'outputs a CROSS statement with many relations' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = load('in3')
+          d = load('in4')
+          e = a.cross(b, c, d)
+          dump(e)
+        end
+        @interpreter.to_pig_latin.should match(/CROSS \w+, \w+, \w+, \w+/)
+      end
+      
+      it 'outputs a CROSS statement with a PARALLEL clause' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = load('in3')
+          d = a.cross([b, c], :parallel => 4)
+          dump(d)
+        end
+        @interpreter.to_pig_latin.should match(/CROSS \w+, \w+, \w+ PARALLEL 4/)
+      end
+    end
+
+    describe 'UNION' do
+      it 'outputs a UNION statement with two relations' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = a.union(b)
+          dump(c)
+        end
+        @interpreter.to_pig_latin.should match(/UNION \w+, \w+/)
+      end
+      
+      it 'outputs a UNION statement with many relations' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = load('in3')
+          d = load('in4')
+          e = a.union(b, c, d)
+          dump(e)
+        end
+        @interpreter.to_pig_latin.should match(/UNION \w+, \w+, \w+, \w+/)
+      end
+    end
+    
+    describe 'SAMPLE' do
+      it 'outputs a SAMPLE statement' do
+        @interpreter.interpret { dump(load('in').sample(10)) }
+        @interpreter.to_pig_latin.should match(/SAMPLE \w+ 10/)
+      end
+    end
+
+    describe 'LIMIT' do
+      it 'outputs a LIMIT statement' do
+        @interpreter.interpret { dump(load('in').limit(42)) }
+        @interpreter.to_pig_latin.should match(/LIMIT \w+ 42/)
+      end
+    end
+
+    describe 'FOREACH … GENERATE' do
+      it 'outputs a FOREACH … GENERATE statement' do
+        @interpreter.interpret { dump(load('in').foreach { |r| :a }) }
+        @interpreter.to_pig_latin.should match(/FOREACH \w+ GENERATE a/)
+      end
+      
+      it 'outputs a FOREACH … GENERATE statement with a list of fields' do
+        @interpreter.interpret { dump(load('in').foreach { |r| [:a, :b, :c] }) }
+        @interpreter.to_pig_latin.should match(/FOREACH \w+ GENERATE a, b, c/)
+      end
+      
+      it 'outputs a FOREACH … GENERATE statement with fields resolved from the relation' do
+        @interpreter.interpret { dump(load('in').foreach { |r| [r.a, r.b, r.c] }) }
+        @interpreter.to_pig_latin.should match(/FOREACH (\w+) GENERATE a, b, c/)
+      end
+      
+      it 'outputs a FOREACH … GENERATE statement with fields resolved from the relation with positional syntax' do
+        @interpreter.interpret { dump(load('in').foreach { |r| [r[0], r[1], r[2]] }) }
+        @interpreter.to_pig_latin.should match(/FOREACH (\w+) GENERATE \$0, \$1, \$2/)
+      end
+      
+      it 'outputs a FOREACH … GENERATE statement with aggregate functions applied to the fields' do
+        @interpreter.interpret { dump(load('in').foreach { |r| [r.a.max, r.b.min, r.c.avg] }) }
+        @interpreter.to_pig_latin.should match(/FOREACH (\w+) GENERATE MAX\(a\), MIN\(b\), AVG\(c\)/)
+      end
+      
+      it 'outputs a FOREACH … GENERATE statement with fields that access inner fields' do
+        @interpreter.interpret { dump(load('in').foreach { |r| [r.a.b, r.b.c, r.c.d] }) }
+        @interpreter.to_pig_latin.should match(/FOREACH (\w+) GENERATE a.b, b.c, c.d/)
+      end
+      
+      it 'outputs a FOREACH … GENERATE statement that includes field aliasing' do
+        @interpreter.interpret { dump(load('in').foreach { |r| [r.a.b.as(:c), r.a.b.as(:d)] }) }
+        @interpreter.to_pig_latin.should match(/FOREACH (\w+) GENERATE a.b AS c, a.b AS d/)
+      end
+    end
+
+    describe 'FILTER' do
+      it 'outputs a FILTER statement' do
+        @interpreter.interpret { dump(load('in').filter { |r| r.a == 3 }) }
+        @interpreter.to_pig_latin.should match(/FILTER \w+ BY a == 3/)
+      end
+
+      # it 'outputs a FILTER statement with a complex test' do
+      #   @interpreter.interpret { dump(load('in').filter { |r| r.a > r.b && r.c != 3 }) }
+      #   @interpreter.to_pig_latin.should match(/FILTER \w+ BY a > b AND c != 3/)
+      # end
+    end
+    
+    describe 'SPLIT' do
+      it 'outputs a SPLIT statement' do
+        @interpreter.interpret do
+          a, b = load('in').split { |r| [r.a >= 0, r.a < 0]}
+          dump(a)
+          dump(b)
+        end
+        @interpreter.to_pig_latin.should match(/SPLIT \w+ INTO \w+ IF a >= 0, \w+ IF a < 0/)
+      end
+    end
+    
+    describe 'ORDER' do
+      it 'outputs an ORDER statement' do
+        @interpreter.interpret { dump(load('in').order(:a)) }
+        @interpreter.to_pig_latin.should match(/ORDER \w+ BY a/)
+      end
+      
+      it 'outputs an ORDER statement with multiple fields' do
+        @interpreter.interpret { dump(load('in').order(:a, :b)) }
+        @interpreter.to_pig_latin.should match(/ORDER \w+ BY a, b/)
+      end
+      
+      it 'outputs an ORDER statement with ASC and DESC' do
+        @interpreter.interpret { dump(load('in').order([:a, :asc], [:b, :desc])) }
+        @interpreter.to_pig_latin.should match(/ORDER \w+ BY a ASC, b DESC/)
+      end
+    end
+    
+    describe 'JOIN' do
+      it 'outputs a JOIN statement' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = a.join(a => :x, b => :y)
+          dump(c)
+        end
+        @interpreter.to_pig_latin.should match(/JOIN \w+ BY \w+, \w+ BY \w+/)
+      end
+
+      it 'outputs a JOIN statement with a PARALLEL clause' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = a.join(a => :x, b => :y, :parallel => 5)
+          dump(c)
+        end
+        @interpreter.to_pig_latin.should match(/JOIN \w+ BY \w+, \w+ BY \w+ PARALLEL 5/)
+      end
+
+      it 'outputs a JOIN statement with a USING clause' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = a.join(a => :x, b => :y, :using => :replicated)
+          dump(c)
+        end
+        @interpreter.to_pig_latin.should match(/JOIN \w+ BY \w+, \w+ BY \w+ USING "replicated"/)
+      end
+    end
+    
+    describe 'COGROUP' do
+      it 'outputs a COGROUP statement' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = a.cogroup(a => :x, b => :y)
+          dump(c)
+        end
+        @interpreter.to_pig_latin.should match(/COGROUP \w+ BY \w+, \w+ BY \w+/)
+      end
+      
+      it 'outputs a COGROUP statement with multiple join fields' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = a.cogroup(a => :x, b => [:y, :z, :w])
+          dump(c)
+        end
+        @interpreter.to_pig_latin.should match(/\w+ BY \(y, z, w\)/)
+      end
+
+      it 'outputs a COGROUP statement with a PARALLEL clause' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = a.cogroup(a => :x, b => :y, :parallel => 5)
+          dump(c)
+        end
+        @interpreter.to_pig_latin.should match(/COGROUP \w+ BY \w+, \w+ BY \w+ PARALLEL 5/)
+      end
+      
+      it 'outputs a COGROUP statement with INNER and OUTER' do
+        @interpreter.interpret do
+          a = load('in1')
+          b = load('in2')
+          c = a.cogroup(a => [:x, :inner], b => [:y, :outer])
+          dump(c)
+        end
+        @interpreter.to_pig_latin.should match(/\w+ BY x INNER/)
+        @interpreter.to_pig_latin.should match(/\w+ BY y OUTER/)
+      end
+    end
+  end
+
+  context 'aliasing & multiple statements' do
+    it 'aliases the loaded relation and uses the same alias in the STORE statement' do
+      @interpreter.interpret { store(load('in'), 'out') }
+      @interpreter.to_pig_latin.should match(/(\w+) = LOAD 'in';\nSTORE \1 INTO 'out';/)
+    end
+    
+    it 'aliases both a loaded relation and a grouped relation and uses the latter in the STORE statement' do
+      @interpreter.interpret { store(load('in', :schema => [:a]).group(:a), 'out') }
+      @interpreter.to_pig_latin.should match(/(\w+) = LOAD 'in' AS \(a\);\n(\w+) = GROUP \1 BY a;\nSTORE \2 INTO 'out';/)
+    end
+    
+    it 'aliases a whole row of statements' do
+      @interpreter.interpret do
+        a = load('in', :schema => [:a])
+        b = a.group(:a)
+        c = b.group(:a)
+        d = c.group(:a)
+        store(d, 'out')
+      end
+      @interpreter.to_pig_latin.should match(/(\w+) = LOAD 'in' AS \(a\);\n(\w+) = GROUP \1 BY a;\n(\w+) = GROUP \2 BY a;\n(\w+) = GROUP \3 BY a;\nSTORE \4 INTO 'out';/)
+    end
+    
+    it 'outputs the statements for an alias only once, regardless of home many times it is stored' do
+      @interpreter.interpret do
+        a = load('in')
+        b = a.distinct
+        store(b, 'out1')
+        store(b, 'out2')
+      end
+      @interpreter.to_pig_latin.should match(/(\w+) = LOAD 'in';\n(\w+) = DISTINCT \1;\nSTORE \2 INTO 'out1';\nSTORE \2 INTO 'out2';/)
+    end
+  end
+
+end

data/spec/piglet/relation_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+
+describe Piglet::Relation do
+  
+  before do
+    @relation = Object.new
+    @relation.extend Piglet::Relation
+  end
+  
+  it 'has a alias' do
+    @relation.alias.should_not be_nil
+  end
+  
+  it 'has a unique alias' do
+    aliases = { }
+    1000.times do
+      @relation = Object.new
+      @relation.extend Piglet::Relation
+      aliases.should_not have_key(@relation.alias)
+      aliases[@relation.alias] = @relation
+    end
+  end
+  
+  describe '#group' do
+    it 'returns a new relation with the target relation as source' do
+      @relation.group(:a).sources.should include(@relation)
+    end
+  end
+  
+  describe '#distinct' do
+    it 'returns a new relation with the target relation as source' do
+      @relation.distinct.sources.should include(@relation)
+    end
+  end
+  
+  describe '#cross' do
+    it 'returns a new relation with the target relation as one of the sources' do
+      other = Object.new
+      other.extend Piglet::Relation
+      @relation.cross(other).sources.should include(@relation)
+    end
+  end
+  
+  describe '#union' do
+    it 'returns a new relation with the target relation as one of the sources' do
+      other = Object.new
+      other.extend Piglet::Relation
+      @relation.union(other).sources.should include(@relation)
+    end
+  end
+  
+  describe '#sample' do
+    it 'returns a new relation with the target relation as source' do
+      @relation.sample(10).sources.should include(@relation)
+    end
+  end
+
+  describe '#limit' do
+    it 'returns a new relation with the target relation as source' do
+      @relation.limit(42).sources.should include(@relation)
+    end
+  end
+  
+  context 'fields' do
+    it 'returns a field for a message that does not correspond to a method' do
+      @relation.a.should_not be_nil
+    end
+    
+    it 'returns fields that have the correct name' do
+      @relation.a.to_s.should eql('a')
+    end
+    
+    it 'returns fields with positional notation' do
+      @relation[1].to_s.should eql('$1')
+    end
+  end
+  
+end

data/spec/piglet/split_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+
+describe Piglet::Split do
+
+  before do
+    @relation = mock('source')
+    @expr1 = mock('expr1')
+    @expr2 = mock('expr2')
+    @relation.stub!(:alias).and_return('rel')
+    @expr1.stub!(:to_s).and_return('y')
+    @expr2.stub!(:to_s).and_return('w')
+    @split = Piglet::Split.new(@relation, [@expr1, @expr2])
+  end
+
+  describe '#to_s' do
+    it 'outputs all x IF y expressions' do
+      @split.to_s.should match(/SPLIT rel INTO \w+ IF [yw], \w+ IF [yw]/)
+    end
+    
+    it 'contains the names of all the shard relations' do
+      @shards = @split.shards
+      @split.to_s.should include("#{@shards[0].alias} IF y")
+      @split.to_s.should include("#{@shards[1].alias} IF w")
+    end
+  end
+  
+  describe '#shards' do
+    it 'returns the same number of shards as there are expressions' do
+      @split.shards.size.should == 2
+    end
+  end
+
+end

data/spec/piglet_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+
+describe Piglet do
+
+
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--format specdoc
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+
+require 'piglet'
+require 'spec'
+require 'spec/autorun'
+
+
+require 'piglet/interpreter'
+
+Spec::Runner.configure do |config|
+  
+end