table_diff 0.0.1

data/README.md

@@ -0,0 +1,52 @@
+# Table Diff
+
+A simple library for use in testing to compare an actual and expected table. Compatible with Cucumber, Rspec, and Turnip
+
+## Tables
+
+A table is essentially an array of arrays. Cucumber and Turnip both provide table classes that should be compatible with this library.
+
+A sample table:
+
+	[
+	  [ "Name", "Age", "Height" ], # The first 'row' will be used as headers
+	  [ "Dave", "99" , " 999cm" ],
+	  [ "Andy", "99" , " 999cm" ]
+	]
+
+This would be printed as:
+
+	| Name | Age | Height |
+	| Dave | 99  | 999cm  |
+	| Andy | 99  | 999cm  |
+
+## Usage
+
+	TableDiff::CompareTables.compare(actual, expected).should_not be_different
+
+## Forthcoming
+
+* Should handle extra rows
+* Should handle extra columns
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'table_diff'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install table_diff
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/table_diff.rb

@@ -0,0 +1,15 @@
+require "table_diff/version"
+
+module TableDiff
+  autoload :Table,               "table_diff/table"
+  autoload :ComparableTable,     "table_diff/comparable_table"
+  autoload :DifferentTables,     "table_diff/different_tables"
+
+  autoload :Row,                 "table_diff/row"
+  autoload :RowWithDifferences,  "table_diff/row_with_differences"
+
+  autoload :CompareTables,       "table_diff/compare_tables"
+  autoload :OutputFormatter,     "table_diff/output_formatter"
+
+  class MissingRows < Exception; end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'table_diff'

data/spec/table_diff/comparable_table_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe TableDiff::ComparableTable do
+
+  let(:table) { stub( :hashes => [{"foo" => "bar"}, {"baz" => "xlerb"}], :headers => {"foo" => "foo"}) }
+  let(:comparable_table) { described_class.new(table) }
+
+  describe "#rows" do
+    subject { comparable_table.rows }
+    it "is a collection of Rows" do
+      should(satisfy do |rows|
+        rows.all? { |r| r.is_a? TableDiff::Row }
+      end)
+    end
+  end
+
+  describe "#diff" do
+    subject { comparable_table.diff(expected_table) }
+
+    context "when there are no differences" do
+      let(:expected_table) { comparable_table }
+      it "returns self" do
+        should == comparable_table
+      end
+    end
+
+    context "when there are differences" do
+      let(:expected_table) do
+        described_class.new( stub( :hashes => [{ "foo" => "bar"}, {"baz" => "nope"}]) )
+      end
+
+      it "raises DifferentTables" do
+        expect { subject }.to raise_error TableDiff::DifferentTables
+      end
+    end
+
+    context "when the number of rows is not equal" do
+      let(:expected_table) do
+        described_class.new( stub( :hashes => [{"baz" => "nope"}] ) )
+      end
+      it "raises an error" do
+        expect {
+          subject
+        }.to raise_error TableDiff::MissingRows
+      end
+    end
+  end
+
+  describe "#different?" do
+    subject { comparable_table }
+    it { should_not be_different }
+  end
+end

data/spec/table_diff/compare_tables_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe TableDiff::CompareTables do
+  let(:diff) { TableDiff::CompareTables.compare actual, expected }
+
+  subject { diff }
+  context "when tables are the same" do
+    let(:actual) do
+      TableDiff::Table.new [ [ "Name", "Email", "Hat Size" ], [ "Dave", "a@b.co", "7 3/4"   ] ]
+    end
+
+    let(:expected) do
+      actual
+    end
+    it { should_not be_different }
+  end
+
+  context "when tables are not the same" do
+    let(:actual) do
+      TableDiff::Table.new [ [ "Name", "Email", "Hat Size" ], [ "Dave", "a@b.co", "7"   ] ]
+    end
+
+    let(:expected) do
+      TableDiff::Table.new [ [ "Name", "Email", "Hat Size" ], [ "Dave", "a@b.co", 7 ] ]
+    end
+    it { expect {subject}.to raise_error TableDiff::DifferentTables }
+  end
+end

data/spec/table_diff/different_tables_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe TableDiff::DifferentTables do
+end

