diff-display 0.0.1

data/test/fixtures/multiple_adds_after_rem.diff

@@ -0,0 +1,11 @@
+--- a/one.txt
++++ b/one.txt
+@@ -193,7 +193,21 @@ module One
+       pre yada yada
+-        
++
++      foo
++      bar
++      baz
++      
+       post yada yada

data/test/fixtures/multiple_rems_then_add.diff

@@ -0,0 +1,14 @@
+diff --git a/strokedb-ruby/lib/stores/chainable_storage.rb b/strokedb-ruby/lib/stores/chainable_storage.rb
+index 5326c92..1e2de8f 100644
+--- a/strokedb-ruby/lib/stores/chainable_storage.rb
++++ b/strokedb-ruby/lib/stores/chainable_storage.rb
+@@ -44,9 +44,7 @@ module StrokeDB
+     def save_with_chained_storages!(chunk,source=nil)
+       perform_save!(chunk)
+       (@chained_storages||{}).each_pair do |storage,savings|
+-        unless storage == chunk
+-          savings << chunk unless savings.include?(chunk)
+-        end
++          savings << chunk unless  storage == chunk || savings.include?(chunk)
+       end
+     end

data/test/fixtures/only_add.diff

@@ -0,0 +1,4 @@
+--- a.txt	2008-02-03 16:28:06.000000000 +0100
++++ b.txt	2008-02-03 16:28:14.000000000 +0100
+@@ -0,0 +1 @@
++foo

data/test/fixtures/only_rem.diff

@@ -0,0 +1,4 @@
+--- b.txt	2008-02-03 16:28:14.000000000 +0100
++++ a.txt	2008-02-03 16:28:06.000000000 +0100
+@@ -1 +0,0 @@
+-foo

data/test/fixtures/pseudo_recursive.diff

@@ -0,0 +1,21 @@
+diff --git a/spec/fixtures/multiple_rems_then_add.diff b/spec/fixtures/multiple_rems_then_add.diff
+new file mode 100644
+index 0000000..f5fd3f8
+--- /dev/null
++++ b/spec/fixtures/multiple_rems_then_add.diff
+@@ -0,0 +1,14 @@
++diff --git a/strokedb-ruby/lib/stores/chainable_storage.rb b/strokedb-ruby/lib/stores/chainable_storage.rb
++index 5326c92..1e2de8f 100644
++--- a/strokedb-ruby/lib/stores/chainable_storage.rb
+++++ b/strokedb-ruby/lib/stores/chainable_storage.rb
++@@ -44,9 +44,7 @@ module StrokeDB
++     def save_with_chained_storages!(chunk,source=nil)
++       perform_save!(chunk)
++       (@chained_storages||{}).each_pair do |storage,savings|
++-        unless storage == chunk
++-          savings << chunk unless savings.include?(chunk)
++-        end
+++          savings << chunk unless  storage == chunk || savings.include?(chunk)
++       end
++     end
+

data/test/fixtures/simple.diff

@@ -0,0 +1,12 @@
+diff --git a/History.txt b/History.txt
+index 0ed7358..622c384 100644
+--- a/History.txt
++++ b/History.txt
+@@ -1,4 +1,5 @@
+ == 0.0.1 2008-01-28
+ 
+-* 1 major enhancement:
+-  * Initial release
++* 2 major enhancements:
++  * The Initial release
++  * stuff added

data/test/fixtures/simple_oneliner.diff

@@ -0,0 +1,7 @@
+--- a.txt	2009-03-04 17:20:15.000000000 +0100
++++ b.txt	2009-03-04 17:20:33.000000000 +0100
+@@ -1,3 +1,3 @@
+ foo
+-bar
++baz
+ baz

data/test/fixtures/simple_rewrite.diff

@@ -0,0 +1,8 @@
+diff --git a/text.txt b/text.txt
+index 7b57bd2..7010a82 100644
+--- a/text.txt
++++ b/text.txt
+@@ -1 +1 @@
+-some text
++asdasdsa
+

data/test/test_api.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + "/test_helper"
+
+class TestApi < Test::Unit::TestCase
+  include DiffFixtureHelper
+
+  def test_it_has_a_simple_API
+    diff = Diff::Display::Unified.new(load_diff("simple"))
+    diff.render(Diff::Renderer::Base.new)
+  end
+end

