pvande-differ 0.1.1

data/README.rdoc

@@ -0,0 +1,99 @@
+= Differ
+
+    As streams of text swirled before the young man's eyes, his mind swam with
+  thoughts of many things. They would have to wait, however, as he focussed his
+  full concentration on the shifting patterns ahead of him. A glint of light
+  reflecting off a piece of buried code caught his eye and any hope he had was
+  lost. For the very moment he glanced aside, the landscape became Different.
+    The young man gave a small sigh and trudged onward in solemn resignation,
+  fated to wander the desolate codebanks in perpetuity.
+
+Differ is a flexible, pure-Ruby diff library, suitable for use in both command
+line scripts and web applications.  The flexibility comes from the fact that
+diffs can be built at completely arbitrary levels of granularity (some common
+ones are built-in), and can be output in a variety of formats.
+
+== Installation
+
+  sudo gem install pvande-differ --source http://gems.github.com
+
+== Usage
+
+There are a number of ways to use Differ, depending on your situation and needs.
+
+  @original = "Epic lolcat fail!"
+  @current  = "Epic wolfman fail!"
+
+You can call the Differ module directly.
+
+  require 'differ'
+
+There are a number of built-in diff methods to choose from...
+
+  @diff = Differ.diff_by_line(@current, @original)
+    # => "{"Epic lolcat fail!" >> "Epic wolfman fail!"}"
+
+  @diff = Differ.diff_by_word(@current, @original)
+    # => "Epic {"lolcat" >> "wolfman"} fail!"
+
+  @diff = Differ.diff_by_char(@current, @original)
+    # => "Epic {+"wo"}l{-"olcat "}f{+"m"}a{+"n fa"}il!"
+
+... or call #diff directly and supply your own boundary string!
+
+  @diff = Differ.diff(@current, @original)  # implicitly by line!
+    # => "{"Epic lolcat fail!" >> "Epic wolfman fail!"}"
+
+  @diff = Differ.diff(@current, @original, 'i')
+    # => "Epi{"c lolcat fa" >> "c wolfman fa"}il"
+
+If you would like something a little more inline...
+
+  require 'differ/string'
+
+  @diff = @current.diff(@original)  # implicitly by line!
+    # => "{"Epic lolcat fail!" >> "Epic wolfman fail!"}"
+
+... or a lot more inline...
+
+  @diff = (@current - @original)    # implicitly by line!
+    # => "{"Epic lolcat fail!" >> "Epic wolfman fail!"}"
+
+  $; = ' '
+  @diff = (@current - @original)
+    # => "Epic {"lolcat" >> "wolfman"} fail!"
+
+... we've pretty much got you covered.
+
+=== Output Formatting
+
+Need a different output format?  We've got a few of those too.
+
+  Differ.format = :ascii  # <- Default
+  Differ.format = :color
+  Differ.format = :html
+
+  Differ.format = MyCustomFormatModule
+
+Don't want to change the system-wide default for only a single diff output?
+Yeah, me either.
+
+  @diff = (@current - @original)
+  @diff.format_as(:color)
+
+== Copyright
+
+Copyright (c) 2009 Pieter Vande Bruggen.
+
+(The GIFT License, v1)
+
+Permission is hereby granted to use this software and/or its source code for
+whatever purpose you should choose. Seriously, go nuts. Use it for your personal
+RSS feed reader, your wildly profitable social network, or your mission to Mars.
+
+I don't care, it's yours. Change the name on it if you want -- in fact, if you
+start significantly changing what it does, I'd rather you did! Make it your own
+little work of art, complete with a stylish flowing signature in the corner. All
+I really did was give you the canvas.  And my blessing.
+
+  Know always right from wrong, and let others see your good works.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 1
+:major: 0
+:minor: 1

data/lib/differ.rb

