ydiffy 0.0.2

data/lib/diffy.rb

@@ -0,0 +1,13 @@
+require 'tempfile'
+require 'erb'
+require 'rbconfig'
+
+module Diffy
+  WINDOWS = (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+end
+require 'open3' unless Diffy::WINDOWS
+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')
+require File.join(File.dirname(__FILE__), 'diffy', 'split_diff')
+require File.join(File.dirname(__FILE__), 'diffy', 'css')

data/lib/diffy/css.rb

@@ -0,0 +1,34 @@
+module Diffy
+  CSS = <<-STYLE
+.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;height:1em;}
+.diff li.ins{background:#dfd; color:#080}
+.diff li.del{background:#fee; color:#b00}
+.diff li:hover{background:#ffc}
+/* 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 del strong{font-weight:normal;background:#fcc;}
+.diff ins strong{font-weight:normal;background:#9f9;}
+.diff li.diff-comment { display: none; }
+.diff li.diff-block-info { background: none repeat scroll 0 0 gray; }
+  STYLE
+
+  CSS_COLORBLIND_1 = <<-STYLE
+.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;height:1em;}
+.diff li.ins{background:#ddf; color:#008}
+.diff li.del{background:#fee; color:#b00}
+.diff li:hover{background:#ffc}
+/* 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 del strong{font-weight:normal;background:#fcc;}
+.diff ins strong{font-weight:normal;background:#99f;}
+.diff li.diff-comment { display: none; }
+.diff li.diff-block-info { background: none repeat scroll 0 0 gray; }
+  STYLE
+
+end

data/lib/diffy/diff.rb

@@ -0,0 +1,171 @@
+module Diffy
+  class Diff
+    ORIGINAL_DEFAULT_OPTIONS = {
+      :diff => '-U 10000',
+      :source => 'strings',
+      :include_diff_info => false,
+      :include_plus_and_minus_in_html => false,
+      :context => nil,
+      :allow_empty_diff => true,
+    }
+
+    class << self
+      attr_writer :default_format
+      def default_format
+        @default_format ||= :text
+      end
+
+      # default options passed to new Diff objects
+      attr_writer :default_options
+      def default_options
+        @default_options ||= ORIGINAL_DEFAULT_OPTIONS.dup
+      end
+
+    end
+    include Enumerable
+    attr_reader :string1, :string2, :options
+
+    # 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.
+    # +:include_diff_info+::    Include diff header info
+    # +:include_plus_and_minus_in_html+::    Show the +, -, ' ' at the
+    #                                        beginning of lines in html output.
+    def initialize(string1, string2, options = {})
+      @options = self.class.default_options.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
+
+        if WINDOWS
+          # don't use open3 on windows
+          cmd = sprintf '"%s" %s %s', diff_bin, diff_options.join(' '), paths.map { |s| %("#{s}") }.join(' ')
+          diff = `#{cmd}`
+        else
+          diff = Open3.popen3(diff_bin, *(diff_options + paths)) { |i, o, e| o.read }
+        end
+        diff.force_encoding('ASCII-8BIT') if diff.respond_to?(:valid_encoding?) && !diff.valid_encoding?
+        if diff =~ /\A\s*\Z/ && !options[:allow_empty_diff]
+          diff = case options[:source]
+          when 'strings' then string1
+          when 'files' then File.read(string1)
+          end.gsub(/^/, " ")
+        end
+        diff
+      end
+    ensure
+      # unlink the tempfiles explicitly now that the diff is generated
+      if defined? @tempfiles # to avoid Ruby warnings about undefined ins var.
+        Array(@tempfiles).each do |t|
+          begin
+            # check that the path is not nil and file still exists.
+            # REE seems to be very agressive with when it magically removes
+            # tempfiles
+            t.unlink if t.path && File.exist?(t.path)
+          rescue => e
+            warn "#{e.class}: #{e}"
+            warn e.backtrace.join("\n")
+          end
+        end
+        @tempfiles = []
+      end
+    end
+
+    def each
+      lines = case @options[:include_diff_info]
+      when false then diff.split("\n").reject{|x| x =~ /^(---|\+\+\+|@@|\\\\)/ }.map {|line| line + "\n" }
+      when true then diff.split("\n").map {|line| line + "\n" }
+      end
+      if block_given?
+        lines.each{|line| yield line}
+      else
+        lines.to_enum
+      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
+        chunks.to_enum
+      end
+    end
+
+    def tempfile(string)
+      t = Tempfile.new('diffy')
+      # ensure tempfiles aren't unlinked when GC runs by maintaining a
+      # reference to them.
+      @tempfiles ||=[]
+      @tempfiles.push(t)
+      t.print(string)
+      t.flush
+      t.close
+      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
+
+    @@bin = nil
+    def diff_bin
+      return @@bin if @@bin
+
+      if @@bin = ENV['DIFFY_DIFF']
+        # system() trick from Minitest
+        raise "Can't execute diff program '#@@bin'" unless system(@@bin, __FILE__, __FILE__)
+        return @@bin
+      end
+
+      diffs = ['diff', 'ldiff']
+      diffs.first << '.exe' if WINDOWS  # ldiff does not have exe extension
+      @@bin = diffs.find { |name| system(name, __FILE__, __FILE__) }
+
+      if @@bin.nil?
+        raise "Can't find a diff executable in PATH #{ENV['PATH']}"
+      end
+
+      @@bin
+    end
+
+    # options pass to diff program
+    def diff_options
+      Array(options[:context] ? "-U #{options[:context]}" : options[:diff])
+    end
+
+  end
+end

data/lib/diffy/format.rb

@@ -0,0 +1,37 @@
+module Diffy
+  module Format
+    # ANSI color output suitable for terminal output
+    def color
+      map do |line|
+        case line
+        when /^(---|\+\+\+|\\\\)/
+          "\033[90m#{line.chomp}\033[0m"
+        when /^\+/
+          "\033[32m#{line.chomp}\033[0m"
+        when /^-/
+          "\033[31m#{line.chomp}\033[0m"
+        when /^@@/
+          "\033[36m#{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, options).to_s
+    end
+
+    # Html output which does inline highlighting of changes between two lines.
+    def html
+      HtmlFormatter.new(self, options.merge(:highlight_words => true)).to_s
+    end
+  end
+end

data/lib/diffy/html_formatter.rb

@@ -0,0 +1,135 @@
+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 = clean_line(line)
+      case line
+      when /^(---|\+\+\+|\\\\)/
+        '    <li class="diff-comment"><span>' + line.chomp + '</span></li>'
+      when /^\+/
+        '    <li class="ins"><ins>' + cleaned + '</ins></li>'
+      when /^-/
+        '    <li class="del"><del>' + cleaned + '</del></li>'
+      when /^ /
+        '    <li class="unchanged"><span>' + cleaned + '</span></li>'
+      when /^@@/
+        '    <li class="diff-block-info"><span>' + line.chomp + '</span></li>'
+      end
+    end
+
+    # remove +/- or wrap in html
+    def clean_line(line)
+      if @options[:include_plus_and_minus_in_html]
+        line.sub(/^(.)/, '<span class="symbol">\1</span>')
+      else
+        line.sub(/^./, '')
+      end.chomp
+    end
+
+    def wrap_lines(lines)
+      if lines.empty?
+        %'<div class="diff"></div>'
+      else
+        %'<div class="diff">\n  <ul>\n#{lines.join("\n")}\n  </ul>\n</div>\n'
+      end
+    end
+
+    def highlighted_words
+      chunks = @diff.each_chunk.
+        reject{|c| c == ''"\n"}
+
+      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 ERB::Util.h(chunk1)
+        end
+
+        dir1 = chunk1.each_char.first
+        dir2 = chunk2.each_char.first
+        case [dir1, dir2]
+        when ['-', '+']
+          if chunk1.each_char.take(3).join("") =~ /^(---|\+\+\+|\\\\)/ and
+              chunk2.each_char.take(3).join("") =~ /^(---|\+\+\+|\\\\)/
+            ERB::Util.h(chunk1)
+          else
+            line_diff = Diffy::Diff.new(
+                                        split_characters(chunk1),
+                                        split_characters(chunk2),
+                                        Diffy::Diff::ORIGINAL_DEFAULT_OPTIONS
+                                        )
+            hi1 = reconstruct_characters(line_diff, '-')
+            hi2 = reconstruct_characters(line_diff, '+')
+            processed << (index + 1)
+            [hi1, hi2]
+          end
+        else
+          ERB::Util.h(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|
+        chars = line.sub(/([\r\n]$)/, '').split('')
+        # add escaped newlines
+        chars << '\n'
+        chars.map{|chr| ERB::Util.h(chr) }
+      end.flatten.join("\n") + "\n"
+    end
+
+    def reconstruct_characters(line_diff, type)
+      enum = line_diff.each_chunk.to_a
+      enum.each_with_index.map do |l, i|
+        re = /(^|\\n)#{Regexp.escape(type)}/
+        case l
+        when re
+          highlight(l)
+        when /^ /
+          if i > 1 and enum[i+1] and l.each_line.to_a.size < 4
+            highlight(l)
+          else
+            l.gsub(/^./, '').gsub("\n", '').
+              gsub('\r', "\r").gsub('\n', "\n")
+          end
+        end
+      end.join('').split("\n").map do |l|
+        type + l.gsub('</strong><strong>' , '')
+      end
+    end
+
+    def highlight(lines)
+      "<strong>" +
+        lines.
+          # strip diff tokens (e.g. +,-,etc.)
+          gsub(/(^|\\n)./, '').
+          # mark line boundaries from higher level line diff
+          # html is all escaped so using brackets should make this safe.
+          gsub('\n', '<LINE_BOUNDARY>').
+          # join characters back by stripping out newlines
+          gsub("\n", '').
+          # close and reopen strong tags.  we don't want inline elements
+          # spanning block elements which get added later.
+          gsub('<LINE_BOUNDARY>',"</strong>\n<strong>") + "</strong>"
+    end
+  end
+end

data/lib/diffy/split_diff.rb

@@ -0,0 +1,49 @@
+module Diffy
+  class SplitDiff
+    def initialize(left, right, options = {})
+      @format = options[:format] || Diffy::Diff.default_format
+
+      formats = Format.instance_methods(false).map { |x| x.to_s }
+      unless formats.include?(@format.to_s)
+        fail ArgumentError, "Format #{format.inspect} is not a valid format"
+      end
+
+      @diff = Diffy::Diff.new(left, right, options).to_s(@format)
+      @left_diff, @right_diff = split
+    end
+
+    %w(left right).each do |direction|
+      define_method direction do
+        instance_variable_get("@#{direction}_diff")
+      end
+    end
+
+    private
+
+    def split
+      [split_left, split_right]
+    end
+
+    def split_left
+      case @format
+      when :color
+        @diff.gsub(/\033\[32m\+(.*)\033\[0m\n/, '')
+      when :html, :html_simple
+        @diff.gsub(%r{\s+<li class="ins"><ins>(.*)</ins></li>}, '')
+      when :text
+        @diff.gsub(/^\+(.*)\n/, '')
+      end
+    end
+
+    def split_right
+      case @format
+      when :color
+        @diff.gsub(/\033\[31m\-(.*)\033\[0m\n/, '')
+      when :html, :html_simple
+        @diff.gsub(%r{\s+<li class="del"><del>(.*)</del></li>}, '')
+      when :text
+        @diff.gsub(/^-(.*)\n/, '')
+      end
+    end
+  end
+end

data/lib/diffy/version.rb

@@ -0,0 +1,3 @@
+module Diffy
+  VERSION = '0.0.2'
+end