data/test/test_base_renderer.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + "/test_helper"
+
+class TestBaseRenderer < Test::Unit::TestCase
+  include DiffFixtureHelper
+  
+  def setup
+    @data = Diff::Display::Unified::Generator.run(load_diff("big"))
+    @base_renderer = Diff::Renderer::Base.new
+  end
+  
+  def test_it_classifies_a_classname
+    assert_equal "remblock", @base_renderer.send(:classify, Diff::Display::RemBlock.new)
+  end
+  
+  def test_it_calls_the_before_headerblock
+    @base_renderer.expects(:before_headerblock).at_least_once
+    @base_renderer.render(@data)
+  end
+  
+  # def test_it_calls_the_before_sepblock
+  #   @base_renderer.expects(:before_sepblock).at_least_once
+  #   @base_renderer.render(@data)
+  # end
+  
+  # def test_it_calls_the_before_modblock
+  #   @base_renderer.expects(:before_modblock).at_least_once
+  #   @base_renderer.render(@data)
+  # end
+  
+  def test_calls_the_before_unmodblock
+    @base_renderer.expects(:before_unmodblock).at_least_once
+    @base_renderer.render(@data)
+  end
+  
+  def test_should_calls_the_before_addblock
+    @base_renderer.expects(:before_addblock).at_least_once
+    @base_renderer.render(@data)
+  end
+  
+  def test_calls_the_before_remblock
+    @base_renderer.expects(:before_remblock).at_least_once
+    @base_renderer.render(@data)
+  end
+  
+  def test_calls_headerline
+    @base_renderer.expects(:headerline).at_least_once
+    @base_renderer.render(@data)
+  end
+  
+  def test_calls_unmodline
+    @base_renderer.expects(:unmodline).at_least_once
+    @base_renderer.render(@data)
+  end  
+  
+  def test_calls_addline
+    @base_renderer.expects(:addline).at_least_once
+    @base_renderer.render(@data)
+  end
+  
+  def test_calls_remline
+    @base_renderer.expects(:remline).at_least_once
+    @base_renderer.render(@data)
+  end
+  
+  def test_calls_the_after_headerblock
+    @base_renderer.expects(:after_headerblock).at_least_once
+    @base_renderer.render(@data)
+  end
+  
+  # def test_calls_the_after_sepblock
+  #   @base_renderer.expects(:after_sepblock).at_least_once
+  #   @base_renderer.render(@data)
+  # end
+  
+  # def test_calls_the_after_modblock
+  #   @base_renderer.expects(:after_modblock).at_least_once
+  #   @base_renderer.render(@data)
+  # end
+  
+  def test_calls_the_after_unmodblock
+    @base_renderer.expects(:after_unmodblock).at_least_once
+    @base_renderer.render(@data)
+  end
+  
+  def test_calls_the_after_addblock
+    @base_renderer.expects(:after_addblock).at_least_once
+    @base_renderer.render(@data)
+  end
+  
+  def test_calls_the_after_remblock
+    @base_renderer.expects(:after_remblock).at_least_once
+    @base_renderer.render(@data)
+  end
+  
+  def test_renders_a_basic_datastructure
+    output = @base_renderer.render(@data)
+    assert_not_equal nil, output
+  end
+end

