Fingertips-revision_san 0.1.0

data/README.rdoc

@@ -0,0 +1,29 @@
+= RevisionSan
+
+A simple Rails plugin which creates revisions of your model and comes with an equally simple HTML differ.
+
+== Install
+
+* As a gem:
+    $ sudo gem install Fingertips-revision_san -s http://gems.github.com
+
+* Vendor:
+    $ cd vendor/plugins && git clone git@github.com:Fingertips/revision_san.git
+
+== Usage
+
+Include the RevisionSan module into the model for which you'd like to keep
+revisions.
+
+  class Artist < ActiveRecord::Base
+    include RevisionSan
+  end
+
+And create a migration to add the columns needed by RevisionSan to your model:
+
+  add_column :artists, :revision,           :default => 1
+  add_column :artists, :revision_parent_id, :default => nil
+  
+  add_index  :artists, :revision_parent_id
+
+Copyright © 2008 Fingertips, Eloy Duran <eloy@fngtps.com>, released under the MIT license

data/VERSION.yml

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

data/lib/revision_san.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../revision_san/diff', __FILE__)
+
+module RevisionSan
+  def self.included(klass)
+    klass.class_eval do
+      before_update :create_new_revision
+      named_scope :current_revisions, { :conditions => { :revision_parent_id => nil } }
+      klass.extend ClassMethods
+    end
+  end
+  
+  module ClassMethods
+    def find_with_current_revisions(*args)
+      current_revisions.find_without_current_revisions(*args)
+    end
+    
+    def count_with_current_revisions(*args)
+      current_revisions.count_without_current_revisions(*args)
+    end
+    
+    def self.extended(klass)
+      class << klass
+        alias_method_chain :find, :current_revisions
+        alias_method_chain :count, :current_revisions
+      end
+    end
+  end
+  
+  def revisions
+    self.class.find_without_current_revisions(:all, :conditions => { :revision_parent_id => id }, :order => 'id ASC') + [self]
+  end
+  
+  def fetch_revision(revision)
+    revision = revision.to_i
+    return self if self.revision == revision
+    sub_query = revision_parent_id.blank? ? "revision_parent_id = #{id}" : "(id = #{revision_parent_id} OR revision_parent_id = #{revision_parent_id})"
+    self.class.find_without_current_revisions :first, :conditions => "#{sub_query} AND revision = #{revision}"
+  end
+  
+  def create_new_revision
+    if changed?
+      record = self.class.new(:revision_parent_id => id)
+      attributes.except('id', 'revision_parent_id').each do |key, value|
+        record.write_attribute(key, changes.has_key?(key) ? changes[key].first : value)
+      end
+      record.save(false)
+      self.revision += 1
+    end
+  end
+end

data/lib/revision_san/diff.rb

