dirb 2.0.0 → 2.0.1

data/README

@@ -0,0 +1,3 @@
+This project has been renamed to diffy.
+
+See https://github.com/samg/diffy.

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dirb
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: false
   segments: 
   - 2
   - 0
-  - 0
-  version: 2.0.0
+  - 1
+  version: 2.0.1
 platform: ruby
 authors: 
 - Sam Goldstein
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-20 00:00:00 -08:00
+date: 2010-12-07 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -26,26 +26,24 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- LICENSE
-- README.md
+- README
 files: 
-- .gitignore
-- CHANGELOG
-- LICENSE
-- README.md
-- Rakefile
-- VERSION
-- dirb.gemspec
-- lib/dirb.rb
-- lib/dirb/diff.rb
-- lib/dirb/format.rb
-- lib/dirb/html_formatter.rb
-- spec/dirb_spec.rb
+- README
 has_rdoc: true
-homepage: http://github.com/samg/dirb/tree/master
+homepage: http://github.com/samg/diffy/tree/master
 licenses: []
 
-post_install_message: 
+post_install_message: |
+  ######################################################
+  
+  Hello! The dirb gem has changed it's name to just diffy.  Rather than
+  installing `dirb`, you should install `diffy`.  Please update your
+  dependencies accordingly.
+  
+  Thanks!
+  
+  #######################################################
+
 rdoc_options: 
 - --inline-source
 - --charset=UTF-8
@@ -75,6 +73,6 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: A convenient way to diff string in ruby
-test_files: 
-- spec/dirb_spec.rb
+summary: Renamed to diffy
+test_files: []
+

data/.gitignore

@@ -1,2 +0,0 @@
-*.gem
-*.swp

data/CHANGELOG

@@ -1,5 +0,0 @@
-== 1.0.1 ==
-* Compatibility with ruby 1.8.6 and 1.9
-
-== 1.0.0 ==
-* HTML output and better documentation

data/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2010 Sam Goldstein
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

data/README.md

@@ -1,121 +0,0 @@
-Dirb - Easy Diffing With Ruby
-============================
-
-Need diffs in your ruby app?  Dirb has you covered.  It provides a convenient
-way to generate a diff from two strings.  Instead of reimplementing the LCS diff
-algorithm Dirb uses battle tested Unix diff to generate diffs, and focuses on
-providing a convenient interface, and getting out of your way.
-
-Supported Formats
------------------
-
-It provides several built in format options which can be passed to
-`Dirb::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:
-
-    `Dirb::Diff.default_format = :html`
-
-Getting Started
----------------
-
-    sudo gem install dirb
-
-Here's an example of using Dirb to diff two strings
-
-    $ irb
-    >> string1 = <<-TXT
-    >" Hello how are you
-    >" I'm fine
-    >" That's great
-    >" TXT
-    => "Hello how are you\nI'm fine\nThat's great\n"
-    >> string2 = <<-TXT
-    >" Hello how are you?
-    >" I'm fine
-    >" That's swell
-    >" TXT
-    => "Hello how are you?\nI'm fine\nThat's swell\n"
-    >> puts Dirb::Diff.new(string1, string2)
-    -Hello how are you
-    +Hello how are you?
-     I'm fine
-    -That's great
-    +That's swell
-
-Outputing the diff as html is easy too.
-
-    >> puts Dirb::Diff.new(string1, string2).to_s(:html_simple)
-    <div class="diff">
-      <ul>
-        <li class="del"><del>Hello how are you</del></li>
-        <li class="ins"><ins>Hello how are you?</ins></li>
-        <li class="unchanged"><span>I'm fine</span></li>
-        <li class="del"><del>That's great</del></li>
-        <li class="ins"><ins>That's swell</ins></li>
-      </ul>
-    </div>
-
-Then try adding this css to your stylesheets:
-
-    .diff{overflow:auto;}
-    .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;}
-    .diff del, .diff ins, .diff span{white-space:pre;font-family:courier;}
-    .diff li.ins{background:#9f9;}
-    .diff li.del{background:#fcc;}
-    .diff li.ins strong{font-weight:normal; background: #6f6 }
-    .diff li.del strong{font-weight:normal; background: #f99 }
-
-You can also diff files instead of strings
-
-    >> puts Dirb::Diff.new('/tmp/foo', '/tmp/bar', :source => 'files')
-
-Custom Formats
---------------
-
-Dirb tries to make generating your own custom formatted output easy.
-`Dirb::Diff` provides an enumberable interface which lets you iterate over
-lines in the diff.
-
-    >> Dirb::Diff.new("foo\nbar\n", "foo\nbar\nbaz\n").each do |line|
-    >*   case line
-    >>   when /^\+/ then puts "line #{line.chomp} added"
-    >>   when /^-/ then puts "line #{line.chomp} removed"
-    >>   end
-    >> end
-    line +baz added
-    => [" foo\n", " bar\n", "+baz\n"]
-
-You can also use `Dirb::Diff#each_chunk` to iterate each grouping of additions,
-deletions, and unchanged in a diff.
-
-    >> Dirb::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.
-
-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 Dirb and Ruby 1.8.6 then:
-
-    $ gem install dirb -v1.1.0
-
----------------------------------------------------------------------
-
-Report bugs or request features at http://github.com/samg/Dirb/issues
-

