pig-spec 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in pig-unit.gemspec
+gemspec

data/README.md

@@ -0,0 +1,56 @@
+Summary/Description
+===================
+PigSpec is a Ruby gem which can be used to test Pig scripts.  It was designed to be easily integrated with the RSpec framework.  It is loosely based on PigUnit (see: https://pig.apache.org/docs/r0.8.1/pigunit.html).
+
+Building the gem:
+-----------------
+The PigSpec gem can be built with the following command:
+
+```bash
+gem build pig-spec.gemspec
+```
+
+Example usage:
+--------------
+```ruby
+require 'pig-spec'
+
+describe 'something to be tested' do
+  include PigSpec
+
+  it 'should run the pig script and produce a single line of output' do
+    test_pig_script 'pig-0.6.0-core.jar', 'fake_script.pig', { "generated_file.txt" => "PigSpec creates this file. Current time is: #{Time.now}" }, { "output.csv" => "1,2,3,4" }, { "param1" => "foo", "param2" => "bar" }
+    verify_output(false).should == true
+  end
+end
+```
+
+If PigSpec is properly installed, you will see the following line (along with standard RSpec output) when the spec is run:
+
+>Running the following command: java -jar pig-0.6.0-core.jar -x local -p param1=foo -p param2=bar fake_script.pig
+
+Unless you've made some modifications to the above example (e.g. pointing it to an actual Pig JAR & script on your system), the above example will fail and produce output that looks like:
+
+>Running the following command: java -jar pig-0.6.0-core.jar -x local -p param1=foo -p param2=bar fake_script.pig  
+>Unable to access jarfile pig-0.6.0-core.jar  
+>Pig script exited with non-zero exit code: 256.  
+>\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-  
+>| Verifying Pig script output... |  
+>\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-  
+>Pig script exited with non-zero exit code: 256.  
+>F
+>
+>Failures:
+>
+>  1) something to be tested should run the pig script and produce a single line of output  
+>     Failure/Error: verify_output(false).should == true  
+>       expected: true  
+>            got: false (using ==)  
+>     # ./spec/example_spec.rb:8
+>
+>Finished in 0.0131 seconds  
+>1 example, 1 failure
+>
+>Failed examples:
+>
+>rspec ./spec/example_spec.rb:6 # something to be tested should run the pig script and produce a single line of output

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/pig-spec.rb

@@ -0,0 +1,6 @@
+require "pig-spec/version"
+
+require 'pig-spec/pig_unit_core'
+
+module PigSpec
+end

data/lib/pig-spec/pig_unit_core.rb

