diffy 1.1.0 → 2.0.0

data/README.md

@@ -6,9 +6,20 @@ way to generate a diff from two strings.  Instead of reimplementing the LCS diff
 algorithm Diffy uses battle tested Unix diff to generate diffs, and focuses on
 providing a convenient interface, and getting out of your way.
 
-It provides several built in format options.  Pass `:text`, `:color`, or
-`:html` to `Diffy::Diff#to_s` to force that format, or set
-`Diffy::Diff.default_format`
+Supported Formats
+-----------------
+
+It provides several built in format options which can be passed to
+`Diffy::Diff#to_s`.
+
+* `:text`         - Plain text output
+* `:color`        - ANSI colorized text suitable for use in a terminal
+* `:html`         - HTML output.  Since version 2.0 this format does inline highlighting of the changes between two the changes within lines.
+* `:html_simple`  - HTML output without inline highlighting.  This may be useful in situations where high performance is required or simpler output is desired.
+
+A default format can be set like so:
+
+    Diffy::Diff.default_format = :html
 
 Getting Started
 ---------------
@@ -39,7 +50,7 @@ Here's an example of using Diffy to diff two strings
 
 Outputing the diff as html is easy too.
 
-    >> puts Diffy::Diff.new(string1, string2).to_s(:html)
+    >> puts Diffy::Diff.new(string1, string2).to_s(:html_simple)
     <div class="diff">
       <ul>
         <li class="del"><del>Hello how are you</del></li>
