cascading.jruby 0.0.9 → 0.0.10

data/samples/group_by.rb

@@ -1,61 +0,0 @@
-#! /usr/bin/env jruby
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'cascading'
-
-cascade 'group_by', :mode => :local do
-  flow 'group_by' do
-    source 'input', tap('samples/data/data_group_by.txt')
-
-    assembly 'input' do
-      split 'line', ['id', 'city'], :output => ['id', 'city']
-
-      branch 'group_by' do
-        group_by 'city', :sort_by => 'city' do
-          count
-          sum 'id', :type => :int
-        end
-      end
-
-      branch 'empty_group_by' do
-        group_by 'city', :sort_by => 'city' do
-        end
-      end
-
-      branch 'blockless_group_by' do
-        group_by 'city', :sort_by => 'city'
-      end
-
-      branch 'aggregate_by' do
-        group_by 'city' do
-          count
-          sum 'id', :type => :int
-        end
-      end
-
-      # These compile into GroupBy unless we relax Aggregations#can_aggregate?
-      # to allow empty Aggregations#aggregate_bys, which does not make sense
-      #branch 'empty_aggregate_by' do
-      #  group_by 'city' do
-      #  end
-      #end
-
-      #branch 'blockless_aggregate_by' do
-      #  group_by 'city'
-      #end
-
-      branch 'unique' do
-        sub_assembly Java::CascadingPipeAssembly::Unique.new(tail_pipe, fields('city'))
-      end
-    end
-
-    sink 'group_by', tap('output/group_by', :sink_mode => :replace)
-    sink 'empty_group_by', tap('output/empty_group_by', :sink_mode => :replace)
-    sink 'blockless_group_by', tap('output/blockless_group_by', :sink_mode => :replace)
-    sink 'aggregate_by', tap('output/aggregate_by', :sink_mode => :replace)
-    #sink 'empty_aggregate_by', tap('output/empty_aggregate_by', :sink_mode => :replace)
-    #sink 'blockless_aggregate_by', tap('output/blockless_aggregate_by', :sink_mode => :replace)
-    sink 'unique', tap('output/unique', :sink_mode => :replace)
-  end
-#end.draw(ARGV[0])
-end.complete

data/samples/join.rb

@@ -1,31 +0,0 @@
-#! /usr/bin/env jruby
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'cascading'
-
-cascade 'join', :mode => :local do
-  flow 'join' do
-    source 'input1', tap('samples/data/data_join1.txt')
-    source 'input2', tap('samples/data/data_join2.txt')
-    source 'input3', tap('samples/data/data_join3.txt')
-
-    assembly 'input1' do
-      split 'line', ['id', 'name']
-    end
-
-    assembly 'input2' do
-      split 'line', ['id', 'age']
-    end
-
-    assembly 'input3' do
-      split 'line', ['id', 'city']
-    end
-
-    assembly 'join' do
-      join 'input1', 'input2', 'input3', :on => 'id'
-      project 'id', 'name', 'age', 'city'
-    end
-
-    sink 'join', tap('output/join', :sink_mode => :replace)
-  end
-end.complete

data/samples/logwordcount.rb

@@ -1,22 +0,0 @@
-#! /usr/bin/env jruby
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'cascading'
-
-cascade 'logwordcount', :mode => :local do
-  flow 'logwordcount' do
-    # This works just as well, but will get you blocked by Project Gutenberg
-    #source 'input', tap('http://www.gutenberg.org/files/20417/20417-8.txt')
-    source 'input', tap('samples/data/gutenberg/the_outline_of_science_vol_1')
-
-    assembly 'input' do
-      split_rows 'line', 'word', :pattern => /[.,]*\s+/, :output => 'word'
-      group_by 'word' do
-        count
-      end
-      group_by 'count', :reverse => true
-    end
-
-    sink 'input', tap('output/logwordcount', :sink_mode => :replace)
-  end
-end.complete

data/samples/project.rb