@@ -0,0 +1,101 @@
+require 'diff/lcs'
+
+module RevisionSan
+  # Return a RevisionSan::Diff object which compares this revision to the specified revision.
+  #
+  #   artist = Artist.create(:name => 'van Gogh')
+  #   artist.update_attribute(:name => 'Vincent van Gogh')
+  #
+  #   revision_1 = artist.fetch_revision(1)
+  #   diff = revision_1.compare_against_revision(2)
+  #   diff.name # => '<ins>Vincent </ins>van Gogh'
+  def compare_against_revision(revision)
+    Diff.new(self, fetch_revision(revision))
+  end
+  
+  class Diff
+    attr_reader :from, :to
+    
+    def initialize(from, to)
+      @from, @to = from, to
+    end
+    
+    def diff_for_column(column)
+      from_lines, to_lines = [@from.send(column), @to.send(column)].map do |res|
+        text = res.blank? ? '' : res.to_s
+        text = yield(text) if block_given?
+        text.scan(/\n+|.+/)
+      end
+      SimpleHTMLFormatter.diff(from_lines, to_lines)
+    end
+    
+    def method_missing(method, *args, &block)
+      if @from.respond_to?(method) || @from.class.column_names.include?(method.to_s)
+        define_and_call_singleton_method(method, &block)
+      else
+        super
+      end
+    end
+    
+    def define_and_call_singleton_method(method, &block)
+      instance_eval %{
+        def #{method}(&block)
+          diff_for_column('#{method}', &block)
+        end
+        
+        #{method}(&block)
+      }
+    end
+    
+    module SimpleHTMLFormatter
+      def self.diff(from_lines, to_lines)
+        LineDiffHTMLFormatter.new(from_lines, to_lines).output
+      end
+      
+      class LineDiffHTMLFormatter
+        def output
+          @output.join.gsub(%r{</ins><ins>|</del><del>|<del></del>}, '')
+        end
+        
+        def initialize(from, to)
+          @output = []
+          @went_deep = false
+          ::Diff::LCS.traverse_sequences(from, to, self)
+        end
+        
+        def discard_a(change)
+          from_words, to_words = [change.old_element, change.new_element].map { |text| text.to_s.scan(/\w+|\W|\s/) }
+          changes = ::Diff::LCS.diff(from_words, to_words).length
+          if changes > 1 && changes > (from_words.length / 5)
+            @output << "<del>#{change.old_element}</del>"
+          else
+            @output << WordDiffHTMLFormatter.new(from_words, to_words).output
+            @went_deep = true
+          end
+        end
+        
+        def discard_b(change)
+          if @went_deep
+            @went_deep = false
+          else
+            @output << "<ins>#{change.new_element}</ins>"
+          end
+        end
+        
+        def match(match)
+          @output << match.new_element
+        end
+      end
+      
+      class WordDiffHTMLFormatter < LineDiffHTMLFormatter
+        def output
+          @output.join
+        end
+        
+        def discard_a(change)
+          @output << "<del>#{change.old_element}</del>"
+        end
+      end
+    end
+  end
+end

data/test/diff_test.rb