@@ -0,0 +1,130 @@
+module PigSpec
+  require 'fileutils'
+  INPUT_DIR_PREFIX = "pig_test_"
+  PIG_CMD_PREFIX = "java -jar "
+
+  attr_reader :output_files, :input_dir, :error_stream, :stdout_stream, :exit_code
+  @@test_number = 0
+
+  def initialize
+    @output_files = {}
+    @input_dir = ""
+    @error_stream = $stderr
+    @stdout_stream = $stdout
+    @exit_code = 0
+  end
+
+  def self.test_number
+    @@test_number
+  end
+
+  def test_pig_script(pig_binary, pig_script, input_files_hash, output_files_hash, params)
+    @error_stream = error_stream
+    @stdout_stream = stdout_stream
+    @@test_number = @@test_number + 1
+
+    write_input_files(input_files_hash)
+    @output_files = output_files_hash
+    run_script(pig_binary, pig_script, params)
+  end
+
+  def build_pig_script_params(params)
+    if params.class != Hash
+      error_stream.puts "Params had unexpected class: #{params.class}"
+      return ""
+    end
+
+    params.reduce("") do |param_str, param|
+      param_str + (param_str.empty? ? "" : " ") + "-p " + param[0].to_s + "=" + param[1].to_s
+    end
+  end
+
+  def build_cmd_line(pig_binary, pig_script, params)
+    pig_params = build_pig_script_params(params)
+    pig_params = pig_params.empty? ? "" : "#{pig_params} "
+    "#{PIG_CMD_PREFIX}#{pig_binary} -x local #{pig_params}#{pig_script}"
+  end
+
+  def run_script(pig_binary, pig_script, params)
+    cmd_to_run = build_cmd_line(pig_binary, pig_script, params)
+    stdout_stream.puts("Running the following command: #{cmd_to_run}")
+    original_cwd = Dir.pwd
+    Dir.chdir(input_dir)
+    system cmd_to_run
+    @exit_code = $?
+    if exit_code != 0
+      error_stream.puts "Pig script exited with non-zero exit code: #{exit_code}."
+    end
+    Dir.chdir(original_cwd)
+  end
+
+  def write_input_files(input_files_hash)
+    @input_dir = File.expand_path(INPUT_DIR_PREFIX + PigSpec.test_number.to_i.to_s)
+
+    FileUtils.rm_rf(input_dir)
+    FileUtils.mkdir_p(input_dir)
+
+    if input_files_hash.class != Hash
+      error_stream.puts "Input files had unexpected class: #{input_files_hash.class}"
+      return
+    end
+
+    input_files_hash.keys.each do |file_name|
+      File.open(File.join(input_dir, file_name.to_s), "w") { |f| f.print(input_files_hash[file_name]) }
+    end
+  end
+
+  def print_mismatch_error(file)
+    error_stream.puts "Mismatch detected in '#{file}':"
+  end
+
+  def compare_pairs(file, pairs, mapping)
+    pairs.each do |pair|
+      if pair[0] != pair[1]
+        print_mismatch_error(file)
+        error_stream.puts "\tExpected line: '#{pair[mapping[:expected]]}'"
+        error_stream.puts "\tActual line:   '#{pair[mapping[:actual]]}'"
+        return false
+      end
+    end
+  end
+
+  def verify_output(order_matters)
+    stdout_stream.puts "----------------------------------"
+    stdout_stream.puts "| Verifying Pig script output... |"
+    stdout_stream.puts "----------------------------------"
+    if output_files.class != Hash
+      error_stream.puts "Expected hash of expected output with (filename, file content) pairs. Unexpected class: #{output_files.class}"
+      return false
+    elsif output_files.size == 0
+      error_stream.puts "No output files to verify."
+      return false
+    end
+
+    if exit_code != 0
+      error_stream.puts "Pig script exited with non-zero exit code: #{exit_code}."
+      return false
+    end
+
+    all_output_matched = true
+    original_cwd = Dir.pwd
+    Dir.chdir(input_dir)
+
+    output_files.keys.each do |file|
+      file_lines_array = IO.read(file).split("\n")
+      file_lines_array = file_lines_array.sort if !order_matters
+
+      expected_output_array = output_files[file].split("\n")
+      expected_output_array = expected_output_array.sort if !order_matters
+
+      if (!compare_pairs(file, expected_output_array.zip(file_lines_array), { :expected => 0, :actual => 1 }) ||
+          !compare_pairs(file, file_lines_array.zip(expected_output_array), { :expected => 1, :actual => 0 }))
+        all_output_matched = false
+        next
+      end
+    end
+
+    Dir.chdir(original_cwd)
+    all_output_matched
+  end
+end

data/lib/pig-spec/version.rb

@@ -0,0 +1,3 @@
+module PigSpec
+  VERSION = "0.0.2"
+end

data/pig-spec.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pig-spec/version"
+
+Gem::Specification.new do |s|
+  s.name = "pig-spec"
+  s.version = PigSpec::VERSION
+  s.authors = ["Matt Martin"]
+  s.email = ["matt [dot] martin [at] thinkbiganalytics [dot] com"]
+  s.homepage = "http://www.thinkbiganalytics.com/"
+  s.summary = %q{PigSpec is a PigUnit-like program implemented in Ruby.}
+  s.description = %q{PigSpec is a PigUnit-like program implemented in Ruby. It can be easily included into RSpec for running integration tests of existing Pig scripts.}
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+end