@@ -1,23 +0,0 @@
-#! /usr/bin/env jruby
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-
-# History: "project" (verb) used to be known as "restrict"
-
-require 'cascading'
-
-cascade 'project', :mode => :local do
-  flow 'project' do
-    source 'input', tap('samples/data/data2.txt')
-
-    assembly 'input' do
-      split 'line', ['name', 'score1', 'score2', 'id'], :output => ['name', 'score1', 'score2', 'id']
-      assert Java::CascadingOperationAssertion::AssertSizeEquals.new(4)
-      project 'name', 'score1', 'score2'
-      assert Java::CascadingOperationAssertion::AssertSizeEquals.new(3)
-      project 'name', 'score2'
-      assert Java::CascadingOperationAssertion::AssertSizeEquals.new(2)
-    end
-
-    sink 'input', tap('output/project', :sink_mode => :replace)
-  end
-end.complete

data/samples/rename.rb

@@ -1,20 +0,0 @@
-#! /usr/bin/env jruby
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'cascading'
-
-cascade 'rename', :mode => :local do
-  flow 'rename' do
-    source 'input', tap('samples/data/data2.txt')
-
-    assembly 'input' do
-      split 'line', ['name', 'score1', 'score2', 'id'], :output => ['name', 'score1', 'score2', 'id']
-      assert Java::CascadingOperationAssertion::AssertSizeEquals.new(4)
-      rename 'name' => 'new_name', 'score1' => 'new_score1', 'score2' => 'new_score2'
-      assert Java::CascadingOperationAssertion::AssertSizeEquals.new(4)
-      puts "Final field names: #{scope.values_fields.to_a.inspect}"
-    end
-
-    sink 'input', tap('output/rename', :sink_mode => :replace)
-  end
-end.complete

data/samples/scorenames.rb

@@ -1,20 +0,0 @@
-#! /usr/bin/env jruby
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'cascading'
-
-cascade 'scorenames', :mode => :local do
-  flow 'scorenames' do
-    # You don't have to curl and cache inputs: tap can fetch via HTTP
-    #source 'input', tap('http://www.census.gov/genealogy/names/dist.all.last')
-    source 'input', tap('samples/data/genealogy/names/dist.all.last')
-
-    assembly 'input' do
-      split 'line', ['name', 'val1', 'val2', 'id']
-      insert 'val3' => expr('val2:double < 40.0 ? val1:double : val2:double')
-      project 'name', 'val3', 'id'
-    end
-
-    sink 'input', tap('output/scorenames', :sink_mode => :replace)
-  end
-end.complete

data/samples/splitter.rb

@@ -1,19 +0,0 @@
-#! /usr/bin/env jruby
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'cascading'
-
-cascade 'splitter', :mode => :local do
-  flow 'splitter' do
-    source 'input', tap('samples/data/data2.txt')
-
-    assembly 'input' do
-      split 'line', ['name', 'score1', 'score2', 'id'], :output => ['name', 'score1', 'score2', 'id']
-      group_by 'score1' do
-        count
-      end
-    end
-
-    sink 'input', tap('output/splitter', :sink_mode => :replace)
-  end
-end.complete

data/samples/sub_assembly.rb

@@ -1,30 +0,0 @@
-#! /usr/bin/env jruby
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'cascading'
-
-cascade 'sub_assembly', :mode => :local do
-  flow 'sub_assembly' do
-    source 'input', tap('samples/data/data2.txt')
-
-    assembly 'input' do
-      split 'line', ['name', 'score1', 'score2', 'id'], :output => ['name', 'score1', 'score2', 'id']
-      assert Java::CascadingOperationAssertion::AssertSizeEquals.new(4)
-      sub_assembly Java::CascadingPipeAssembly::Discard.new(tail_pipe, fields('id'))
-      assert Java::CascadingOperationAssertion::AssertSizeEquals.new(3)
-
-      sub_assembly Java::CascadingPipeAssembly::Unique.new(tail_pipe, fields('name'))
-      assert Java::CascadingOperationAssertion::AssertSizeEquals.new(3)
-
-      sub_assembly Java::CascadingPipeAssembly::Retain.new(tail_pipe, fields(['score1', 'score2']))
-      assert Java::CascadingOperationAssertion::AssertSizeEquals.new(2)
-
-      sub_assembly Java::CascadingPipeAssembly::Rename.new(tail_pipe, fields(['score1', 'score2']), fields(['score_a', 'score_b']))
-      assert Java::CascadingOperationAssertion::AssertSizeEquals.new(2)
-
-      debug_scope
-    end
-
-    sink 'input', tap('output/sub_assembly', :sink_mode => :replace)
-  end
-end.complete