data/test/test_datastructure.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + "/test_helper"
+
+class TestDatastructure < Test::Unit::TestCase
+  include DiffFixtureHelper  
+  
+  # Data
+  def test_behaves_like_an_array
+    data = Diff::Display::Data.new
+    data << "foo"
+    data.push "bar"
+    assert_equal ["foo", "bar"], data
+  end
+  
+  # Line
+  def test_initializes_with_an_old_line_number
+    line = Diff::Display::Line.new("foo", 12)
+    assert_equal 12, line.old_number
+  end
+
+  def test_initializes_with_numbers
+    line = Diff::Display::Line.new("foo", 12, 13)
+    assert_equal 12, line.old_number
+    assert_equal 13, line.new_number
+  end
+  
+  def test_has_a_class_method_for_creating_an_addline
+    line = Diff::Display::Line.add("foo", 7)
+    assert_instance_of Diff::Display::AddLine, line
+  end
+  
+  def test_has_a_class_method_for_creating_a_remline
+    line = Diff::Display::Line.rem("foo", 7)
+    assert_instance_of Diff::Display::RemLine, line
+  end
+  
+  def test_has_a_class_method_for_creating_a_unmodline
+    line = Diff::Display::Line.unmod("foo", 7, 8)
+    assert_instance_of Diff::Display::UnModLine, line
+  end
+  
+  def test_has_a_class_method_for_creating_a_header_line
+    line = Diff::Display::Line.header("foo")
+    assert_instance_of Diff::Display::HeaderLine, line
+  end
+  
+  def test_has_an_identifier
+    assert_equal :add, Diff::Display::Line.add("foo", 7).identifier
+    assert_equal :rem, Diff::Display::Line.rem("foo", 7).identifier
+    assert_equal :unmod, Diff::Display::Line.unmod("foo", 7, 8).identifier
+    assert_equal :header, Diff::Display::Line.header("foo").identifier
+    assert_equal :nonewline, Diff::Display::Line.nonewline("foo").identifier
+  end
+  
+  def test_expands_inline_changes
+    line = Diff::Display::AddLine.new('the \\0quick \\1brown fox', 42, true)
+    expanded = line.expand_inline_changes_with("START", "END")
+    assert_equal "the STARTquick ENDbrown fox", expanded.to_s
+  end
+  
+  def test_segments
+    line = Diff::Display::AddLine.new('the \\0quick \\1brown fox', 42, true)
+    assert_equal ["the ", "quick ", "brown fox"], line.segments
+  end
+  
+  # Block
+  def test_block_behaves_like_an_array
+    block = Diff::Display::Block.new
+    block.push 1,2,3
+    assert_equal 3, block.size
+    assert_equal [1,2,3], block
+  end
+  
+  def test_has_class_method_for_creating_an_addblock
+    block = Diff::Display::Block.add
+    assert_instance_of Diff::Display::AddBlock, block
+  end
+  
+  def test_has_class_method_for_creating_an_remblock
+    block = Diff::Display::Block.rem
+    assert_instance_of Diff::Display::RemBlock, block
+  end
+  
+  def test_has_class_method_for_creating_an_modblock
+    block = Diff::Display::Block.mod
+    assert_instance_of Diff::Display::ModBlock, block
+  end
+  
+  def test_has_class_method_for_creating_an_unmodblock
+    block = Diff::Display::Block.unmod
+    assert_instance_of Diff::Display::UnModBlock, block
+  end
+  
+  def test_has_class_method_for_creating_an_headerblock
+    block = Diff::Display::Block.header
+    assert_instance_of Diff::Display::HeaderBlock, block
+  end
+  
+end

data/test/test_diff_renderer.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + "/test_helper"
+
+class TestDiffRenderer < Test::Unit::TestCase
+  include DiffFixtureHelper
+  
+  def test_it_renders_a_diff_back_to_its_original_state
+    data = Diff::Display::Unified::Generator.run(load_diff("simple"))
+    base_renderer = Diff::Renderer::Diff.new
+    assert_equal load_diff("simple"), base_renderer.render(data)
+  end
+end
+

