piglet 0.2.5 → 0.3.0

data/lib/piglet/relation/order.rb

@@ -5,14 +5,16 @@ module Piglet
     class Order # :nodoc:
       include Relation
     
-      def initialize(relation, fields, options)
+      def initialize(relation, interpreter, fields, options)
         options ||= {}
+        @interpreter = interpreter
         @sources, @parallel = [relation], options[:parallel]
         @fields = fields.is_a?(Enumerable) ? fields : [fields]
       end
     
       def to_s
-        "ORDER #{@sources.first.alias} BY #{field_strings}"
+        target = @sources.first.respond_to?(:field_alias) ? @sources.first.field_alias : @sources.first.alias
+        "ORDER #{target} BY #{field_strings}"
       end
     
     private

data/lib/piglet/relation/relation.rb

@@ -8,7 +8,13 @@ module Piglet
       # The name this relation will get in Pig Latin. Then name is generated when
       # the relation is outputed by the interpreter, and will be unique.
       def alias
-        @alias ||= Relation.next_alias
+        @alias ||= @interpreter.next_relation_alias
+      end
+      
+      def next_field_alias
+        @field_counter ||= 0
+        @field_counter += 1
+        "#{self.alias}_field_#{@field_counter}"
       end
   
       # GROUP
@@ -18,7 +24,7 @@ module Piglet
       #   x.group([:a, :b, :c], :parallel => 3) # => GROUP x BY (a, b, c) PARALLEL 3
       def group(*args)
         grouping, options = split_at_options(args)
-        Group.new(self, [grouping].flatten, options)
+        Group.new(self, @interpreter, [grouping].flatten, options)
       end
   
       # DISTINCT
@@ -26,7 +32,7 @@ module Piglet
       #   x.distinct                 # => DISTINCT x
       #   x.distinct(:parallel => 5) # => DISTINCT x PARALLEL 5
       def distinct(options={})
-        Distinct.new(self, options)
+        Distinct.new(self, @interpreter, options)
       end
 
       # COGROUP
@@ -37,7 +43,7 @@ module Piglet
       #   x.cogroup(x => :a, y => [:b, :inner])       # => COGROUP x BY a, y BY b INNER
       #   x.cogroup(x => :a, y => :b, :parallel => 5) # => COGROUP x BY a, y BY b PARALLEL 5
       def cogroup(description)
-        Cogroup.new(self, description)
+        Cogroup.new(self, @interpreter, description)
       end
   
       # CROSS
@@ -47,29 +53,39 @@ module Piglet
       #   x.cross([y, z], :parallel => 5) # => CROSS x, y, z, w PARALLEL 5
       def cross(*args)
         relations, options = split_at_options(args)
-        Cross.new(([self] + relations).flatten, options)
+        Cross.new(([self] + relations).flatten, @interpreter, options)
       end
   
       # FILTER
       #
-      #   x.filter { |r| r.a == r.b }            # => FILTER x BY a == b
-      #   x.filter { |r| r.a > r.b && r.c != 3 } # => FILTER x BY a > b AND c != 3
-      def filter
-        Filter.new(self, yield(self))
+      #   x.filter { a == b }          # => FILTER x BY a == b
+      #   x.filter { a > b && c == 3 } # => FILTER x BY a > b AND c == 3
+      def filter(&block)
+        context = BlockContext.new(self, @interpreter)
+        Filter.new(self, @interpreter, context.instance_eval(&block))
       end
   
       # FOREACH ... GENERATE
       #
-      #   x.foreach { |r| r.a }            # => FOREACH x GENERATE a
-      #   x.foreach { |r| [r.a, r.b] }     # => FOREACH x GENERATE a, b
-      #   x.foreach { |r| r.a.max }        # => FOREACH x GENERATE MAX(a)
-      #   x.foreach { |r| r.a.avg.as(:b) } # => FOREACH x GENERATE AVG(a) AS b
+      #   x.foreach { a }            # => FOREACH x GENERATE a
+      #   x.foreach { [a, b] }       # => FOREACH x GENERATE a, b
+      #   x.foreach { a.max }        # => FOREACH x GENERATE MAX(a)
+      #   x.foreach { a.avg.as(:b) } # => FOREACH x GENERATE AVG(a) AS b
       #