data/Rakefile

@@ -1,39 +0,0 @@
-require 'spec/rake/spectask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-
-task :default => :spec
-
-desc "Run all specs in spec directory"
-Spec::Rake::SpecTask.new(:spec) do |t|
-  t.spec_files = FileList['spec/**/*_spec.rb']
-  t.spec_opts = %w{--color --format profile}
-end
-
-Rake::RDocTask.new do |rd|
-  rd.main = "README"
-  rd.rdoc_dir = 'doc'
-  rd.rdoc_files.include("README", "**/*.rb")
-end
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = %q{dirb}
-
-    s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-    s.authors = ["Sam Goldstein"]
-    s.date = %q{2010-06-28}
-    s.description = %q{Convenient diffing in ruby}
-    s.email = %q{sgrock@gmail.com}
-    s.has_rdoc = true
-    s.homepage = "http://github.com/samg/dirb/tree/master"
-    s.rdoc_options = ["--inline-source", "--charset=UTF-8"]
-    s.require_paths = ["lib"]
-    s.summary = %q{A convenient way to diff string in ruby}
-
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
-

data/VERSION

@@ -1 +0,0 @@
-2.0.0

data/dirb.gemspec

@@ -1,52 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{dirb}
-  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-11-20}
-  s.description = %q{Convenient diffing in ruby}
-  s.email = %q{sgrock@gmail.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.md"
-  ]
-  s.files = [
-    ".gitignore",
-     "CHANGELOG",
-     "LICENSE",
-     "README.md",
-     "Rakefile",
-     "VERSION",
-     "dirb.gemspec",
-     "lib/dirb.rb",
-     "lib/dirb/diff.rb",
-     "lib/dirb/format.rb",
-     "lib/dirb/html_formatter.rb",
-     "spec/dirb_spec.rb"
-  ]
-  s.homepage = %q{http://github.com/samg/dirb/tree/master}
-  s.rdoc_options = ["--inline-source", "--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{A convenient way to diff string in ruby}
-  s.test_files = [
-    "spec/dirb_spec.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
-end
-

data/lib/dirb.rb

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

data/lib/dirb/diff.rb

@@ -1,105 +0,0 @@
-module Dirb
-  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('dirb')
-      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/dirb/format.rb

@@ -1,33 +0,0 @@
-module Dirb
-  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/dirb/html_formatter.rb

@@ -1,90 +0,0 @@
-module Dirb
-  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 = Dirb::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

@@ -1,277 +0,0 @@
-require 'spec'
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'dirb'))
-
-describe Dirb::Diff do
-
-  describe "diffing two files" do
-    def tempfile(string)
-      t = Tempfile.new('dirb-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)
-      Dirb::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
-        Dirb::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
-        Dirb::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
-        Dirb::Diff.new(@string1, @string2).to_s.should == <<-DIFF
- foo
--bar
- bang
-        DIFF
-      end
-
-      it "to_s should accept a format key" do
-        Dirb::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 = Dirb::Diff.default_format
-        Dirb::Diff.default_format = :color
-        Dirb::Diff.new(@string1, @string2).to_s.
-          should == " foo\n\e[31m-bar\e[0m\n bang\n"
-        Dirb::Diff.default_format = old_format
-      end
-
-      it "should show one line added" do
-        Dirb::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
-        Dirb::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
-        Dirb::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 = Dirb::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 = Dirb::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 = Dirb::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 = Dirb::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 = Dirb::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 = Dirb::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 = Dirb::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
-      Dirb::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
-      Dirb::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
-      Dirb::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
-