data/test/test_generator.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + "/test_helper"
+
+class TestGenerator < Test::Unit::TestCase
+  include DiffFixtureHelper
+  
+  def setup
+    @generator = Diff::Display::Unified::Generator.new
+  end
+  
+  def test_generator_run_raises_if_doesnt_get_a_enumerable_object
+    assert_raises(ArgumentError) do
+      Diff::Display::Unified::Generator.run(nil)
+    end
+  end
+  
+  def test_generator_run_processes_each_line_in_the_diff
+    Diff::Display::Unified::Generator.expects(:new).returns(@generator)
+    @generator.expects(:process).with("foo")
+    @generator.expects(:process).with("bar")
+    Diff::Display::Unified::Generator.run("foo\nbar")
+  end
+  
+  def test_generator_run_returns_the_data
+    Diff::Display::Unified::Generator.expects(:new).returns(@generator)
+    generated = Diff::Display::Unified::Generator.run("foo\nbar")
+    assert_instance_of Diff::Display::Data, generated
+  end
+  
+  def test_the_returned_that_object_is_in_parity_with_the_diff
+    %w[multiple_rems_then_add only_rem simple multiple_adds_after_rem only_add pseudo_recursive simple_oneliner].each do |diff|
+      data = Diff::Display::Unified::Generator.run(load_diff(diff))
+      assert_equal load_diff(diff).chomp, data.to_diff, "failed on #{diff}"
+    end
+  end
+  
+  def test_big
+    diff_data = load_diff("big")
+    data = Diff::Display::Unified::Generator.run(diff_data)
+    assert_equal diff_data.chomp, data.to_diff
+  end
+  
+  def test_multiple_rems_and_an_add_is_in_parity
+    diff_data = load_diff("multiple_rems_then_add")
+    data = Diff::Display::Unified::Generator.run(diff_data)
+    assert_equal diff_data.chomp, data.to_diff
+  end
+  
+  def test_doesnt_parse_linenumbers_that_isnt_part_if_the_diff
+    range = 1..14
+    expected_lines = range.to_a.map{|l| [nil, l] }
+    assert_equal expected_lines, line_numbers_for(:pseudo_recursive).compact
+  end
+  
+  def test_parses_no_newline_at_end_of_file
+    diff_data = load_diff("pseudo_recursive")
+    data = Diff::Display::Unified::Generator.run(diff_data)
+    assert_equal diff_data.chomp, data.to_diff
+    assert_instance_of Diff::Display::NonewlineBlock, data.last
+    assert_equal 1, data.last.size
+    assert_instance_of Diff::Display::NonewlineLine, data.last[0]
+    assert_equal '\', data.last[0]
+  end
+  
+  def test_a_changed_string_becomes_a_modblock
+    diff_data = load_diff("simple_oneliner")
+    data = Diff::Display::Unified::Generator.run(diff_data)
+    
+    assert_equal diff_data.chomp, data.to_diff
+    assert_equal 6, data.size
+    modblock = data[4]
+    assert_instance_of Diff::Display::ModBlock, modblock
+    assert_equal 2, modblock.size, modblock.inspect
+    
+    rem = modblock[0]
+    add = modblock[1]
+    assert_instance_of Diff::Display::RemLine, rem
+    assert_instance_of Diff::Display::AddLine, add    
+    assert add.inline_changes?
+    assert rem.inline_changes?
+  end
+
+  # line numbering
+  def test_numbers_correctly_for_multiple_adds_after_rem
+    expected = [
+      [193, 193],
+      [194, nil],
+      [nil, 194],
+      [nil, 195],
+      [nil, 196],
+      [nil, 197],
+      [nil, 198],
+      [195, 199]
+    ]
+    assert_equal expected, line_numbers_for(:multiple_adds_after_rem)
+  end
+
+  def test_numbers_correctly_for_simple
+    expected = [
+      [1, 1],
+      [2, 2],
+      [3, nil],
+      [4, nil],
+      [nil, 3],
+      [nil, 4],
+      [nil, 5],
+    ]
+    assert_equal expected, line_numbers_for(:simple)
+  end
+  
+  def test_rewrite_line_does_not_set_inline_changes
+    diff_data = load_diff("simple_rewrite")
+    data = Diff::Display::Unified::Generator.run(diff_data)
+    
+    assert_equal diff_data.chomp, data.to_diff
+    modblock = data[5]
+    assert_instance_of Diff::Display::ModBlock, modblock
+    
+    assert_instance_of Diff::Display::RemLine, rem = modblock[0]
+    assert_instance_of Diff::Display::AddLine, add = modblock[1]
+    
+    assert !rem.inline_changes?, "rem has inline changes"
+    assert !add.inline_changes?, "add has inline_changes"
+  end
+  
+  def test_should_not_explode_on_invalid_byte_sequences
+    diff_data = "+s\x8B\xB5\x13\n"
+    assert_nothing_raised do
+      Diff::Display::Unified::Generator.run(diff_data)
+    end
+  end
+
+  protected
+  def line_numbers_for(diff)
+    diff_data = load_diff(diff)
+    data = Diff::Display::Unified::Generator.run(diff_data)
+    linenos = []
+    data.each do |blk| 
+      blk.each do |line|
+        next if line.class == Diff::Display::HeaderLine
+        next if line.class == Diff::Display::NonewlineLine
+        linenos << [line.old_number, line.new_number]
+      end
+    end
+    linenos
+  end
+end