data/samples/union.rb

@@ -1,36 +0,0 @@
-#! /usr/bin/env jruby
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'cascading'
-
-cascade 'union', :mode => :local do
-  flow 'union' do
-    # You don't have to curl and cache inputs: tap can fetch via HTTP
-    #source 'input', tap('http://www.census.gov/genealogy/names/dist.all.last')
-    source 'input', tap('samples/data/genealogy/names/dist.all.last')
-
-    assembly 'input' do
-      split 'line', ['name', 'score1', 'score2', 'id']
-
-      branch 'branch1' do
-        group_by 'score1', 'name' do
-          count
-        end
-        rename 'score1' => 'score'
-      end
-
-      branch 'branch2' do
-        group_by 'score2', 'name' do
-          count
-        end
-        rename 'score2' => 'score'
-      end
-    end
-
-    assembly 'union' do
-      union 'branch1', 'branch2'
-    end
-
-    sink 'union', tap('output/union', :sink_mode => :replace)
-  end
-end.complete

data/spec/cascading_spec.rb

@@ -1,105 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-context Cascading do
-  it 'should handle string and integer field names' do
-    f = fields(['a', 1, 'b', 2])
-    f.to_a.should == ['a', 1, 'b', 2]
-  end
-
-  it 'should dedup field names from multiple sources' do
-    left_names = ['a', 'b', 'c', 'd', 'e']
-    mid_names = ['a', 'f']
-    right_names = ['a', 'g']
-
-    field_names = dedup_field_names(left_names, mid_names, right_names)
-    field_names.should == [
-      'a', 'b', 'c', 'd', 'e',
-      'a_', 'f',
-      'a__', 'g'
-    ]
-  end
-
-  it 'should fail to resolve duplicate fields' do
-    incoming = fields(['line'])
-    declared = fields(['line'])
-    outgoing = all_fields
-    lambda do
-      begin
-        resolved = Java::CascadingTuple::Fields.resolve(outgoing, [incoming, declared].to_java(Java::CascadingTuple::Fields))
-      rescue NativeException => e
-        raise e.cause
-      end
-    end.should raise_error Java::CascadingTuple::TupleException, 'field name already exists: line'
-  end
-
-  it 'should find branches to sink' do
-    cascade 'branched_pass', :mode => :local do
-      flow 'branched_pass' do
-        source 'input', tap('spec/resource/test_input.txt', :scheme => text_line_scheme)
-        assembly 'input' do
-          branch 'branched_input' do
-            project 'line'
-          end
-        end
-        sink 'branched_input', tap("#{OUTPUT_DIR}/branched_pass_out", :sink_mode => :replace)
-      end
-    end.complete
-
-    ilc = `wc -l spec/resource/test_input.txt`.strip.split(/\s+/).first
-    olc = `wc -l #{OUTPUT_DIR}/branched_pass_out`.strip.split(/\s+/).first
-    olc.should == ilc
-  end
-
-  it 'should create an isolated namespace per cascade' do
-    cascade 'double', :mode => :local do
-      flow 'double' do
-        source 'input', tap('spec/resource/test_input.txt', :scheme => text_line_scheme)
-        assembly 'input' do # Dup name
-          insert 'doubled' => expr('line:string + "," + line:string')
-          project 'doubled'
-        end
-        sink 'input', tap("#{OUTPUT_DIR}/double_out", :sink_mode => :replace)
-      end
-    end
-
-    cascade 'pass', :mode => :local do
-      flow 'pass' do
-        source 'input', tap('spec/resource/test_input.txt', :scheme => text_line_scheme)
-        assembly 'input' do # Dup name
-          project 'line'
-        end
-        sink 'input', tap("#{OUTPUT_DIR}/pass_out", :sink_mode => :replace)
-      end
-    end
-
-    Cascade.get('double').complete
-    Cascade.get('pass').complete
-    diff = `diff #{OUTPUT_DIR}/double_out #{OUTPUT_DIR}/pass_out`
-    diff.should_not be_empty
-  end
-
-  it 'should support joins in branches' do
-    cascade 'branch_join', :mode => :local do
-      flow 'branch_join' do
-        source 'left', tap('spec/resource/join_input.txt', :scheme => text_line_scheme)
-        source 'right', tap('spec/resource/join_input.txt', :scheme => text_line_scheme)
-
-        assembly 'left' do
-          split 'line', ['x', 'y', 'z'], :pattern => /,/
-          project 'x', 'y', 'z'
-        end
-
-        assembly 'right' do
-          split 'line', ['x', 'y', 'z'], :pattern => /,/
-          project 'x', 'y', 'z'
-
-          branch 'branch_join' do
-            join 'left', 'right', :on => 'x'
-          end
-        end
-
-        sink 'branch_join', tap("#{OUTPUT_DIR}/branch_join_out.txt", :sink_mode => :replace)
-      end
-    end.complete
-  end
-end