-      #--
+      # See #nested_foreach for FOREACH ... { ... GENERATE }
+      def foreach(&block)
+        context = BlockContext.new(self, @interpreter)
+        Foreach.new(self, @interpreter, context.instance_eval(&block))
+      end
+      
+      # FOREACH ... { ... GENERATE }
+      #
+      #   x.nested_foreach { [a.distinct] } # => FOREACH x { a1 = DISTINCT a; GENERATE a1 }
       #
-      # TODO: FOREACH a { b GENERATE c }
-      def foreach
-        Foreach.new(self, yield(self))
+      # See #foreach for FOREACH ... GENERATE
+      def nested_foreach(&block)
+        context = BlockContext.new(self, @interpreter)
+        NestedForeach.new(self, @interpreter, context.instance_eval(&block))
       end
   
       # JOIN
@@ -79,14 +95,14 @@ module Piglet
       #   x.join(x => :a, y => :b, :using => :replicated) # => JOIN x BY a, y BY b USING "replicated"
       #   x.join(x => :a, y => :b, :parallel => 5)        # => JOIN x BY a, y BY b PARALLEL 5
       def join(description)
-        Join.new(self, description)
+        Join.new(self, @interpreter, description)
       end
   
       # LIMIT
       #
       #   x.limit(10) # => LIMIT x 10
       def limit(n)
-        Limit.new(self, n)
+        Limit.new(self, @interpreter, n)
       end
   
       # ORDER
@@ -103,21 +119,22 @@ module Piglet
       def order(*args)
         fields, options = split_at_options(args)
         fields = *fields
-        Order.new(self, fields, options)
+        Order.new(self, @interpreter, fields, options)
       end
   
       # SAMPLE
       #
       #   x.sample(5) # => SAMPLE x 5;
       def sample(n)
-        Sample.new(self, n)
+        Sample.new(self, @interpreter, n)
       end
     
       # SPLIT
       #
-      #   y, z = x.split { |r| [r.a <= 3, r.b > 4]} # => SPLIT x INTO y IF a <= 3, z IF a > 4
-      def split
-        Split.new(self, yield(self)).shards
+      #   y, z = x.split { [a <= 3, b > 4] } # => SPLIT x INTO y IF a <= 3, z IF a > 4
+      def split(&block)
+        context = BlockContext.new(self, @interpreter)
+        Split.new(self, @interpreter, context.instance_eval(&block)).shards
       end
   
       # STREAM
@@ -128,7 +145,7 @@ module Piglet
       #   x.stream(:cmd, :schema => [%w(a int)]) # => STREAM x THROUGH cmd AS (a:int)
       def stream(*args)
         fields, options = split_at_options(args)
-        Stream.new(self, fields, options)
+        Stream.new(self, @interpreter, fields, options)
       end
   
       # UNION
@@ -136,7 +153,7 @@ module Piglet
       #   x.union(y)    # => UNION x, y
       #   x.union(y, z) # => UNION x, y, z
       def union(*relations)
-        Union.new(*([self] + relations))
+        Union.new(([self] + relations).flatten, @interpreter)
       end
 
       def field(name)
@@ -183,12 +200,6 @@ module Piglet
           [parameters, nil]
         end
       end
-
-      def self.next_alias
-        @counter ||= 0
-        @counter += 1
-        "relation_#{@counter}"
-      end
     end
   end
 end

data/lib/piglet/relation/sample.rb

@@ -5,8 +5,8 @@ module Piglet
     class Sample # :nodoc:
       include Relation
     
-      def initialize(relation, n)
-        @sources, @n = [relation], n
+      def initialize(relation, interpreter, n)
+        @sources, @interpreter, @n = [relation], interpreter, n
       end
     
       def to_s

data/lib/piglet/relation/split.rb

@@ -5,8 +5,8 @@ module Piglet
     class Split # :nodoc:
       include Relation
     
-      def initialize(relation, expressions)
-        @sources, @expressions = [relation], expressions
+      def initialize(relation, interpreter, expressions)
+        @sources, @interpreter, @expressions = [relation], interpreter, expressions
         @shard_map = create_shards
       end
     
@@ -26,7 +26,7 @@ module Piglet
   
       def create_shards
         @expressions.inject({}) do |map, expr|