@@ -0,0 +1,83 @@
+require 'differ/change'
+require 'differ/diff'
+require 'differ/format/ascii'
+require 'differ/format/color'
+require 'differ/format/html'
+
+module Differ
+  class << self
+
+    def diff(target, source, separator = "\n")
+      old_sep, $; = $;, separator
+
+      target = target.split(separator)
+      source = source.split(separator)
+
+      $; = '' if separator.is_a? Regexp
+
+      @diff = Diff.new
+      advance(target, source) until source.empty? || target.empty?
+      @diff.insert(*target) || @diff.delete(*source)
+      return @diff
+    ensure
+      $; = old_sep
+    end
+
+    def diff_by_char(to, from)
+      diff(to, from, '')
+    end
+
+    def diff_by_word(to, from)
+      diff(to, from, /\b/)
+    end
+
+    def diff_by_line(to, from)
+      diff(to, from, "\n")
+    end
+
+    def format=(f)
+      @format = format_for(f)
+    end
+
+    def format
+      return @format || Format::Ascii
+    end
+
+    def format_for(f)
+      case f
+      when Module then f
+      when :ascii then Format::Ascii
+      when :color then Format::Color
+      when :html  then Format::HTML
+      when nil    then nil
+      else raise "Unknown format type #{f.inspect}"
+      end
+    end
+
+  private
+    def advance(target, source)
+      del, add = source.shift, target.shift
+
+      prioritize_insert = target.length > source.length
+      insert = target.index(del)
+      delete = source.index(add)
+
+      if del == add
+        @diff.same(add)
+      elsif insert && prioritize_insert
+        change(:insert, target.unshift(add), insert)
+      elsif delete
+        change(:delete, source.unshift(del), delete)
+      elsif insert && !prioritize_insert
+        change(:insert, target.unshift(add), insert)
+      else
+        @diff.insert(add) && @diff.delete(del)
+      end
+    end
+
+    def change(method, array, index)
+      @diff.send(method, *array.slice!(0..index))
+      @diff.same(array.shift)
+    end
+  end
+end

data/lib/differ/change.rb

@@ -0,0 +1,30 @@
+module Differ
+  class Change # :nodoc:
+    attr_accessor :insert, :delete
+    def initialize(options = {})
+      @insert = options[:insert] || ''
+      @delete = options[:delete] || ''
+    end
+
+    def insert?
+      !@insert.empty?
+    end
+
+    def delete?
+      !@delete.empty?
+    end
+
+    def change?
+      !@insert.empty? && !@delete.empty?
+    end
+
+    def to_s
+      Differ.format.format(self)
+    end
+    alias :inspect :to_s
+
+    def ==(other)
+      self.insert == other.insert && self.delete == other.delete
+    end
+  end
+end

data/lib/differ/diff.rb