@@ -0,0 +1,123 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class DiffTestEntity
+  def self.column_names
+    ["text"]
+  end
+  
+  attr_accessor :text
+  
+  def initialize(text)
+    @text = text
+  end
+end
+
+describe "RevisionSan::Diff" do
+  it "should return correctly formatted html" do
+    [
+      [long_text[:before], long_text[:after], long_text[:diff]],
+      [nil, "First words.", "<ins>First words.</ins>"],
+      ["First words.", nil, "<del>First words.</del>"],
+      ["No changes.", "No changes.", "No changes."],
+      ["Bla", "Foo", "<del>Bla</del><ins>Foo</ins>"],
+      ["Bar!", "Baz!", "<del>Bar</del><ins>Baz</ins>!"],
+      ["Begin\n\nEnd", "Begin\n\nMiddle\n\nEnd", "Begin\n\n<ins>Middle\n\n</ins>End"],
+      ["Multiple added.", "Multiple words are added.", "Multiple <ins>words are </ins>added."],
+      ["Multiple words are removed.", "Multiple removed.", "Multiple <del>words are </del>removed."]
+    ].each do |from, to, html|
+      diff_html(from, to).should == html
+    end
+  end
+  
+  def long_text
+    {
+      :before => %{Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Fusce gravida. Ut orci orci, molestie et, scelerisque ut, faucibus pharetra, enim. Morbi vehicula consequat nunc. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Quisque ac orci. Proin adipiscing tempor erat. Phasellus gravida tincidunt sapien. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. In venenatis libero sit amet quam. Nam sapien diam, tempor placerat, feugiat quis, congue in, elit. Vivamus nec enim eget elit posuere tincidunt. Quisque scelerisque lobortis risus. Quisque cursus dolor sit amet arcu.
+
+Suspendisse auctor. Quisque sodales dapibus pede. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Cras blandit tellus id libero. Morbi sed purus sed sapien ornare facilisis. Vestibulum rutrum egestas mauris. Vestibulum luctus velit vitae ante. In dictum, metus sed lacinia sagittis, leo diam elementum tortor, rutrum elementum justo tellus eget risus. Curabitur faucibus mauris eget nisi. Nam mattis nunc eget turpis. In porta. Aliquam risus ante, sodales quis, consequat vitae, fermentum ut, nisi. Etiam congue ipsum id ante aliquet dictum.},
+      
+      :after => %{Landscape architecture involves the investigation and designed response to the landscape. The scope of the profession includes architectural design, site planning, environmental restoration, town or urban planning, urban design, parks and recreation planning. A practitioner in the field of landscape architecture is called a landscape architect.
+
+Suspendisse auctor. Quisque sodales dapibus pede. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Cras blandit tellus id libero. Morbi sed purus sed sapien ornare facilisis. Vestibulum rutrum egestas mauris. Vestibulum luctus velit vitae ante. In dictum, metus sed lacinia sagittis, leo diam elementum tortor, rutrum elementum justo tellus eget risus. Curabitur faucibus mauris eget nisi. Nam mattis nunc eget turpis. In porta. Aliquam risus ante, sodales quis, consequat vitae, fermentum ut, nisi. Etiam congue ipsum id ante aliquet dictum.},
+      
+      :diff => %{<del>Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Fusce gravida. Ut orci orci, molestie et, scelerisque ut, faucibus pharetra, enim. Morbi vehicula consequat nunc. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Quisque ac orci. Proin adipiscing tempor erat. Phasellus gravida tincidunt sapien. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. In venenatis libero sit amet quam. Nam sapien diam, tempor placerat, feugiat quis, congue in, elit. Vivamus nec enim eget elit posuere tincidunt. Quisque scelerisque lobortis risus. Quisque cursus dolor sit amet arcu.</del><ins>Landscape architecture involves the investigation and designed response to the landscape. The scope of the profession includes architectural design, site planning, environmental restoration, town or urban planning, urban design, parks and recreation planning. A practitioner in the field of landscape architecture is called a landscape architect.</ins>
+
+Suspendisse auctor. Quisque sodales dapibus pede. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Cras blandit tellus id libero. Morbi sed purus sed sapien ornare facilisis. Vestibulum rutrum egestas mauris. Vestibulum luctus velit vitae ante. In dictum, metus sed lacinia sagittis, leo diam elementum tortor, rutrum elementum justo tellus eget risus. Curabitur faucibus mauris eget nisi. Nam mattis nunc eget turpis. In porta. Aliquam risus ante, sodales quis, consequat vitae, fermentum ut, nisi. Etiam congue ipsum id ante aliquet dictum.}
+    }
+  end
+  
+  private
+  
+  def diff_html(from, to)
+    RevisionSan::Diff.new(DiffTestEntity.new(from), DiffTestEntity.new(to)).text
+  end
+end
+
+class Artist
+  def real_method
+    obj = Object.new
+    def obj.to_s
+      'Real method'
+    end
+    obj
+  end
+end
+
+describe "RevisionSan, looking at diff methods" do
+  before do
+    RevisionSanTest::Initializer.setup_database
+    
+    @artist_rev_2 = Artist.create(:name => 'van Gogh', :bio => 'He painted a lot.')
+    @artist_rev_2.update_attributes(:name => 'Vincent van Gogh', :bio => 'He occasionally drew a lot.')
+    @artist_rev_1 = @artist_rev_2.revisions.first
+    
+    @diff = @artist_rev_1.compare_against_revision(2)
+  end
+  
+  after do
+    RevisionSanTest::Initializer.teardown_database
+  end
+  
+  it "should take an older revision number to compare against" do
+    @artist_rev_2.compare_against_revision(1).should.be.instance_of RevisionSan::Diff
+  end
+  
+  it "should have instantiated a RevisionSan::Diff object with the correct revisions" do
+    @diff.from.should == @artist_rev_1
+    @diff.to.should == @artist_rev_2
+  end
+  
+  it "should lazy define accessors for requested columns" do
+    @diff.name
+    @diff.bio
+    
+    @diff.should.respond_to :name
+    @diff.should.respond_to :bio
+  end
+  
+  it "should also work with real existing methods instead of a column" do
+    @diff.real_method
+    @diff.should.respond_to :real_method
+  end
+  
+  it "should coerce the value to a string before trying to diff them" do
+    @diff.real_method.should == 'Real method'
+  end
+  
+  it "should yield the from and to strings, if a block is given, so the user can adjust the text before diffing" do
+    @diff.real_method { |text| text.reverse }.should == 'dohtem laeR'
+  end
+  
+  it "should only define the accessors on the singleton, not the class" do
+    @diff.name
+    RevisionSan::Diff.instance_methods.should.not.include 'name'
+  end
+  
+  it "should still raise a NoMethodError for column names that don't exist" do
+    lambda { @diff.foo }.should.raise NoMethodError
+  end
+  
+  it "should return html with the diff for a requested column" do
+    @diff.name.should == "<ins>Vincent </ins>van Gogh"
+    @diff.bio.should  == "He <del>painted</del><ins>occasionally drew</ins> a lot."
+  end
+end