data/spec/expr_spec.rb

@@ -1,230 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-context ExprStub do
-  it 'should allow expr syntax' do
-    test_assembly do
-      insert 'foo' => 1, 'bar' => expr('offset:int')
-      check_scope :values_fields => ['offset', 'line', 'bar', 'foo']
-    end
-  end
-
-  it 'should compile expressions' do
-    e = ExprStub.new('x:int + y:int')
-    e.compile
-  end
-
-  it 'should throw an exception for parsing failures' do
-    e = ExprStub.new('x:int + doesnotparse y:string')
-    lambda{ e.compile }.should raise_error CascadingException
-  end
-
-  it 'should throw an exception for compile failures' do
-    e = ExprStub.new('new DoesNotExist(x:int).doesnotcompile()')
-    lambda{ e.compile }.should raise_error CascadingException
-  end
-
-  it 'should throw an exception for compile failures' do
-    e = ExprStub.new('true ? x:int : y:string')
-    lambda{ e.compile }.should raise_error CascadingException
-  end
-
-  it 'should evaluate expressions' do
-    e = ExprStub.new('x:int + y:int')
-    result = e.eval(:x => 2, :y => 3)
-    result.should == 5
-
-    e = ExprStub.new('x:int + y:string')
-    result = e.eval(:x => 2, :y => 'blah')
-    result.should == '2blah'
-
-    e = ExprStub.new('x:long + y:int')
-    result = e.eval(:x => 2, :y => 3)
-    result.should == 5
-
-    e = ExprStub.new('x:double + y:int')
-    result = e.eval(:x => 2.0, :y => 3)
-    result.should == 5.0
-
-    e = ExprStub.new('x:float + y:int')
-    result = e.eval(:x => 2.0, :y => 3)
-    result.should == 5.0
-
-    e = ExprStub.new('x:bool && y:bool')
-    result = e.eval(:x => true, :y => false)
-    result.should == false
-  end
-
-  it 'should evaluate expressions despite argument order' do
-    e = ExprStub.new('x:int + y:int')
-    result = e.eval(:y => 3, :x => 2)
-    result.should == 5
-  end
-
-  it 'should throw an exception for invalid actual arguments' do
-    e = ExprStub.new('x:int + y:int')
-    lambda{ e.eval(:x => 2, :y => 'blah') }.should raise_error CascadingException
-
-    # Janino does not coerce numeric strings to Java Integers
-    e = ExprStub.new('x:int + y:int')
-    lambda{ e.eval(:x => 2, :y => '3') }.should raise_error CascadingException
-
-    # eval should not coerce numeric strings to Java Floats
-    e = ExprStub.new('x:int + y:float')
-    lambda{ e.eval(:x => 2, :y => '3') }.should raise_error CascadingException
-
-    # eval should not coerce numeric strings to Java Longs
-    e = ExprStub.new('x:long + y:int')
-    lambda{ e.eval(:x => '2', :y => 3) }.should raise_error CascadingException
-
-    # eval should not coerce floats to Java Longs
-    e = ExprStub.new('x:long + y:int')
-    lambda{ e.eval(:x => 2.0, :y => 3) }.should raise_error CascadingException
-
-    # eval should not coerce integers to Java Floats
-    e = ExprStub.new('x:int + y:float')
-    lambda{ e.eval(:x => 2, :y => 3) }.should raise_error CascadingException
-
-    e = ExprStub.new('x:float + y:int')
-    lambda{ e.eval(:x => 'blah', :y => 3) }.should raise_error CascadingException
-
-    e = ExprStub.new('x:long + y:int')
-    lambda{ e.eval(:x => [], :y => 3) }.should raise_error CascadingException
-
-    e = ExprStub.new('x:long + y:int')
-    lambda{ e.eval(:x => nil, :y => 3) }.should raise_error CascadingException
-  end
-
-  it 'should throw an exception for missing actual arguments' do
-    e = ExprStub.new('x:int + y:int')
-    lambda{ e.eval(:x => 2) }.should raise_error ExprArgException
-  end
-
-  it 'should ignore extraneous actual arguments' do
-    e = ExprStub.new('x:int + y:int')
-    result = e.eval(:x => 2, :y => 3, :z => 'unused')
-    result.should == 5
-  end
-
-  it 'should use default actual arguments to validate' do
-    e = ExprStub.new('x:int + y:int')
-    result = e.validate
-    result.should == 0
-
-    e = ExprStub.new('x:long + y:int')
-    result = e.validate
-    result.should == 0
-
-    e = ExprStub.new('x:double + y:int')
-    result = e.validate
-    result.should == 0.0
-
-    e = ExprStub.new('x:float + y:int')
-    result = e.validate
-    result.should == 0.0
-
-    e = ExprStub.new('x:bool && y:bool')
-    result = e.validate
-    result.should == false
-
-    e = ExprStub.new('x:int + y:string')
-    result = e.validate
-    result.should == '0null'
-
-    e = ExprStub.new('x:string + y:string')
-    result = e.validate
-    result.should == 'nullnull'
-  end
-
-  it 'should fail to validate these expressions with default actual arguments' do
-    e = ExprStub.new('x:string.indexOf("R") == -1')
-    lambda { e.validate }.should raise_error CascadingException
-
-    e = ExprStub.new('x:string.substring(0, 8)')
-    lambda { e.validate }.should raise_error CascadingException
-  end
-
-  it 'should allow overriding default actual arguments for validation' do
-    e = ExprStub.new('x:string.indexOf("R") == -1')
-    result = e.validate(:x => 'nothinghere')
-    result.should == true
-
-    e = ExprStub.new('x:string.substring(0, 8)')
-    result = e.validate(:x => 'atleast8chars')
-    result.should == 'atleast8'
-  end
-
-  it 'should allow overriding default actual arguments for validation via expr' do
-    expr('x:string.indexOf("R") == -1', :validate_with => { :x => 'nothinghere' })
-    expr('x:string.substring(0, 8)', :validate_with => { :x => 'atleast8chars' })
-  end
-
-  it 'should allow overriding default actual arguments for validation via filter' do
-    test_assembly do
-      filter :expression => 'line:string.indexOf("R") == -1', :validate_with => { :line => 'nothinghere' }
-      check_scope :values_fields => ['offset', 'line']
-    end
-  end
-
-  it 'should allow overriding default actual arguments for validation via where' do
-    test_assembly do
-      where 'line:string.equals("not_set") && "0".equals(offset:string)', :validate_with => { :line => 'nulls_rejected' }
-      check_scope :values_fields => ['offset', 'line']
-    end
-  end
-
-  it 'should allow disabling validation via expr' do
-    expr('x:string.indexOf("R") == -1', :validate => false)
-    expr('x:string.substring(0, 8)', :validate => false)
-  end
-
-  it 'should allow disabling validation via filter' do
-    test_assembly do
-      filter :expression => 'line:string.indexOf("R") == -1', :validate => false
-      check_scope :values_fields => ['offset', 'line']
-    end
-  end
-
-  it 'should allow disabling validation via where' do
-    test_assembly do
-      where 'line:string.indexOf("R") == -1', :validate => false
-      check_scope :values_fields => ['offset', 'line']
-    end
-  end
-
-  it 'should only allow floating point division by zero' do
-    e = ExprStub.new('x:float / y:float')
-    result = e.validate
-    result.nan?.should == true
-
-    e = ExprStub.new('x:double / y:double')
-    result = e.validate
-    result.nan?.should == true
-
-    # From: http://download.oracle.com/javase/6/docs/api/java/lang/ArithmeticException.html
-    # Thrown when an exceptional arithmetic condition has occurred. For
-    # example, an integer "divide by zero" throws an instance of this class.
-
-    e = ExprStub.new('x:long / y:long')
-    lambda { e.validate }.should raise_error CascadingException
-
-    e = ExprStub.new('x:int / y:int')
-    lambda { e.validate }.should raise_error CascadingException
-  end
-
-  it 'should catch missing fields in filter expressions' do
-    lambda do
-      test_assembly do
-        filter :expression => 'doesnotexist:int > offset:int'
-      check_scope :values_fields => ['offset', 'line', 'bar', 'foo']
-      end
-    end.should raise_error ExprArgException
-  end
-
-  it 'should catch missing fields in insert expressions' do
-    lambda do
-      test_assembly do
-        insert 'foo' => 1, 'bar' => expr('doesnotexist:int + offset:int')
-      end
-    end.should raise_error ExprArgException
-  end
-end