-          map[expr] = RelationShard.new(self)
+          map[expr] = RelationShard.new(self, @interpreter)
           map
         end
       end
@@ -35,8 +35,8 @@ module Piglet
     class RelationShard # :nodoc:
       include Relation
     
-      def initialize(split)
-        @sources = [split]
+      def initialize(split, interpreter)
+        @sources, @interpreter = [split], interpreter
       end
     
       def to_s

data/lib/piglet/relation/stream.rb

@@ -5,7 +5,8 @@ module Piglet
     class Stream # :nodoc:
       include Relation
       
-      def initialize(source, args, options=nil)
+      def initialize(source, interpreter, args, options=nil)
+        @interpreter = interpreter
         options ||= {}
         @sources = [source]
         args.each do |arg|

data/lib/piglet/relation/union.rb

@@ -5,8 +5,8 @@ module Piglet
     class Union # :nodoc:
       include Relation
     
-      def initialize(*relations)
-        @sources = [relations].flatten
+      def initialize(relations, interpreter)
+        @sources, @interpreter = relations, interpreter
       end
     
       def to_s

data/piglet.gemspec

@@ -0,0 +1,126 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{piglet}
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Theo Hultberg"]
+  s.date = %q{2010-07-09}
+  s.default_executable = %q{piglet}
+  s.description = %q{Piglet aims to look like Pig Latin while allowing for things like loops and control of flow that are missing from Pig.}
+  s.email = %q{theo@iconara.net}
+  s.executables = ["piglet"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "Gemfile",
+     "Gemfile.lock",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "bin/piglet",
+     "lib/piglet.rb",
+     "lib/piglet/field/binary_conditional.rb",
+     "lib/piglet/field/call_expression.rb",
+     "lib/piglet/field/direct_expression.rb",
+     "lib/piglet/field/field.rb",
+     "lib/piglet/field/infix_expression.rb",
+     "lib/piglet/field/literal.rb",
+     "lib/piglet/field/map_value.rb",
+     "lib/piglet/field/prefix_expression.rb",
+     "lib/piglet/field/reference.rb",
+     "lib/piglet/field/rename.rb",
+     "lib/piglet/field/suffix_expression.rb",
+     "lib/piglet/field/udf_expression.rb",
+     "lib/piglet/inout/describe.rb",
+     "lib/piglet/inout/dump.rb",
+     "lib/piglet/inout/explain.rb",
+     "lib/piglet/inout/illustrate.rb",
+     "lib/piglet/inout/load.rb",
+     "lib/piglet/inout/output.rb",
+     "lib/piglet/inout/storage_types.rb",
+     "lib/piglet/inout/store.rb",
+     "lib/piglet/interpreter.rb",
+     "lib/piglet/param/declare.rb",
+     "lib/piglet/param/default.rb",
+     "lib/piglet/param/parameter_statement.rb",
+     "lib/piglet/relation/block_context.rb",
+     "lib/piglet/relation/cogroup.rb",
+     "lib/piglet/relation/cross.rb",
+     "lib/piglet/relation/distinct.rb",
+     "lib/piglet/relation/filter.rb",
+     "lib/piglet/relation/foreach.rb",
+     "lib/piglet/relation/group.rb",
+     "lib/piglet/relation/join.rb",
+     "lib/piglet/relation/limit.rb",
+     "lib/piglet/relation/nested_foreach.rb",
+     "lib/piglet/relation/order.rb",
+     "lib/piglet/relation/relation.rb",
+     "lib/piglet/relation/sample.rb",
+     "lib/piglet/relation/split.rb",
+     "lib/piglet/relation/stream.rb",
+     "lib/piglet/relation/union.rb",
+     "lib/piglet/schema/bag.rb",
+     "lib/piglet/schema/tuple.rb",
+     "lib/piglet/udf/define.rb",
+     "lib/piglet/udf/register.rb",
+     "piglet.gemspec",
+     "spec/piglet/field/binary_conditional_spec.rb",
+     "spec/piglet/field/field_spec.rb",
+     "spec/piglet/field/infix_expression_spec.rb",
+     "spec/piglet/field/literal_spec.rb",
+     "spec/piglet/field/reference_spec.rb",
+     "spec/piglet/interpreter_spec.rb",
+     "spec/piglet/relation/relation_spec.rb",
+     "spec/piglet/relation/split_spec.rb",
+     "spec/piglet/relation/union_spec.rb",
+     "spec/piglet/schema/tuple_spec.rb",
+     "spec/piglet_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "tasks/gem.rake",
+     "tasks/rdoc.rake",
+     "tasks/spec.rake"
+  ]
+  s.homepage = %q{http://github.com/iconara/piglet}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Piglet is a DSL for Pig scripts}
+  s.test_files = [
+    "spec/piglet/field/binary_conditional_spec.rb",
+     "spec/piglet/field/field_spec.rb",
+     "spec/piglet/field/infix_expression_spec.rb",
+     "spec/piglet/field/literal_spec.rb",
+     "spec/piglet/field/reference_spec.rb",
+     "spec/piglet/interpreter_spec.rb",
+     "spec/piglet/relation/relation_spec.rb",
+     "spec/piglet/relation/split_spec.rb",
+     "spec/piglet/relation/union_spec.rb",
+     "spec/piglet/schema/tuple_spec.rb",
+     "spec/piglet_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/spec/piglet/field/field_spec.rb

@@ -9,8 +9,9 @@ include Piglet::Field
 describe Field do
 
   before do
-    @field = mock('field')
-    @field.extend Field
+    @field = Object.new
+    @field.extend(Field)
+    @field.stub(:predecessors).and_return([stub(:generate_field_alias => 'xyz')])
     @expressions = {}
     [:int, :long, :float, :double, :chararray, :bytearray, :bag, :tuple].each do |type|
       @expressions[type] = mock("#{type} expression")
@@ -19,6 +20,10 @@ describe Field do
     end
   end
   
+  it 'should have an alias' do
+    @field.field_alias.should_not be_nil
+  end
+  
   describe '#type' do
     [:==, :ne, :<, :>, :<=, :>=, :and, :or].each do |op|
       op_str = (op == :ne ? '!=' : op).to_s.upcase

data/spec/piglet/interpreter_spec.rb

@@ -32,7 +32,7 @@ describe Piglet::Interpreter do
   describe '#test' do
     it 'outputs a binary conditional' do
       @interpreter.interpret do
-        dump(load('in').foreach { |r| [test(r.a == r.b, r.a, r.b)]})
+        dump(load('in').foreach { [test(self.a == self.b, self.a, self.b)]})
       end
       @interpreter.to_pig_latin.should include('(a == b ? a : b)')
     end
@@ -41,35 +41,35 @@ describe Piglet::Interpreter do
   describe '#literal' do
     it 'outputs a literal string' do
       @interpreter.interpret do
-        dump(load('in').foreach { |r| [literal('hello').as(:world)]})
+        dump(load('in').foreach { [literal('hello').as(:world)]})
       end
       @interpreter.to_pig_latin.should include("'hello' AS world")
     end
     
     it 'outputs a literal integer' do
       @interpreter.interpret do
-        dump(load('in').foreach { |r| [literal(3).as(:n)]})
+        dump(load('in').foreach { [literal(3).as(:n)]})
       end
       @interpreter.to_pig_latin.should include("3 AS n")
     end
     
     it 'outputs a literal float' do
       @interpreter.interpret do
-        dump(load('in').foreach { |r| [literal(3.14).as(:pi)]})
+        dump(load('in').foreach { [literal(3.14).as(:pi)]})
       end
       @interpreter.to_pig_latin.should include("3.14 AS pi")
     end
     
     it 'outputs a literal string when passed an arbitrary object' do
       @interpreter.interpret do
-        dump(load('in').foreach { |r| [literal(self).as(:interpreter)]})
+        dump(load('in').foreach { [literal(self).as(:interpreter)]})
       end
       @interpreter.to_pig_latin.should match(/'[^']+' AS interpreter/)
     end
     
     it 'escapes single quotes' do
       @interpreter.interpret do
-        dump(load('in').foreach { |r| [literal("hello 'world'").as(:str)]})
+        dump(load('in').foreach { [literal("hello 'world'").as(:str)]})
       end
       @interpreter.to_pig_latin.should include("'hello \\'world\\'' AS str")
     end