@@ -56,26 +67,23 @@ Then try adding this css to your stylesheets:
     .diff ul{background:#fff;overflow:auto;font-size:13px;list-style:none;margin:0;padding:0;display:table;width:100%;}
     .diff del, .diff ins{display:block;text-decoration:none;}
     .diff li{padding:0; display:table-row;margin: 0;}
+    /* try 'whitespace:pre;' if you don't want lines to wrap */
+    .diff del, .diff ins, .diff span{white-space:pre-wrap;font-family:courier;}
     .diff li.ins{background:#9f9;}
-    .diff li.del{background:#ccf;}
-    .diff li:hover{background:#ffc}
-    .diff del, .diff ins, .diff span{white-space:pre;font-family:courier;}
+    .diff li.del{background:#fcc;}
+    .diff li.ins strong{font-weight:normal; background: #6f6 }
+    .diff li.del strong{font-weight:normal; background: #f99 }
 
-`Diffy::Diff` also alows you to set a default format.  Here we set the default to
-use ANSI termnial color escape sequences.
+You can also diff files instead of strings
 
-    >> Diffy::Diff.default_format = :color
-    => :color
-    >> puts Diffy::Diff.new(string1, string2) # prints color in the terminal
-    -Hello how are you
-    +Hello how are you?
-     I'm fine
-    -That's great
-    +That's swell
+    >> puts Diffy::Diff.new('/tmp/foo', '/tmp/bar', :source => 'files')
 
+Custom Formats
+--------------
 
-Creating custom formatted output is easy too.  `Diffy::Diff` provides an
-enumberable interface which lets you iterate over lines in the diff.
+Diffy tries to make generating your own custom formatted output easy.
+`Diffy::Diff` provides an enumberable interface which lets you iterate over
+lines in the diff.
 
     >> Diffy::Diff.new("foo\nbar\n", "foo\nbar\nbaz\n").each do |line|
     >*   case line
@@ -86,7 +94,25 @@ enumberable interface which lets you iterate over lines in the diff.
     line +baz added
     => [" foo\n", " bar\n", "+baz\n"]
 
+You can also use `Diffy::Diff#each_chunk` to iterate each grouping of additions,
+deletions, and unchanged in a diff.
+
+    >> Diffy::Diff.new("foo\nbar\nbang\nbaz\n", "foo\nbar\nbing\nbong\n").each_chunk.to_a
+    => [" foo\n bar\n", "-bang\n-baz\n", "+bing\n+bong\n"]
+
 Use `#map`, `#inject`, or any of Enumerable's methods.  Go crazy.
 
-Report bugs or request features at http://github.com/samg/Diffy/issues
+Ruby Version Compatibility
+-------------------------
+
+Support for Ruby 1.8.6 was dropped beggining at version 2.0 in order to support
+the chainable enumerators available in 1.8.7 and 1.9.
+
+If you want to use Diffy and Ruby 1.8.6 then:
+
+    $ gem install diffy -v1.1.0
+
+---------------------------------------------------------------------
+
+Report bugs or request features at http://github.com/samg/diffy/issues
 

data/VERSION

@@ -1 +1 @@
-1.1.0
+2.0.0

data/dirb.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{diffy}
-  s.version = "1.1.0"
+  s.version = "2.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sam Goldstein"]
-  s.date = %q{2010-10-15}
+  s.date = %q{2010-11-20}
   s.description = %q{Convenient diffing in ruby}
   s.email = %q{sgrock@gmail.com}
   s.extra_rdoc_files = [
@@ -25,6 +25,9 @@ Gem::Specification.new do |s|
      "VERSION",
      "diffy.gemspec",
      "lib/diffy.rb",
+     "lib/diffy/diff.rb",
+     "lib/diffy/format.rb",
+     "lib/diffy/html_formatter.rb",
      "spec/diffy_spec.rb"
   ]
   s.homepage = %q{http://github.com/samg/diffy/tree/master}

data/lib/diffy.rb

@@ -0,0 +1,12 @@
+require 'tempfile'
+require 'open3'
+require 'erb'
+# 1.9 compatibility
+if defined? Enumerator and ! defined? Enumerable::Enumerator
+  Enumerable::Enumerator = Enumerator
+end
+
+module Diffy; end
+require File.join(File.dirname(__FILE__), 'diffy', 'format')
+require File.join(File.dirname(__FILE__), 'diffy', 'html_formatter')
+require File.join(File.dirname(__FILE__), 'diffy', 'diff')

data/lib/diffy/diff.rb

@@ -0,0 +1,105 @@
+module Diffy
+  class Diff
+    class << self
+      attr_writer :default_format
+      def default_format
+        @default_format || :text
+      end
+    end
+    include Enumerable
+    attr_reader :string1, :string2, :options, :diff
+
+    # supported options
+    # +:diff+::    A cli options string passed to diff
+    # +:source+::  Either _strings_ or _files_.  Determines whether string1
+    #              and string2 should be interpreted as strings or file paths.
+    def initialize(string1, string2, options = {})
+      @options = {:diff => '-U 10000', :source => 'strings'}.merge(options)
+      if ! ['strings', 'files'].include?(@options[:source])
+        raise ArgumentError, "Invalid :source option #{@options[:source].inspect}. Supported options are 'strings' and 'files'."
+      end
+      @string1, @string2 = string1, string2
+    end
+
+    def diff
+      @diff ||= begin
+        paths = case options[:source]
+          when 'strings'
+            [tempfile(string1), tempfile(string2)]
+          when 'files'
+            [string1, string2]
+          end
+        diff ||= Open3.popen3(
+          *[ diff_bin, options[:diff], *paths ]
+        ) { |i, o, e| o.read }
+        if diff =~ /\A\s*\Z/
+          diff = case options[:source]
+          when 'strings' then string1
+          when 'files' then File.read(string1)
+          end.gsub(/^/, " ")
+        end
+        diff
+      end
+    end
+
+    def each
+      lines = diff.split("\n").reject{|x| x =~ /^---|\+\+\+|@@|\\\\/ }.
+        map{|line| line + "\n"}
+      if block_given?
+        lines.each{|line| yield line}
+      else
+        Enumerable::Enumerator.new(lines)
+      end
+    end
+
+    def each_chunk
+      old_state = nil
+      chunks = inject([]) do |cc, line|
+        state = line.each_char.first
+        if state == old_state
+          cc.last << line
+        else
+          cc.push line.dup
+        end
+        old_state = state
+        cc
+      end
+
+      if block_given?
+        chunks.each{|chunk| yield chunk }
+      else
+        Enumerable::Enumerator.new(chunks)
+      end
+    end
+
+    def tempfile(string)
+      t = Tempfile.new('diffy')
+      t.print(string)
+      t.flush
+      t.path
+    end
+
+    def to_s(format = nil)
+      format ||= self.class.default_format
+      formats = Format.instance_methods(false).map{|x| x.to_s}
+      if formats.include? format.to_s
+        enum = self
+        enum.extend Format
+        enum.send format
+      else
+        raise ArgumentError,
+          "Format #{format.inspect} not found in #{formats.inspect}"
+      end
+    end
+    private
+
+    def diff_bin
+      bin = `which diff`.chomp
+      if bin.empty?
+        raise "Can't find a diff executable in PATH #{ENV['PATH']}"
+      end
+      bin
+    end
+
+  end
+end

data/lib/diffy/format.rb

@@ -0,0 +1,33 @@
+module Diffy
+  module Format
+    # ANSI color output suitable for terminal output
+    def color
+      map do |line|
+        case line
+        when /^\+/
+          "\033[32m#{line.chomp}\033[0m"
+        when /^-/
+          "\033[31m#{line.chomp}\033[0m"
+        else
+          line.chomp
+        end
+      end.join("\n") + "\n"
+    end
+
+    # Basic text output
+    def text
+      to_a.join
+    end
+
+    # Basic html output which does not attempt to highlight the changes
+    # between lines, and is more performant.
+    def html_simple
+      HtmlFormatter.new(self).to_s
+    end
+
+    # Html output which does inline highlighting of changes between two lines.
+    def html
+      HtmlFormatter.new(self, :highlight_words => true).to_s
+    end
+  end
+end

data/lib/diffy/html_formatter.rb

@@ -0,0 +1,90 @@
+module Diffy
+  class HtmlFormatter
+    def initialize(diff, options = {})
+      @diff = diff
+      @options = options
+    end
+
+    def to_s
+      if @options[:highlight_words]
+        wrap_lines(highlighted_words)
+      else
+        wrap_lines(@diff.map{|line| wrap_line(ERB::Util.h(line))})
+      end
+    end
+
+    private
+    def wrap_line(line)
+      cleaned = line.gsub(/^./, '').chomp
+      case line
+      when /^\+/
+        '    <li class="ins"><ins>' + cleaned + '</ins></li>'
+      when /^-/
+        '    <li class="del"><del>' + cleaned + '</del></li>'
+      when /^ /
+        '    <li class="unchanged"><span>' + cleaned + '</span></li>'
+      end
+    end
+
+    def wrap_lines(lines)
+      %'<div class="diff">\n  <ul>\n#{lines.join("\n")}\n  </ul>\n</div>\n'
+    end
+
+    def highlighted_words
+      chunks = @diff.each_chunk.to_a
+      processed = []
+      lines = chunks.each_with_index.map do |chunk1, index|
+        next if processed.include? index
+        processed << index
+        chunk1 = chunk1
+        chunk2 = chunks[index + 1]
+        if not chunk2
+          next chunk1
+        end
+
+        chunk1 = ERB::Util.h(chunk1)
+        chunk2 = ERB::Util.h(chunk2)
+
+        dir1 = chunk1.each_char.first
+        dir2 = chunk2.each_char.first
+        case [dir1, dir2]
+        when ['-', '+']
+          line_diff = Diffy::Diff.new(
+            split_characters(chunk1),
+            split_characters(chunk2)
+          )
+          hi1 = reconstruct_characters(line_diff, '-')
+          hi2 = reconstruct_characters(line_diff, '+')
+          processed << (index + 1)
+          [hi1, hi2]
+        else
+          chunk1
+        end
+      end.flatten
+      lines.map{|line| line.each_line.map(&:chomp).to_a if line }.flatten.compact.
+        map{|line|wrap_line(line) }.compact
+    end
+
+    def split_characters(chunk)
+      chunk.gsub(/^./, '').each_line.map do |line|
+        line.chomp.split('') + ['\n']
+      end.flatten.join("\n")
+    end
+
+    def reconstruct_characters(line_diff, type)
+      line_diff.each_chunk.map do |l|
+        re = /(^|\\n)#{Regexp.escape(type)}/
+        case l
+        when re
+          "<strong>" + l.gsub(re, '').gsub("\n", '').
+            gsub('\n', "</strong>\n<strong>") + "</strong>"
+        when /^ /
+          l.gsub(/^./, '').gsub("\n", '').
+            gsub('\r', "\r").gsub('\n', "\n")
+        end
+      end.join('').split("\n").map do |l|
+        type + l
+      end
+    end
+  end
+end

data/spec/dirb_spec.rb

@@ -0,0 +1,277 @@
+require 'spec'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'diffy'))
+
+describe Diffy::Diff do
+
+  describe "diffing two files" do
+    def tempfile(string)
+      t = Tempfile.new('diffy-spec')
+      t.print(string)
+      t.flush
+      t.path
+    end
+
+    it "should accept file paths as arguments" do
+      string1 = "foo\nbar\nbang\n"
+      string2 = "foo\nbang\n"
+      path1, path2 = tempfile(string1), tempfile(string2)
+      Diffy::Diff.new(path1, path2, :source => 'files').to_s.should == <<-DIFF
+ foo
+-bar
+ bang
+      DIFF
+    end
+
+    describe "with no line different" do
+      before do
+        string1 = "foo\nbar\nbang\n"
+        string2 = "foo\nbar\nbang\n"
+        @path1, @path2 = tempfile(string1), tempfile(string2)
+      end
+
+      it "should show everything" do
+        Diffy::Diff.new(@path1, @path2, :source => 'files').to_s.should == <<-DIFF
+ foo
+ bar
+ bang
+        DIFF
+      end
+    end
+  end
+
+  describe "#to_s" do
+    describe "with no line different" do
+      before do
+        @string1 = "foo\nbar\nbang\n"
+        @string2 = "foo\nbar\nbang\n"
+      end
+
+      it "should show everything" do
+        Diffy::Diff.new(@string1, @string2).to_s.should == <<-DIFF
+ foo
+ bar
+ bang
+        DIFF
+      end
+    end
+    describe "with one line different" do
+      before do
+        @string1 = "foo\nbar\nbang\n"
+        @string2 = "foo\nbang\n"
+      end
+
+      it "should show one line removed" do
+        Diffy::Diff.new(@string1, @string2).to_s.should == <<-DIFF
+ foo
+-bar
+ bang
+        DIFF
+      end
+
+      it "to_s should accept a format key" do
+        Diffy::Diff.new(@string1, @string2).to_s(:color).
+          should == " foo\n\e[31m-bar\e[0m\n bang\n"
+      end
+
+      it "should accept a default format option" do
+        old_format = Diffy::Diff.default_format
+        Diffy::Diff.default_format = :color
+        Diffy::Diff.new(@string1, @string2).to_s.
+          should == " foo\n\e[31m-bar\e[0m\n bang\n"
+        Diffy::Diff.default_format = old_format
+      end
+
+      it "should show one line added" do
+        Diffy::Diff.new(@string2, @string1).to_s.should == <<-DIFF
+ foo
++bar
+ bang
+        DIFF
+      end
+    end
+
+    describe "with one line changed" do
+      before do
+        @string1 = "foo\nbar\nbang\n"
+        @string2 = "foo\nbong\nbang\n"
+      end
+      it "should show one line added and one removed" do
+        Diffy::Diff.new(@string1, @string2).to_s.should == <<-DIFF
+ foo
+-bar
++bong
+ bang
+        DIFF
+      end
+    end
+
+    describe "with totally different strings" do
+      before do
+        @string1 = "foo\nbar\nbang\n"
+        @string2 = "one\ntwo\nthree\n"
+      end
+      it "should show one line added and one removed" do
+        Diffy::Diff.new(@string1, @string2).to_s.should == <<-DIFF
+-foo
+-bar
+-bang
++one
++two
++three
+        DIFF
+      end
+    end
+
+    describe "with a somewhat complicated diff" do
+      before do
+        @string1 = "foo\nbar\nbang\nwoot\n"
+        @string2 = "one\ntwo\nthree\nbar\nbang\nbaz\n"
+        @diff = Diffy::Diff.new(@string1, @string2)
+      end
+      it "should show one line added and one removed" do
+        @diff.to_s.should == <<-DIFF
+-foo
++one
++two
++three
+ bar
+ bang
+-woot
++baz
+        DIFF
+      end
+
+      it "should make an awesome simple html diff" do
+        @diff.to_s(:html_simple).should == <<-HTML
+<div class="diff">
+  <ul>
+    <li class="del"><del>foo</del></li>
+    <li class="ins"><ins>one</ins></li>
+    <li class="ins"><ins>two</ins></li>
+    <li class="ins"><ins>three</ins></li>
+    <li class="unchanged"><span>bar</span></li>
+    <li class="unchanged"><span>bang</span></li>
+    <li class="del"><del>woot</del></li>
+    <li class="ins"><ins>baz</ins></li>
+  </ul>
+</div>
+        HTML
+      end
+
+      it "should accept overrides to diff's options" do
+        @diff = Diffy::Diff.new(@string1, @string2, :diff => "--rcs")
+        @diff.to_s.should == <<-DIFF
+d1 1
+a1 3
+one
+two
+three
+d4 1
+a4 1
+baz
+          DIFF
+      end
+    end
+
+    describe "html" do
+
+      it "should highlight the changes within the line" do
+        @string1 = "hahaha\ntime flies like an arrow\nfoo bar\nbang baz\n"
+        @string2 = "hahaha\nfruit flies like a banana\nbang baz\n"
+        @diff = Diffy::Diff.new(@string1, @string2)
+        html = <<-HTML
+<div class="diff">
+  <ul>
+    <li class="unchanged"><span>hahaha</span></li>
+    <li class="del"><del><strong>t</strong>i<strong>me</strong> flies like a<strong>n arrow</strong></del></li>
+    <li class="del"><del><strong>foo</strong> ba<strong>r</strong></del></li>
+    <li class="ins"><ins><strong>fru</strong>i<strong>t</strong> flies like a ba<strong>nana</strong></ins></li>
+    <li class="unchanged"><span>bang baz</span></li>
+  </ul>
+</div>
+        HTML
+        @diff.to_s(:html).should ==  html
+      end
+
+      it "should not duplicate some lines" do
+        @string1 = "hahaha\ntime flies like an arrow\n"
+        @string2 = "hahaha\nfruit flies like a banana\nbang baz"
+        @diff = Diffy::Diff.new(@string1, @string2)
+        html = <<-HTML
+<div class="diff">
+  <ul>
+    <li class="unchanged"><span>hahaha</span></li>
+    <li class="del"><del><strong>t</strong>i<strong>me</strong> flies like an a<strong>rrow</strong></del></li>
+    <li class="ins"><ins><strong>fru</strong>i<strong>t</strong> flies like a<strong> ba</strong>n<strong>ana</strong></ins></li>
+    <li class="ins"><ins><strong>bang</strong> <strong>b</strong>a<strong>z</strong></ins></li>
+  </ul>
+</div>
+        HTML
+        @diff.to_s(:html).should ==  html
+      end
+
+      it "should escape html" do
+        @string1 = "ha<br>haha\ntime flies like an arrow\n"
+        @string2 = "ha<br>haha\nfruit flies like a banana\nbang baz"
+        @diff = Diffy::Diff.new(@string1, @string2)
+        html = <<-HTML
+<div class="diff">
+  <ul>
+    <li class="unchanged"><span>ha&lt;br&gt;haha</span></li>
+    <li class="del"><del><strong>t</strong>i<strong>me</strong> flies like an a<strong>rrow</strong></del></li>
+    <li class="ins"><ins><strong>fru</strong>i<strong>t</strong> flies like a<strong> ba</strong>n<strong>ana</strong></ins></li>
+    <li class="ins"><ins><strong>bang</strong> <strong>b</strong>a<strong>z</strong></ins></li>
+  </ul>
+</div>
+        HTML
+        @diff.to_s(:html).should ==  html
+      end
+
+      it "should highlight the changes within the line with windows style line breaks" do
+        @string1 = "hahaha\r\ntime flies like an arrow\r\nfoo bar\r\nbang baz\n"
+        @string2 = "hahaha\r\nfruit flies like a banana\r\nbang baz\n"
+        @diff = Diffy::Diff.new(@string1, @string2)
+        html = <<-HTML
+<div class="diff">
+  <ul>
+    <li class="unchanged"><span>hahaha</span></li>
+    <li class="del"><del><strong>t</strong>i<strong>me</strong> flies like a<strong>n arrow</strong></del></li>
+    <li class="del"><del><strong>foo</strong> ba<strong>r</strong></del></li>
+    <li class="ins"><ins><strong>fru</strong>i<strong>t</strong> flies like a ba<strong>nana</strong></ins></li>
+    <li class="unchanged"><span>bang baz</span></li>
+  </ul>
+</div>
+        HTML
+        @diff.to_s(:html).should ==  html
+      end
+    end
+
+    it "should escape diffed html in html output" do
+      diff = Diffy::Diff.new("<script>alert('bar')</script>", "<script>alert('foo')</script>").to_s(:html)
+      diff.should include('&lt;script&gt;')
+      diff.should_not include('<script>')
+    end
+
+    it "should be easy to generate custom format" do
+      Diffy::Diff.new("foo\nbar\n", "foo\nbar\nbaz\n").map do |line|
+        case line
+        when /^\+/ then "line #{line.chomp} added"
+        when /^-/ then "line #{line.chomp} removed"
+        end
+      end.compact.join.should == "line +baz added"
+    end
+
+    it "should let you iterate over chunks instead of lines" do
+      Diffy::Diff.new("foo\nbar\n", "foo\nbar\nbaz\n").each_chunk.map do |chunk|
+        chunk
+      end.should == [" foo\n bar\n", "+baz\n"]
+    end
+
+    it "should allow chaining enumerable methods" do
+      Diffy::Diff.new("foo\nbar\n", "foo\nbar\nbaz\n").each.map do |line|
+        line
+      end.should == [" foo\n", " bar\n", "+baz\n"]
+    end
+  end
+end
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: diffy
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 15
   prerelease: false
   segments: 
-  - 1
-  - 1
+  - 2
   - 0
-  version: 1.1.0
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Sam Goldstein
@@ -36,7 +36,11 @@ files:
 - Rakefile
 - VERSION
 - dirb.gemspec
-- spec/diffy_spec.rb
+- lib/diffy.rb
+- lib/diffy/diff.rb
+- lib/diffy/format.rb
+- lib/diffy/html_formatter.rb
+- spec/dirb_spec.rb
 has_rdoc: true
 homepage: http://github.com/samg/diffy/tree/master
 licenses: []
@@ -73,4 +77,4 @@ signing_key:
 specification_version: 3
 summary: A convenient way to diff string in ruby
 test_files: 
-- spec/diffy_spec.rb
+- spec/dirb_spec.rb

data/spec/diffy_spec.rb

@@ -1,155 +0,0 @@
-require 'spec'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'diffy')
-
-describe Diffy::Diff do
-  describe "#to_s" do
-    describe "with no line different" do
-      before do
-        @string1 = "foo\nbar\nbang\n"
-        @string2 = "foo\nbar\nbang\n"
-      end
-
-      it "should show everything" do
-        Diffy::Diff.new(@string1, @string2).to_s.should == <<-DIFF
- foo
- bar
- bang
-        DIFF
-      end
-    end
-    describe "with one line different" do
-      before do
-        @string1 = "foo\nbar\nbang\n"
-        @string2 = "foo\nbang\n"
-      end
-
-      it "should show one line removed" do
-        Diffy::Diff.new(@string1, @string2).to_s.should == <<-DIFF
- foo
--bar
- bang
-        DIFF
-      end
-
-      it "to_s should accept a format key" do
-        Diffy::Diff.new(@string1, @string2).to_s(:color).
-          should == " foo\n\e[31m-bar\e[0m\n bang\n"
-      end
-
-      it "should accept a default format option" do
-        old_format = Diffy::Diff.default_format
-        Diffy::Diff.default_format = :color
-        Diffy::Diff.new(@string1, @string2).to_s.
-          should == " foo\n\e[31m-bar\e[0m\n bang\n"
-        Diffy::Diff.default_format = old_format
-      end
-
-      it "should show one line added" do
-        Diffy::Diff.new(@string2, @string1).to_s.should == <<-DIFF
- foo
-+bar
- bang
-        DIFF
-      end
-    end
-
-    describe "with one line changed" do
-      before do
-        @string1 = "foo\nbar\nbang\n"
-        @string2 = "foo\nbong\nbang\n"
-      end
-      it "should show one line added and one removed" do
-        Diffy::Diff.new(@string1, @string2).to_s.should == <<-DIFF
- foo
--bar
-+bong
- bang
-        DIFF
-      end
-    end
-
-    describe "with totally different strings" do
-      before do
-        @string1 = "foo\nbar\nbang\n"
-        @string2 = "one\ntwo\nthree\n"
-      end
-      it "should show one line added and one removed" do
-        Diffy::Diff.new(@string1, @string2).to_s.should == <<-DIFF
--foo
--bar
--bang
-+one
-+two
-+three
-        DIFF
-      end
-    end
-
-    describe "with a somewhat complicated diff" do
-      before do
-        @string1 = "foo\nbar\nbang\nwoot\n"
-        @string2 = "one\ntwo\nthree\nbar\nbang\nbaz\n"
-        @diff = Diffy::Diff.new(@string1, @string2)
-      end
-      it "should show one line added and one removed" do
-        @diff.to_s.should == <<-DIFF
--foo
-+one
-+two
-+three
- bar
- bang
--woot
-+baz
-        DIFF
-      end
-
-      it "should make an awesome html diff" do
-        @diff.to_s(:html).should == <<-HTML
-<div class="diff">
-  <ul>
-    <li class="del"><del>foo</del></li>
-    <li class="ins"><ins>one</ins></li>
-    <li class="ins"><ins>two</ins></li>
-    <li class="ins"><ins>three</ins></li>
-    <li class="unchanged"><span>bar</span></li>
-    <li class="unchanged"><span>bang</span></li>
-    <li class="del"><del>woot</del></li>
-    <li class="ins"><ins>baz</ins></li>
-  </ul>
-</div>
-        HTML
-      end
-
-      it "should accept overrides to diff's options" do
-        @diff = Diffy::Diff.new(@string1, @string2, "--rcs")
-        @diff.to_s.should == <<-DIFF
-d1 1
-a1 3
-one
-two
-three
-d4 1
-a4 1
-baz
-          DIFF
-      end
-    end
-
-    it "should escape diffed html in html output" do
-      diff = Diffy::Diff.new("<script>alert('bar')</script>", "<script>alert('foo')</script>").to_s(:html)
-      diff.should include('&lt;script&gt;')
-      diff.should_not include('<script>')
-    end
-
-    it "should be easy to generate custom format" do
-      Diffy::Diff.new("foo\nbar\n", "foo\nbar\nbaz\n").map do |line|
-        case line
-        when /^\+/ then "line #{line.chomp} added"
-        when /^-/ then "line #{line.chomp} removed"
-        end
-      end.compact.join.should == "line +baz added"
-    end
-  end
-end
-