data/spec/jruby_version_spec.rb

@@ -1,72 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-context Object do
-  it 'should definitely not do this' do
-    names = ['x', 'y'].to_java(java.lang.String)
-    types = [java.lang.Integer.java_class, java.lang.Integer.java_class].to_java(java.lang.Class)
-    evaluator = Java::OrgCodehausJanino::ExpressionEvaluator.new('x + y', java.lang.Comparable.java_class, names, types)
-
-    thrown = nil
-    exception = nil
-    begin
-      evaluator.evaluate([nil, nil].to_java)
-    rescue java.lang.IllegalArgumentException => iae
-      thrown = 'IllegalArgumentException'
-      exception = iae
-    rescue java.lang.reflect.InvocationTargetException => ite
-      thrown = 'InvocationTargetException'
-      exception = ite
-    end
-
-    # How can this be?  A nil exception?
-    thrown.should == 'InvocationTargetException'
-    exception.should be_nil
-  end
-
-  case JRUBY_VERSION
-  when '1.2.0'
-    it 'should handle Fixnum -> Long for ExprStub#eval' do
-      e = ExprStub.new('x:long + y:long')
-      result = e.eval(:x => 2, :y => 3)
-      result.should == 5
-    end
-
-    it 'should handle Fixnum -> Long for ExprStub#validate' do
-      e = ExprStub.new('x:long + y:long')
-      result = e.validate
-      result.should == 0
-    end
-  when '1.4.0'
-    # This test previously failed for 1.4.0 (it's duplicated in cascading_spec)
-    it 'should handle string and integer field names' do
-      f = fields(['a', 1, 'b', 2])
-      f.to_a.should == ['a', 1, 'b', 2]
-    end
-
-    it 'should handle Fixnum -> Integer for ExprStub#eval' do
-      e = ExprStub.new('x:int + y:int')
-      result = e.eval(:x => 2, :y => 3)
-      result.should == 5
-    end
-
-    it 'should handle Fixnum -> Integer for ExprStub#validate' do
-      e = ExprStub.new('x:int + y:int')
-      result = e.validate
-      result.should == 0
-    end
-  when '1.5.3', '1.6.5'
-    it 'should handle Fixnum -> Integer for ExprStub#eval' do
-      e = ExprStub.new('x:int + y:int')
-      result = e.eval(:x => 2, :y => 3)
-      result.should == 5
-    end
-
-    it 'should handle Fixnum -> Integer for ExprStub#validate' do
-      e = ExprStub.new('x:int + y:int')
-      result = e.validate
-      result.should == 0
-    end
-  else
-    raise "cascading.jruby has not been tested with JRuby version #{JRUBY_VERSION}"
-  end
-end

data/spec/resource/join_input.txt

@@ -1,3 +0,0 @@
-1,4,world
-2,3,bar
-3,8,baz