diff-display 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+diff-display.gemspec
+pkg/*

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-01-28
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2008 Johan Sørensen
+Copyright (c) 2003 Marcel Molina Jr.
+
+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/Manifest.txt

@@ -0,0 +1,26 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/diff-display.rb
+lib/diff-display/version.rb
+log/debug.log
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+spec/diff-display_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/rspec.rake
+tasks/website.rake
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.rhtml

data/README.txt

@@ -0,0 +1,58 @@
+Diff::Display
+=============
+
+Diff::Display::Unified renders unified diffs into various forms. The output is
+based on a callback object that's passed into the renderer
+
+Rewrite of an (unreleased) library by Marcel Molina Jr., who wrote this it 
+probably back in 2004 or so.
+
+Usage
+======
+
+irb(main):001:0> require 'diff-display'
+=> true
+irb(main):002:0> diff = <<EOS
+irb(main):003:0" diff --git a/History.txt b/History.txt
+irb(main):004:0" index 0ed7358..622c384 100644
+irb(main):005:0" --- a/History.txt
+irb(main):006:0" +++ b/History.txt
+irb(main):007:0" @@ -1,4 +1,5 @@
+irb(main):008:0"  == 0.0.1 2008-01-28
+irb(main):009:0"  
+irb(main):010:0" -* 1 major enhancement:
+irb(main):011:0" -  * Initial release
+irb(main):012:0" +* 2 major enhancements:
+irb(main):013:0" +  * The Initial release
+irb(main):014:0" +  * stuff added
+irb(main):015:0" EOS
+...
+irb(main):016:0> diff_display = Diff::Display::Unified.new(diff)
+=> #<Diff::Display::Unified:0x331c9c @data=...
+# Be boring and render it back out as a diff
+irb(main):017:0> puts diff_display.render(Diff::Renderer::Diff.new)
+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
+
+See Diff::Renderer::Base for what methods your callback needs to implement
+
+Git Repository
+===============
+
+http://gitorious.org/projects/diff-display/
+
+
+License
+======
+
+Please see License.txt

data/Rakefile

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake/testtask'
+
+require './lib/diff-display.rb'
+
+task "gemspec" do
+  spec = Gem::Specification.new do |s|
+    s.name            = "diff-display"
+    s.version         = Diff::Display::VERSION::STRING
+    s.platform        = Gem::Platform::RUBY
+    s.summary         = "Diff::Display::Unified renders unified diffs into various forms."
+    
+    s.description     = %Q{Diff::Display::Unified renders unified diffs into various forms. The output is based on a callback object that's passed into the renderer}
+
+    s.files           = `git ls-files`.split("\n") + %w(diff-display.gemspec)
+    s.require_path    = 'lib'
+    s.has_rdoc        = false
+    s.extra_rdoc_files = ['README.txt']
+    s.test_files      = Dir['test/{test,spec}_*.rb']
+    
+    s.authors          = ['Johan Sørensen', 'Ketan Padegaonkar']
+    s.email           = ['johan@johansorensen.com', 'KetanPadegaonkar@gmail.com']
+    s.homepage        = 'http://github.com/ketan/diff-display'
+    
+    s.add_development_dependency 'mocha'
+  end
+
+  File.open("diff-display.gemspec", "w") { |f| f << spec.to_ruby }
+end
+
+task :gem => ["gemspec"] do
+  rm_rf 'pkg'
+  sh "gem build diff-display.gemspec"
+  mkdir 'pkg'
+  mv "diff-display-#{Diff::Display::VERSION::STRING}.gem", "pkg"
+end
+
+task :test do
+  Rake::TestTask.new do |t|
+     t.libs << "test"
+     t.test_files = FileList['test/test_*.rb']
+     t.verbose = true
+   end
+end
+
+task :default => :test

data/lib/diff-display.rb

@@ -0,0 +1,14 @@
+$:.unshift File.dirname(__FILE__)
+
+module Diff
+  module Display
+  end
+end
+
+require "diff/display/version"
+require "diff/display/data_structure"
+require "diff/display/unified"
+require "diff/display/unified/generator"
+
+require "diff/renderer/base"
+require "diff/renderer/diff"

data/lib/diff/display/data_structure.rb

@@ -0,0 +1,193 @@
+module Diff
+  module Display
+    class Data < Array
+      def initialize
+        super
+      end
+      
+      def to_diff
+        diff = ""
+        each do |block|
+          block.each do |line|
+            line_str = line.expand_inline_changes_with(nil, nil)
+            case line
+            when HeaderLine
+              diff << "#{line_str}\n"
+            when UnModLine
+              diff << " #{line_str}\n"
+            when SepLine
+              diff << "\n"
+            when AddLine
+              diff << "+#{line_str}\n"
+            when RemLine
+              diff << "-#{line_str}\n"
+            when NonewlineLine
+              diff << line_str
+            end
+          end
+        end
+        diff.chomp
+      end
+      
+      def debug
+        demodularize = Proc.new {|obj| obj.class.name[/\w+$/]}
+        each do |diff_block|
+          print "-" * 40, ' ', demodularize.call(diff_block)
+          puts
+          puts diff_block.map {|line| 
+            # "%5d" % line.old_number + 
+            "%8s" % "[#{line.old_number || '.'} #{line.new_number || '.'}]" +
+            " [#{demodularize.call(line)}#{'(i)' if line.inline_changes?}]" +
+            line
+          }.join("\n")
+          puts "-" * 40, ' ' 
+        end
+        nil
+      end
+    end
+    
+    # Every line from the passed in diff gets transformed into an instance of
+    # one of line Line class's subclasses. One subclass exists for each line
+    # type in a diff. As such there is an AddLine class for added lines, a RemLine
+    # class for removed lines, an UnModLine class for lines which remain unchanged and
+    # a SepLine class which represents all the lines that aren't part of the diff.
+    class Line < String
+      class << self
+        def add(line, line_number, inline = false)
+          AddLine.new(line, line_number, inline)
+        end
+      
+        def rem(line, line_number, inline = false)
+          RemLine.new(line, line_number, inline)
+        end
+      
+        def unmod(line, old_number, new_number)
+          UnModLine.new(line, old_number, new_number)
+        end
+        
+        def nonewline(line)
+          NonewlineLine.new(line)
+        end
+        
+        def header(line)
+          HeaderLine.new(line)
+        end
+      end
+      
+      def initialize(line, old_number = nil, new_number = nil)
+        super(line)
+        @old_number, @new_number = old_number, new_number
+        @inline = false
+      end
+      attr_reader :old_number, :new_number
+      
+      def identifier
+        self.class.name[/\w+$/].gsub(/Line$/, "").downcase.to_sym
+      end
+      
+      def inline_changes?
+        # Is set in the AddLine+RemLine subclasses
+        @inline
+      end
+      
+      # returns the prefix, middle and postfix parts of a line with inline changes
+      def segments
+        return self.dup unless inline_changes?
+        prefix, changed = self.dup.split('\\0')
+        changed, postfix = changed.split('\\1')
+        [prefix, changed, postfix]
+      end
+      
+      # Expand any inline changes with +prefix+ and +postfix+
+      def expand_inline_changes_with(prefix, postfix)
+        return self.dup unless inline_changes?
+        str = self.dup
+        str.sub!('\\0', prefix.to_s)
+        str.sub!('\\1', postfix.to_s)
+        str
+      end
+      
+      def inspect
+        %Q{#<#{self.class.name} [#{old_number.inspect}-#{new_number.inspect}] "#{self}">}
+      end
+    end
+    
+    # class AddLine < Line
+    #   def initialize(line, line_number)
+    #     super(line, nil, line_number)
+    #   end
+    # end
+    # 
+    # class RemLine < Line
+    #   def initialize(line, line_number)
+    #     super(line, line_number, nil)
+    #   end
+    # end
+    class AddLine < Line
+      def initialize(line, line_number, inline = false)
+        super(line, nil, line_number)
+        @inline = inline
+      end
+    end
+    
+    class RemLine < Line
+      def initialize(line, line_number, inline = false)
+        super(line, line_number, nil)
+        @inline = inline
+      end
+    end
+    
+    class NonewlineLine < Line
+      def initialize(line = '\')
+        super(line)
+      end      
+    end
+    
+    class UnModLine < Line
+      def initialize(line, old_number, new_number)
+        super(line, old_number, new_number)
+      end
+    end
+    
+    class SepLine < Line
+      def initialize(line = '...')
+        super(line)
+      end
+    end
+    
+    class HeaderLine < Line
+      def initialize(line)
+        super(line)
+      end
+    end
+    
+    # This class is an array which contains Line objects. Just like Line
+    # classes, several Block classes inherit from Block. If all the lines
+    # in the block are added lines then it is an AddBlock. If all lines
+    # in the block are removed lines then it is a RemBlock. If the lines
+    # in the block are all unmodified then it is an UnMod block. If the
+    # lines in the block are a mixture of added and removed lines then
+    # it is a ModBlock. There are no blocks that contain a mixture of
+    # modified and unmodified lines.
+    class Block < Array
+      class << self
+        def add;    AddBlock.new    end 
+        def rem;    RemBlock.new    end
+        def mod;    ModBlock.new    end
+        def unmod;  UnModBlock.new  end
+        def header; HeaderBlock.new end
+        def nonewline; NonewlineBlock.new end
+      end
+    end
+
+    #:stopdoc:#
+    class AddBlock    < Block;  end  
+    class RemBlock    < Block;  end
+    class ModBlock    < Block;  end
+    class UnModBlock  < Block;  end
+    class SepBlock    < Block;  end
+    class HeaderBlock < Block;  end
+    class NonewlineBlock < Block; end
+    #:startdoc:#
+  end
+end

data/lib/diff/display/unified.rb

@@ -0,0 +1,15 @@
+module Diff
+  module Display
+    class Unified
+      def initialize(udiff)
+        @data = Diff::Display::Unified::Generator.run(udiff)
+      end
+      attr_reader :data
+      
+      def render(renderer, out="")
+        out << renderer.render(data)
+        out
+      end
+    end
+  end
+end

data/lib/diff/display/unified/generator.rb

@@ -0,0 +1,210 @@
+module Diff::Display
+  # Processes the diff and generates a Data object which contains the
+  # resulting data structure.
+  #
+  # The +run+ class method is fed a diff and returns a Data object. It will
+  # accept as its argument a String, an Array or a File object (or anything 
+  # that responds to #each):
+  #
+  #   Diff::Display::Unified::Generator.run(diff)
+  #
+  class Unified::Generator
+    
+    # Extracts the line number info for a given diff section
+    LINE_NUM_RE = /^@@ [+-]([0-9]+)(?:,([0-9]+))? [+-]([0-9]+)(?:,([0-9]+))? @@/
+    LINE_TYPES  = {'+' => :add, '-' => :rem, ' ' => :unmod, '\\' => :nonewline}
+    
+    # Runs the generator on a diff and returns a Data object
+    def self.run(udiff)
+      raise ArgumentError, "Object must be enumerable" unless udiff.respond_to?(:each_line)
+      generator = new
+      udiff.each_line do |line|
+        begin
+          generator.process(line.chomp)
+        rescue ArgumentError => e
+          e.message =~ /^invalid byte sequence/ ? next : raise(e)
+        end
+      end
+      generator.finish
+      generator.data
+    end
+    
+    def initialize
+      @buffer         = []
+      @line_type      = nil
+      @prev_line_type = nil
+      @offset         = [0, 0]
+      @data = Data.new
+      self
+    end
+    
+    # Finishes up with the generation and returns the Data object (could
+    # probably use a better name...maybe just #data?)
+    def data
+      @data
+    end
+    
+    # This method is called once the generator is done with the unified
+    # diff. It is a finalizer of sorts. By the time it is called all data
+    # has been collected and processed.
+    def finish
+      # certain things could be set now that processing is done
+      #identify_block
+    end
+    
+    def process(line)      
+      if is_header_line?(line)
+        push Block.header
+        current_block << Line.header(line)
+        return
+      end
+      
+      if line =~ LINE_NUM_RE
+        push Block.header
+        current_block << Line.header(line)
+        add_separator unless @offset[0].zero?
+        @line_type = nil
+        @offset    = Array.new(2) { $3.to_i - 1 }
+        return
+      end
+      
+      @line_type, line = LINE_TYPES[car(line)], cdr(line)
+      
+      if @line_type == :add && @prev_line_type == :rem
+        @offset[0] -= 1
+        @buffer.push current_block.pop
+        @buffer.push line
+        process_block(:mod, false)
+        return
+      end
+      
+      if LINE_TYPES.values.include?(@line_type)
+        @buffer.push(line.to_s)
+        process_block(@line_type, true)
+      end
+      
+    end
+    
+    protected
+      def is_header_line?(line)
+        return true if ['+++ ', '--- '].include?(line[0,4])
+        return true if line =~ /^(new|delete) file mode [0-9]+$/
+        return true if line =~ /^diff \-\-git/
+        return true if line =~ /^index \w+\.\.\w+( [0-9]+)?$/i
+        false
+      end
+
+      def process_block(diff_line_type, isnew = false)
+        @data.pop unless isnew
+        push Block.send(diff_line_type)
+        
+        current_line = @buffer.pop
+        return unless current_line
+        
+        # \
+        if diff_line_type == :nonewline
+          current_block << Line.nonewline('\')
+          return
+        end
+        
+        if isnew
+          process_line(current_line, diff_line_type)
+        else
+          process_lines_with_differences(@buffer.shift, current_line)
+          raise "buffer exceeded #{@buffer.inspect}" unless @buffer.empty?
+        end
+      end
+      
+      def process_line(line, type, inline = false)
+        case type
+          when :add
+            @offset[1] += 1
+            current_block << Line.send(type, line, @offset[1], inline)
+          when :rem
+            @offset[0] += 1
+            current_block << Line.send(type, line, @offset[0], inline)
+          # when :rmod
+          #   @offset[0] += 1
+          #   @offset[1] += 1 # TODO: is that really correct?
+          #   current_block << Line.send(@prev_line_type, line, @offset[0])
+          when :unmod
+            @offset[0] += 1
+            @offset[1] += 1
+            current_block << Line.send(type, line, *@offset)
+        end
+        @prev_line_type = type
+      end
+
+      # TODO Needs a better name...it does process a line (two in fact) but
+      # its primary function is to add a Rem and an Add pair which
+      # potentially have inline changes
+      def process_lines_with_differences(oldline, newline)
+        start, ending = get_change_extent(oldline, newline)
+        
+        if start.zero? && ending.zero?
+          process_line(oldline, :rem, false) # -
+          process_line(newline, :add, false) # +
+        else
+          # -
+          line = inline_diff(oldline, start, ending)
+          process_line(line, :rem, true)
+          # +
+          line = inline_diff(newline, start, ending)
+          process_line(line, :add, true)
+        end
+      end
+      
+      # Inserts string formating characters around the section of a string
+      # that differs internally from another line so that the Line class
+      # can insert the desired formating
+      def inline_diff(line, start, ending)
+        if start != 0 || ending != 0
+          last = ending + line.length
+          str = line[0...start] + '\0' + line[start...last] + '\1' + line[last...line.length]
+        end
+        str || line
+      end
+      
+      def add_separator
+        push SepBlock.new 
+        current_block << SepLine.new 
+      end
+
+      def car(line)
+        line[0,1]
+      end
+
+      def cdr(line)
+        line[1..-1]
+      end
+
+      # Returns the current Block object
+      def current_block
+        @data.last
+      end
+
+      # Adds a Line object onto the current Block object 
+      def push(line)
+        @data.push line
+      end
+
+      # Determines the extent of differences between two string. Returns
+      # an array containing the offset at which changes start, and then 
+      # negative offset at which the chnages end. If the two strings have
+      # neither a common prefix nor a common suffic, [0, 0] is returned.
+      def get_change_extent(str1, str2)
+        start = 0
+        limit = [str1.size, str2.size].sort.first
+        while start < limit and str1[start, 1] == str2[start, 1]
+          start += 1
+        end
+        ending = -1
+        limit -= start
+        while -ending <= limit and str1[ending, 1] == str2[ending, 1]
+          ending -= 1
+        end
+
+        return [start, ending + 1]
+      end
+  end
+end