data/test/revision_san_test.rb

@@ -0,0 +1,116 @@
+require File.expand_path('../test_helper', __FILE__)
+
+require 'active_support/testing/core_ext/test/unit/assertions'
+
+describe "RevisionSan, looking at model methods" do
+  before do
+    RevisionSanTest::Initializer.setup_database
+    
+    @artist = Artist.create(:name => 'van Gogh', :bio => 'He painted a lot.')
+    @artist.update_attributes(:name => 'Vincent van Gogh', :bio => 'He painted a lot of nice paintings.')
+    @artist.update_attributes(:name => 'Vincent van Gogh JR', :bio => 'Was never born.')
+  end
+  
+  after do
+    RevisionSanTest::Initializer.teardown_database
+  end
+  
+  it "should only return current revisions when using ::find" do
+    Artist.find(:all).should == [@artist]
+  end
+  
+  it "should return all revisions" do
+    revs = @artist.revisions
+    revs.length.should == 3
+    revs[0].should == Artist.find_without_current_revisions(:first, :conditions => { :revision => 1 })
+    revs[1].should == Artist.find_without_current_revisions(:first, :conditions => { :revision => 2 })
+    revs[2].should == Artist.find_without_current_revisions(:first, :conditions => { :revision => 3 })
+  end
+  
+  it "should return a specific revision" do
+    @artist.fetch_revision(1).should == @artist.revisions[0]
+    @artist.fetch_revision(2).should == @artist.revisions[1]
+    @artist.fetch_revision(3).should == @artist
+    
+    @artist.fetch_revision('1').should == @artist.revisions[0]
+    @artist.fetch_revision('2').should == @artist.revisions[1]
+    @artist.fetch_revision('3').should == @artist
+  end
+  
+  it "should also be able to return a specific revision from an older revision" do
+    @artist.fetch_revision(1).fetch_revision(2).fetch_revision(3).should == @artist
+  end
+  
+  it "should convert a requested revision to an integer before using in the conditions" do
+    @artist.fetch_revision('some evil sql that will be coerced to 0').should.be nil
+  end
+end
+
+describe "RevisionSan, when updating a record" do
+  before do
+    RevisionSanTest::Initializer.setup_database
+    
+    @artist = Artist.create(:name => 'van Gogh', :bio => 'He painted a lot.')
+    @artist.update_attributes(:name => 'Vincent van Gogh', :bio => 'He painted a lot of nice paintings.')
+  end
+  
+  after do
+    RevisionSanTest::Initializer.teardown_database
+  end
+  
+  it "should insert a new revision of a record" do
+    assert_difference('Artist.count_without_current_revisions', +1) do
+      @artist.update_attributes(:name => 'Vincent van Gogh JR', :bio => 'Was never born.')
+    end
+  end
+  
+  it "should add the original attributes to the new revision record" do
+    @artist.revisions.first.name.should == 'van Gogh'
+    @artist.revisions.first.bio.should == 'He painted a lot.'
+  end
+  
+  it "should not take over the created_at value" do
+    created_at_before = @artist.created_at
+    sleep 1
+    @artist.update_attribute(:name, 'Gogh')
+    
+    @artist.revisions.first.created_at.should.not == created_at_before
+  end
+  
+  it "should not create a new revision record if no attributes were changed" do
+    assert_no_difference('Artist.count') do
+      @artist.update_attributes({})
+    end
+  end
+  
+  it "should not create a new revision if validation fails on the original record" do
+    assert_no_difference('@artist.revision') do
+      assert_no_difference('Artist.count') do
+        @artist.update_attributes({ :name => '', :bio => 'Lost his name...' })
+      end
+    end
+  end
+end
+
+describe "RevisionSan, class methods" do
+  before do
+    RevisionSanTest::Initializer.setup_database
+    
+    @gogh = Artist.create(:name => 'van Gogh, 1', :bio => 'He painted a lot.')
+    9.times { |i| @gogh.update_attribute(:name, "van Gogh, #{i+2}") }
+    
+    @picasso = Artist.create(:name => 'Picasso, 1', :bio => 'He drank a lot.')
+    9.times { |i| @picasso.update_attribute(:name, "Picasso, #{i+2}") }
+  end
+  
+  after do
+    RevisionSanTest::Initializer.teardown_database
+  end
+  
+  it "should add a named_scope that only returns the latest revisions" do
+    revisions = Artist.current_revisions
+    revisions.map(&:id).should == [@gogh.id, @picasso.id]
+    revisions.map(&:name).should == ["van Gogh, 10", "Picasso, 10"]
+    revisions.map(&:revision).should == [10, 10]
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,91 @@
+module RevisionSanTest
+  module Initializer
+    VENDOR_RAILS = File.expand_path('../../../../rails', __FILE__)
+    OTHER_RAILS = File.expand_path('../../../rails', __FILE__)
+    PLUGIN_ROOT = File.expand_path('../../', __FILE__)
+    
+    def self.rails_directory
+      if File.exist?(VENDOR_RAILS)
+        VENDOR_RAILS
+      elsif File.exist?(OTHER_RAILS)
+        OTHER_RAILS
+      end
+    end
+    
+    def self.load_dependencies
+      if rails_directory
+        $:.unshift(File.join(rails_directory, 'activesupport', 'lib'))
+        $:.unshift(File.join(rails_directory, 'activerecord', 'lib'))
+      else
+        require 'rubygems' rescue LoadError
+      end
+      
+      require 'activesupport'
+      require 'activerecord'
+      
+      require 'rubygems' rescue LoadError
+      
+      require 'test/spec'
+      require File.join(PLUGIN_ROOT, 'lib', 'revision_san')
+    end
+    
+    def self.configure_database
+      ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+      ActiveRecord::Migration.verbose = false
+    end
+    
+    def self.setup_database
+      ActiveRecord::Schema.define(:version => 1) do
+        create_table :members do |t|
+          t.timestamps
+        end
+
+        create_table :artists do |t|
+          t.integer :revision, :default => 1
+          t.integer :revision_parent_id, :default => nil
+
+          t.integer :member_id
+          t.string  :name
+          t.text    :bio
+          t.timestamps
+        end
+
+        create_table :category_assignments do |t|
+          t.integer :artist_id
+          t.integer :category_id
+          t.timestamps
+        end
+      end
+    end
+    
+    def self.teardown_database
+      ActiveRecord::Base.connection.tables.each do |table|
+        ActiveRecord::Base.connection.drop_table(table)
+      end
+    end
+    
+    def self.start
+      load_dependencies
+      configure_database
+    end
+  end
+end
+
+RevisionSanTest::Initializer.start
+
+class Member < ActiveRecord::Base
+  has_one :artist
+end
+
+class Artist < ActiveRecord::Base
+  belongs_to :member
+  has_many :category_assignments
+  
+  include RevisionSan
+  
+  validates_presence_of :name
+end
+
+class CategoryAssignment < ActiveRecord::Base
+  belongs_to :artist
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: Fingertips-revision_san
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Eloy Duran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-03 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: A simple Rails plugin which creates revisions of your model and comes with an equally simple HTML differ.
+email: eloy.de.enige@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- VERSION.yml
+- lib/revision_san
+- lib/revision_san/diff.rb
+- lib/revision_san.rb
+- test/diff_test.rb
+- test/revision_san_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/Fingertips/revision_san
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A simple Rails plugin which creates revisions of your model and comes with an equally simple HTML differ.
+test_files: []
+