data/spec/table_diff/output_formatter_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe TableDiff::OutputFormatter do
+  HEADERS = ["One", "Two", "Tree"]
+  Row = TableDiff::Row
+  RowWithDifferences = TableDiff::RowWithDifferences
+  def row_hash(array)
+    Hash[HEADERS.zip(array)]
+  end
+
+  let(:rows) do
+    actual = Row.new(row_hash ["Dave", "Jon", "Josh"])
+    expected = Row.new(row_hash ["Dave", "Brian", "Josh"])
+    [
+      Row.new(row_hash(HEADERS)),
+      Row.new(row_hash ["Foo", "Bar", "Baz"]),
+      RowWithDifferences.new( actual, expected)
+    ]
+  end
+
+
+  subject { described_class.new(rows) }
+
+  it do
+    expected = <<EOS
+|  One |         Two | Tree |
+|  Foo |         Bar |  Baz |
+| Dave | Jon (Brian) | Josh |
+EOS
+  subject.to_s.should == expected.chomp
+  end
+end

data/spec/table_diff/row_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe TableDiff::Row do
+  let(:row_hash) do
+    { "Name" => "Dave", "Number" => 11 }
+  end
+  let(:row) { described_class.new( row_hash ) }
+
+  it "keeps the raw row hash" do
+    row.raw.should == row_hash
+  end
+
+  describe "#diff" do
+    context "when there are no differences" do
+      let(:expected_row) { described_class.new(row_hash) }
+      it "returns self" do
+        row.diff(expected_row).should == row
+      end
+    end
+
+    context "when there are differences" do
+      let(:expected_row) { described_class.new(row_hash.merge("Name" => "Bob")) }
+      it "returns an instance of RowWithDifferences" do
+        row.diff(expected_row).should be_a TableDiff::RowWithDifferences
+      end
+    end
+  end
+
+  describe "#different?" do
+    subject { row }
+    it { should_not be_different }
+  end
+
+  describe "#widths" do
+    subject { row.widths }
+    it { should == [ 4, 2 ] }
+  end
+end

data/spec/table_diff/row_with_differences_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe TableDiff::RowWithDifferences do
+  subject { described_class.new nil, nil }
+  describe "#different?" do
+    it { should be_different }
+  end
+
+  describe "printing methods" do
+    let(:actual) { TableDiff::Row.new( { "a" => "bee", "d" => "foo"} ) }
+    let(:expected) { TableDiff::Row.new( { "a" => "woo", "d" => "foo"} ) }
+    describe "#strings" do
+      subject { described_class.new(actual, expected).strings }
+
+      it do
+        should == [ "bee (woo)", "foo" ]
+      end
+    end
+
+    describe "#widths" do
+      subject { described_class.new(actual, expected).widths }
+
+      it do
+        should == [ 9, 3 ]
+      end
+    end
+  end
+end

data/spec/table_diff/table_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe TableDiff::Table do
+  let(:raw_table) do
+    [
+      [ "Name", "Email", "Hat Size"],
+      [ "Dave", "a@b.co", "7 3/4"  ]
+    ]
+  end
+
+  let(:table) { described_class.new(raw_table) }
+
+  it "keeps the raw state" do
+    table.raw.should == raw_table
+  end
+
+  describe "#headers" do
+    subject { table.headers }
+    it "is the first row of the table" do
+      should == raw_table[0]
+    end
+  end
+
+  describe "#rows" do
+    subject { table.rows }
+    it "is all but the first row" do
+      should == [raw_table[1]]
+    end
+  end
+
+  describe "#hashes" do
+    subject { table.hashes }
+
+    let(:hashes) do
+      [{ "Name"     => "Dave",
+        "Email"    => "a@b.co",
+        "Hat Size" => "7 3/4" }]
+    end
+
+    it "hashes the header => column" do
+      should == hashes
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: table_diff
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dave Lyon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2151932660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151932660
+description: A simple library for use in testing to compare an actual and expected
+  table. Compatible with Cucumber, Rspec, and Turnip
+email:
+- dave@davelyon.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/table_diff.rb
+- README.md
+- spec/spec_helper.rb
+- spec/table_diff/comparable_table_spec.rb
+- spec/table_diff/compare_tables_spec.rb
+- spec/table_diff/different_tables_spec.rb
+- spec/table_diff/output_formatter_spec.rb
+- spec/table_diff/row_spec.rb
+- spec/table_diff/row_with_differences_spec.rb
+- spec/table_diff/table_spec.rb
+homepage: https://github.com/davelyon/table_diff
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Table Difference library for use in testing
+test_files:
+- spec/spec_helper.rb
+- spec/table_diff/comparable_table_spec.rb
+- spec/table_diff/compare_tables_spec.rb
+- spec/table_diff/different_tables_spec.rb
+- spec/table_diff/output_formatter_spec.rb
+- spec/table_diff/row_spec.rb
+- spec/table_diff/row_with_differences_spec.rb
+- spec/table_diff/table_spec.rb