data/spec/pig-spec/pig_unit_core_spec.rb

@@ -0,0 +1,379 @@
+require 'spec_helper'
+require 'pig-spec/pig_unit_core'
+
+class DummyPigSpec
+  include PigSpec
+end
+
+describe PigSpec do
+  subject { DummyPigSpec.new }
+
+  let(:pig_binary)      { "pig-0.6.0-core.jar" }
+  let(:script_name)     { "test.pig" }
+  let(:input_hash)      { {"foo.txt" => "bar"} }
+  let(:output_hash)     { {:foo => "baz"} }
+  let(:params)          { {:param1 => "baz"} }
+  let(:unique_spec_dir) { PigSpec::INPUT_DIR_PREFIX.to_s + PigSpec.test_number.to_s }
+  let(:mock_stdout)     { mock }
+  let(:mock_stderr)     { mock }
+
+  before do
+    # Stub out stdout and stderr for tests where they are not relevant
+    subject.stub(:stdout_stream => mock_stdout)
+    mock_stdout.stub(:puts)
+
+    subject.stub(:error_stream => mock_stderr)
+    mock_stderr.stub(:puts)
+  end
+
+  def generate_unique_str
+    Time.now.to_f.to_s.gsub(".", "_")
+  end
+
+  describe '#test_pig_script' do
+    before do
+      subject.stub(:write_input_files)
+      subject.stub(:run_script)
+    end
+
+    it "should call the run_script method with the appropriate command line parameters" do
+      subject.should_receive(:run_script).with(pig_binary, script_name, params)
+      subject.test_pig_script(pig_binary, script_name, input_hash, output_hash, params)
+    end
+
+    it "should call the write_input_files method" do
+      subject.should_receive(:write_input_files).with(input_hash)
+      subject.test_pig_script(pig_binary, script_name, input_hash, output_hash, params)
+    end
+
+    it "should store the expected output files in an instance variable" do
+      subject.test_pig_script(pig_binary, script_name, input_hash, output_hash, params)
+      subject.output_files.should == output_hash
+    end
+
+    it "should increment the test number" do
+      prev_test_number = PigSpec.test_number
+      subject.test_pig_script(pig_binary, script_name, input_hash, output_hash, params)
+      PigSpec.test_number.should == prev_test_number + 1
+    end
+  end
+
+  describe '#write_input_files' do
+    before do
+      PigSpec.stub(:test_number).and_return(Time.now.to_i)
+      FileUtils.rm_rf(unique_spec_dir) if File.exists?(unique_spec_dir)
+    end
+
+    after do
+      FileUtils.rm_rf(unique_spec_dir) if File.exists?(unique_spec_dir)
+    end
+
+    let(:input_files)     { {} }
+
+    context "when a temporary output directory does not already exist" do
+      it "should create a temporary directory using the test number" do
+        subject.write_input_files(input_files)
+        File.directory?(unique_spec_dir).should == true
+      end
+    end
+
+    context "when a temporary output directory already exists" do
+      before do
+        FileUtils.mkdir_p(unique_spec_dir)
+        File.open(File.join(unique_spec_dir, generate_unique_str + ".txt"), "w") { |f| f.print("hello world") }
+      end
+
+      it "should delete the existing directory contents" do
+        Dir.glob(File.join(unique_spec_dir, "*")).size.should > 0
+        subject.write_input_files(input_files)
+        Dir.glob(File.join(unique_spec_dir, "*")).size.should == 0
+      end
+    end
+
+    context "when the hash of input files is not empty" do
+      let(:input_files) { { "foo_#{generate_unique_str}.txt" => generate_unique_str,
+                            "bar_#{generate_unique_str}.txt" => generate_unique_str } }
+
+      it "should create one file per hash key and use the hash keys as the filename and hash values as the content" do
+        subject.write_input_files(input_files)
+
+        input_files.keys.each do |file_name|
+          file_path = File.join(unique_spec_dir, file_name)
+          File.exists?(file_path).should == true
+          IO.readlines(file_path).join("").should == input_files[file_name]
+        end
+      end
+    end
+
+    context "when the paramter is not a hash" do
+      let(:input_files) { nil }
+      before do
+        input_files.class.should_not == Hash
+      end
+
+      it "should print an error and return an empty string" do
+        subject.should_receive(:error_stream).and_return(mock_stderr)
+        mock_stderr.should_receive(:puts).with("Input files had unexpected class: #{input_files.class}")
+
+        subject.write_input_files(input_files)
+      end
+    end
+  end
+
+  describe '#build_pig_script_params' do
+    context "when at least one paramter exists" do
+      let(:params) { {"foo" => 123, "bAr" => "234"} }
+      it "should create a string where the hash keys are the parameter names and the parameter values are the hash values" do
+        subject.build_pig_script_params(params).should == "-p foo=123 -p bAr=234"
+      end
+    end
+
+    context "when the hash of paramters is empty" do
+      let(:params) { {} }
+      it "should return an empty string" do
+        subject.build_pig_script_params(params).should == ""
+      end
+    end
+
+    context "when the paramter is not a hash" do
+      let(:params) { nil }
+      before do
+        params.class.should_not == Hash
+      end
+
+      it "should print an error and return an empty string" do
+        subject.should_receive(:error_stream).and_return(mock_stderr)
+        mock_stderr.should_receive(:puts).with("Params had unexpected class: #{params.class}")
+
+        subject.build_pig_script_params(params).should == ""
+      end
+    end
+  end
+
+  describe '#build_cmd_line' do
+    it "should call the build_pig_script_params helper method" do
+      subject.should_receive(:build_pig_script_params).with(params).and_return("-p fake=fake_value")
+      subject.build_cmd_line(pig_binary, script_name, params)
+    end
+
+    it "should build a string which joins a standard prefix with the flattened pig parameters and pig script name" do
+      subject.build_cmd_line(pig_binary, script_name, params).should == "#{PigSpec::PIG_CMD_PREFIX}#{pig_binary} -x local -p param1=baz #{script_name}"
+    end
+
+    context "when there are no Pig script parameters" do
+      let(:params) { {} }
+      it "should build a script which joins a standard prefix and the pig script name" do
+        subject.build_cmd_line(pig_binary, script_name, params).should == "#{PigSpec::PIG_CMD_PREFIX}#{pig_binary} -x local #{script_name}"
+      end
+    end
+  end
+
+  describe '#run_script' do
+    before do
+      Dir.stub(:chdir)
+    end
+
+    it "should call the build_cmd_line helper method" do
+      subject.should_receive(:build_cmd_line).with(pig_binary, script_name, params).and_return("echo 'echo' is a harmless command")
+      subject.run_script(pig_binary, script_name, params)
+    end
+
+    it "should print the command that it is running to stdout" do
+      subject.stub(:build_cmd_line => 'echo')
+      mock_stdout.should_receive(:puts).with("Running the following command: echo")
+      subject.run_script(pig_binary, script_name, params)
+    end
+
+    def echo_string_to_unique_file(base_dir)
+      unique_str = generate_unique_str
+      unique_filename = File.join(base_dir, "temp_" + unique_str + ".txt")
+      FileUtils.rm_rf(unique_filename) if File.exists?(unique_filename)
+
+      subject.stub(:build_cmd_line => 'echo "' + unique_str + '" > ' + unique_filename)
+
+      subject.run_script(pig_binary, script_name, params)
+      File.exists?(unique_filename).should == true
+      IO.readlines(unique_filename).join("") == unique_str
+
+      FileUtils.rm_rf(unique_filename)
+    end
+
+    it "should run the string returned by the build_cmd_line helper method" do
+      unique_filename = echo_string_to_unique_file(File.expand_path("."))
+    end
+
+    context "when the command fails" do
+      it "should print an error message with the appropriate exit code" do
+        subject.stub(:build_cmd_line => 'false')
+        system 'false'
+        false_exit_code = $?
+
+        subject.should_receive(:error_stream).and_return(mock_stderr)
+        mock_stderr.should_receive(:puts).with("Pig script exited with non-zero exit code: #{false_exit_code}.")
+
+        subject.exit_code.should == 0
+        subject.run_script(pig_binary, script_name, params)
+        subject.exit_code.should == false_exit_code
+      end
+    end
+
+    it "should run the command within the temporary directory created for this test" do
+      original_cwd = Dir.pwd
+      unique_dir = File.expand_path(FileUtils.mkdir_p(generate_unique_str))
+      subject.should_receive(:input_dir).and_return(unique_dir)
+
+      unique_filename = echo_string_to_unique_file(unique_dir)
+      Dir.pwd.should == original_cwd
+
+      FileUtils.rm_rf(unique_dir)
+    end
+  end
+
+  describe '#verify_output' do
+    let(:order_matters)  { true }
+
+    it "should print a standard message letting the user know that it's about to start verifying output" do
+      mock_stdout.should_receive(:puts).with("----------------------------------")
+      mock_stdout.should_receive(:puts).with("| Verifying Pig script output... |")
+      mock_stdout.should_receive(:puts).with("----------------------------------")
+      subject.verify_output(order_matters)
+    end
+
+    context "when there is no expected output" do
+      before do
+        subject.stub(:output_files).and_return( {} )
+      end
+
+      it "should print an error message and return false" do
+        subject.should_receive(:error_stream).and_return(mock_stderr)
+        mock_stderr.should_receive(:puts).with("No output files to verify.")
+        subject.verify_output(order_matters).should == false
+      end
+    end
+
+    context "when the expected output is not a hash" do
+      before do
+        subject.stub(:output_files).and_return( nil )
+      end
+
+      it "should return false and print an error message" do
+        subject.should_receive(:error_stream).and_return(mock_stderr)
+        mock_stderr.should_receive(:puts).with("Expected hash of expected output with (filename, file content) pairs. Unexpected class: #{nil.class}")
+        subject.verify_output(order_matters).should == false
+      end
+    end
+
+    context "when there is one or more output files to compare and there are no type errors" do
+      let(:file_paths)       { [File.join(generate_unique_str + ".txt"),
+                                File.join(generate_unique_str + ".txt")] }
+      let(:file_contents)    { ["hello world\ngoodbye world\nhi world\nhey world\nlater world\nbye world\n",
+                                "hello universe\ngoodbye universe\nhi universe\nhey universe\nlater universe\nbye universe"] }
+      let(:actual_output)    { Hash[*file_paths.zip(file_contents).flatten] }
+      let(:reordered_output) { actual_output.merge( {file_paths[0] => file_contents[0].split("\n").sort.join("\n")} ) }
+
+      before do
+        subject.stub(:input_dir).and_return(generate_unique_str)
+        FileUtils.mkdir_p(subject.input_dir)
+
+        actual_output.keys.each do |file_path|
+          File.open(File.join(subject.input_dir, file_path), "w") { |f| f.print(actual_output[file_path]) }
+        end
+
+        subject.stub(:output_files).and_return( actual_output )
+
+        reordered_output.should_not == actual_output
+      end
+
+      after do
+        FileUtils.rm_rf(subject.input_dir) if File.exists?(subject.input_dir)
+      end
+
+      it "should return false when the Pig script exits with a non-zero exit code" do
+        subject.stub(:exit_code).and_return(123)
+        subject.should_receive(:error_stream).and_return(mock_stderr)
+        mock_stderr.should_receive(:puts).with("Pig script exited with non-zero exit code: 123.")
+        subject.verify_output(order_matters).should == false
+      end
+
+      context "when the actual output has one or more lines than the expected output" do
+        let(:mismatch) { actual_output[file_paths[0]].split("\n")[0..-2].join("\n") }
+        before do
+          subject.stub(:output_files).and_return( actual_output.merge( file_paths[0] => mismatch ) )
+        end
+        it "should print the first extra line and return false" do
+          subject.should_receive(:error_stream).and_return(mock_stderr)
+          mock_stderr.should_receive(:puts).with("Mismatch detected in '#{file_paths[0]}':")
+          mock_stderr.should_receive(:puts).with("\tExpected line: ''")
+          mock_stderr.should_receive(:puts).with("\tActual line:   '#{actual_output[file_paths[0]].split("\n")[-1]}'")
+          subject.verify_output(order_matters).should == false
+        end
+      end
+
+      context "when the expected output has one or more lines than the actual output" do
+        let(:mismatch) { actual_output[file_paths[0]] + "extra line\n" }
+        before do
+          subject.stub(:output_files).and_return( actual_output.merge( file_paths[0] => mismatch ) )
+        end
+        it "should print the first extra line and return false" do
+          subject.should_receive(:error_stream).and_return(mock_stderr)
+          mock_stderr.should_receive(:puts).with("Mismatch detected in '#{file_paths[0]}':")
+          mock_stderr.should_receive(:puts).with("\tExpected line: '#{mismatch.split("\n")[-1]}'")
+          mock_stderr.should_receive(:puts).with("\tActual line:   ''")
+          subject.verify_output(order_matters).should == false
+        end
+      end
+
+      context "when output order matters" do
+        let(:order_matters)  { true }
+
+        context "when the output is exactly the same as the file contents" do
+          it "should return true" do
+            subject.verify_output(order_matters).should == true
+          end
+        end
+
+        context "when the output is not exactly the same as the file contents" do
+          before do
+            subject.stub(:output_files).and_return( reordered_output )
+          end
+
+          it "should return false" do
+            subject.should_receive(:error_stream).and_return(mock_stderr)
+            mock_stderr.should_receive(:puts).with("Mismatch detected in '#{file_paths[0]}':")
+            mock_stderr.should_receive(:puts).with("\tExpected line: '#{reordered_output[file_paths[0]].split("\n")[0]}'")
+            mock_stderr.should_receive(:puts).with("\tActual line:   '#{actual_output[file_paths[0]].split("\n")[0]}'")
+            subject.verify_output(order_matters).should == false
+          end
+        end
+      end
+
+      context "when output order doesn't matter" do
+        let(:order_matters) { false }
+
+        context "when expected output contains the same lines as the file, but in a different order" do
+          before do
+            subject.stub(:output_files).and_return( reordered_output )
+          end
+
+          it "should return true" do
+            subject.verify_output(order_matters).should == true
+          end
+        end
+
+        context "when expected output does not contain the same lines as the file" do
+          let(:mismatch) { reordered_output[file_paths[0]] + "2" }
+          before do
+            subject.stub(:output_files).and_return( reordered_output.merge( file_paths[0] => mismatch ) )
+          end
+          it "should return false" do
+            subject.should_receive(:error_stream).and_return(mock_stderr)
+            mock_stderr.should_receive(:puts).with("Mismatch detected in '#{file_paths[0]}':")
+            mock_stderr.should_receive(:puts).with("\tExpected line: '#{mismatch.split("\n")[-1]}'")
+            mock_stderr.should_receive(:puts).with("\tActual line:   '#{mismatch[0, mismatch.size - 1].split("\n")[-1]}'")
+            subject.verify_output(order_matters).should == false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'bundler'
+Bundler.setup
+
+require 'rspec'

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: pig-spec
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Matt Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-21 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: PigSpec is a PigUnit-like program implemented in Ruby. It can be easily included into RSpec for running integration tests of existing Pig scripts.
+email: 
+- matt [dot] martin [at] thinkbiganalytics [dot] com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/pig-spec.rb
+- lib/pig-spec/pig_unit_core.rb
+- lib/pig-spec/version.rb
+- pig-spec.gemspec
+- spec/pig-spec/pig_unit_core_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.thinkbiganalytics.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: PigSpec is a PigUnit-like program implemented in Ruby.
+test_files: 
+- spec/pig-spec/pig_unit_core_spec.rb
+- spec/spec_helper.rb