@@ -0,0 +1,95 @@
+module Differ
+  class Diff
+    def initialize
+      @raw = []
+    end
+
+    def same(*str)
+      return if str.empty?
+      if @raw.last.is_a? String
+        @raw.last << sep
+      elsif @raw.last.is_a? Change
+        if @raw.last.change?
+          @raw << sep
+        else
+          change = @raw.pop
+          if change.insert? && @raw.last
+            @raw.last << sep if change.insert.sub!(/^#{Regexp.quote(sep)}/, '')
+          end
+          if change.delete? && @raw.last
+            @raw.last << sep if change.delete.sub!(/^#{Regexp.quote(sep)}/, '')
+          end
+          @raw << change
+
+          @raw.last.insert << sep if @raw.last.insert?
+          @raw.last.delete << sep if @raw.last.delete?
+          @raw << ''
+        end
+      else
+        @raw << ''
+      end
+      @raw.last << str.join(sep)
+    end
+
+    def delete(*str)
+      return if str.empty?
+      if @raw.last.is_a? Change
+        change = @raw.pop
+        if change.insert? && @raw.last
+          @raw.last << sep if change.insert.sub!(/^#{Regexp.quote(sep)}/, '')
+        end
+        change.delete << sep if change.delete?
+      else
+        change = Change.new(:delete => @raw.empty? ? '' : sep)
+      end
+
+      @raw << change
+      @raw.last.delete << str.join(sep)
+    end
+
+    def insert(*str)
+      return if str.empty?
+      if @raw.last.is_a? Change
+        change = @raw.pop
+        if change.delete? && @raw.last
+          @raw.last << sep if change.delete.sub!(/^#{Regexp.quote(sep)}/, '')
+        end
+        change.insert << sep if change.insert?
+      else
+        change = Change.new(:insert => @raw.empty? ? '' : sep)
+      end
+
+      @raw << change
+      @raw.last.insert << str.join(sep)
+    end
+
+    def ==(other)
+      @raw == other.raw_array
+    end
+
+    def to_s
+      @raw.to_s
+    end
+
+    def format_as(f)
+      f = Differ.format_for(f)
+      @raw.inject('') do |sum, part|
+        part = case part
+        when String then part
+        when Change then f.format(part)
+        end
+        sum << part
+      end
+    end
+
+  protected
+    def raw_array
+      @raw
+    end
+
+  private
+    def sep
+      "#{$;}"
+    end
+  end
+end

data/lib/differ/format/ascii.rb

@@ -0,0 +1,27 @@
+module Differ
+  module Format
+    module Ascii
+      class << self
+        def format(change)
+          (change.change? && as_change(change)) ||
+          (change.delete? && as_delete(change)) ||
+          (change.insert? && as_insert(change)) ||
+          ''
+        end
+
+      private
+        def as_insert(change)
+          "{+#{change.insert.inspect}}"
+        end
+
+        def as_delete(change)
+          "{-#{change.delete.inspect}}"
+        end
+
+        def as_change(change)
+          "{#{change.delete.inspect} >> #{change.insert.inspect}}"
+        end
+      end
+    end
+  end
+end

data/lib/differ/format/color.rb

@@ -0,0 +1,27 @@
+module Differ
+  module Format
+    module Color
+      class << self
+        def format(change)
+          (change.change? && as_change(change)) ||
+          (change.delete? && as_delete(change)) ||
+          (change.insert? && as_insert(change)) ||
+          ''
+        end
+
+      private
+        def as_insert(change)
+          "\033[32m#{change.insert}\033[0m"
+        end
+
+        def as_delete(change)
+          "\033[31m#{change.delete}\033[0m"
+        end
+
+        def as_change(change)
+          as_delete(change) << as_insert(change)
+        end
+      end
+    end
+  end
+end

data/lib/differ/format/html.rb

@@ -0,0 +1,27 @@
+module Differ
+  module Format
+    module HTML
+      class << self
+        def format(change)
+          (change.change? && as_change(change)) ||
+          (change.delete? && as_delete(change)) ||
+          (change.insert? && as_insert(change)) ||
+          ''
+        end
+
+      private
+        def as_insert(change)
+          %Q{<ins class="differ">#{change.insert}</ins>}
+        end
+
+        def as_delete(change)
+          %Q{<del class="differ">#{change.delete}</del>}
+        end
+
+        def as_change(change)
+          as_delete(change) << as_insert(change)
+        end
+      end
+    end
+  end
+end

data/lib/differ/string.rb

@@ -0,0 +1,12 @@
+module Differ
+  module StringDiffer
+    def diff(old)
+      Differ.diff(self, old, $; || "\n")
+    end
+    alias :- :diff
+  end
+end
+
+String.class_eval do
+  include Differ::StringDiffer
+end

data/spec/differ/change_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Differ::Change do
+  before(:each) do
+    @format = Module.new { def self.format(c); end }
+    Differ.format = @format
+  end
+
+  describe '(empty)' do
+    before(:each) do
+      @change = Differ::Change.new()
+    end
+
+    it 'should have a default insert' do
+      @change.insert.should == ''
+    end
+
+    it 'should have a default delete' do
+      @change.delete.should == ''
+    end
+
+    it 'should stringify to ""' do
+      @format.should_receive(:format).once.and_return('')
+      @change.to_s.should == ''
+    end
+  end
+
+  describe '(insert only)' do
+    before(:each) do
+      @change = Differ::Change.new(:insert => 'foo')
+    end
+
+    it 'should populate the :insert parameter' do
+      @change.insert.should == 'foo'
+    end
+
+    it 'should have a default delete' do
+      @change.delete.should == ''
+    end
+
+    it { (@change).should be_an_insert }
+  end
+
+  describe '(delete only)' do
+    before(:each) do
+      @change = Differ::Change.new(:delete => 'bar')
+    end
+
+    it 'should have a default :insert' do
+      @change.insert.should == ''
+    end
+
+    it 'should populate the :delete parameter' do
+      @change.delete.should == 'bar'
+    end
+
+    it { (@change).should be_a_delete }
+  end
+
+  describe '(both insert and delete)' do
+    before(:each) do
+      @change = Differ::Change.new(:insert => 'foo', :delete => 'bar')
+    end
+
+    it 'should populate the :insert parameter' do
+      @change.insert.should == 'foo'
+    end
+
+    it 'should populate the :delete parameter' do
+      @change.delete.should == 'bar'
+    end
+
+    it { (@change).should be_an_insert }
+    it { (@change).should be_a_delete }
+    it { (@change).should be_a_change }
+  end
+
+  it "should stringify via the current format's #format method" do
+    @format.should_receive(:format).once
+    Differ::Change.new.to_s
+  end
+end