wagn 1.13.0 → 1.14.0.pre1

data/features/update_includers.feature

@@ -1,9 +1,9 @@
 Feature: Updates for Children of watched cards
   In order to keep track of changes that are important to me
   As an Editor
-  I want to be notified when someone changes a child of a card I'm watching
+  I want to be notified when someone changes a child of a card I'm watching  #'
 
-#should this be in watch?
+  #should this be in watch?
 
   Background:
     Given I am signed in as Joe User
@@ -13,11 +13,11 @@ Feature: Updates for Children of watched cards
 
   Scenario: Watcher should be notified of updates to included plus card
     When I create card "Ulysses+author" with content "James Joyce"
-    Then Joe Camel should be notified that "Joe User updated \"Ulysses\""
     #And He should see "added Ulysses+author" in the email  -- FIXME need multiline matching
-    And Joe Admin should be notified that "Joe User updated \"Ulysses\""
-    When Joe Admin edits "Ulysses+author" setting content to "Jim"
-    Then Joe Camel should be notified that "Joe Admin updated \"Ulysses\""
+    Then Joe Admin should be notified that "Joe User created \"Ulysses\+author\""
+    And Joe Camel should be notified that "Joe User created \"Ulysses\+author\""
+    When Joe Admin edits "Ulysses\+author" setting content to "Jim"
+    Then Joe Camel should be notified that "Joe Admin updated \"Ulysses\+author\""
     #And Joe Admin should be notified that "Joe User updated \"Ulysses\""
 
   Scenario: Should not notify of included but not plussed card
@@ -50,19 +50,25 @@ Feature: Updates for Children of watched cards
     When I edit "Banana" with plusses:
       |color|flavor|
       |spotted|mushy|
-    Then Joe Camel should be notified that "Joe User updated \"Banana\+color\""
+    Then Joe Camel should be notified that "Joe User updated \"Banana\""
     When Joe Camel is watching "Banana"
     And I wait a sec
     And I edit "Banana" with plusses:
       |color|flavor|
-      |spotted|mushy|
+      |green|mushy|
     Then Joe Camel should be notified that "Joe User updated \"Banana\""
+    Given a clear email queue
+    And I edit "Banana" with plusses:
+      |color|flavor|
+      |green|mushy|
+    Then No notification should be sent
+    
 
   Scenario: Watching a plus card & including card on regular edit
     When I create card "Ulysses+author" with content "Joyce"
-    Then Joe Camel should be notified that "Joe User updated \"Ulysses\""
+    Then Joe Camel should be notified that "Joe User created \"Ulysses\+author\""
     When Joe Camel is watching "Ulysses+author"
     And I edit "Ulysses+author" setting content to "Jim"
-    Then Joe Camel should be notified that "Joe User updated \"Ulysses\""
+    Then Joe Camel should be notified that "Joe User updated \"Ulysses\+author\""
 
 

data/features/watch.feature

@@ -20,7 +20,7 @@ Feature: Watch interface
     Then In the main card menu I should see "following|unfollow"
     # assumes focus still on that link.  otherwise "following"
     # selenium behavior not totally consistent here.
-    And the card Home+*watchers should contain "Joe User"
+    And the card Joe User+*following should contain "Home"
 
   Scenario: Unwatching a Card
     Given Joe User is watching "Home"
@@ -29,7 +29,7 @@ Feature: Watch interface
     And In the main card menu I click "following"
     #note: turns to "unfollow on mouseover"
     Then In the main card menu I should see "follow"
-    And the card Home+*watchers should not contain "Joe User"
+    And the card Joe User+*following should not contain "Home"
 
   Scenario: Watching a Cardtype
     When I go to card User

data/lib/card.rb

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 
 class Card < ActiveRecord::Base
-
+  
   require_dependency 'card/active_record_ext'
   require_dependency 'card/codename'
   require_dependency 'card/query'
@@ -12,29 +12,30 @@ class Card < ActiveRecord::Base
   require_dependency 'card/auth'
   require_dependency 'card/loader'
 
-  has_many :revisions, :order => :id
   has_many :references_from, :class_name => :Reference, :foreign_key => :referee_id
   has_many :references_to,   :class_name => :Reference, :foreign_key => :referer_id
+  has_many :acts, :order => :id
+  has_many :actions, :order => :id, :conditions=>{:draft => [nil,false]}
+  has_many :drafts, :order=>:id, :conditions=>{:draft=>true}, :class_name=> :Action
 
   cache_attributes 'name', 'type_id' # review - still worth it in Rails 3?
 
   cattr_accessor :set_patterns, :error_codes
   @@set_patterns, @@error_codes = [], {}
 
-  attr_writer :selected_revision_id #writer because read method is in mod (and does not override upon load)
-  attr_accessor :action, :supercard,
+  attr_accessor :action, :supercard, :current_act, :current_action, 
     :comment, :comment_author,    # obviated soon
-    :update_referencers           # wrong mechanism for this
-
+    :update_referencers,           # wrong mechanism for this
+    :follower_stash,
+    :last_action_id_before_edit
+    
   define_callbacks :approve, :store, :extend
   
   before_validation :approve
   around_save :store
   after_save :extend
-
+  
+  TRACKED_FIELDS = %w(name type_id db_content trash)
   Loader.load_mods if count > 0
-    
-  tracks :content # we can phase this out and just use "dirty" handling once current content is stored in the cards table
 
 end
-

data/lib/card/act.rb

@@ -0,0 +1,63 @@
+# -*- encoding : utf-8 -*-
+class Card
+  class Act < ActiveRecord::Base
+    before_save :set_actor
+    has_many :actions, :foreign_key=>:card_act_id, :inverse_of=> :act, :order => :id, :class_name=> "Card::Action"
+    belongs_to :actor, class_name: "Card"
+    belongs_to :card    
+    def set_actor
+      self.actor_id ||= Auth.current_id
+    end
+    
+    def self.delete_actionless
+      Card::Act.where(
+        "id NOT IN (?)",
+        Card::Action.pluck("card_act_id"),
+      ).delete_all
+    end
+    
+    def self.find_all_with_actions_on card_ids, args={}
+      sql = if args[:with_drafts]
+        'card_actions.card_id IN (:card_ids) AND ( (draft = 0 OR draft IS null) OR actor_id = :current_user_id)'
+      else
+        'card_actions.card_id IN (:card_ids) AND ( (draft = 0 OR draft IS null) )'
+      end
+      Card::Act.joins(:actions).where(sql, 
+        {:card_ids => card_ids, :current_user_id=>Card::Auth.current_id }).uniq.order(:id).reverse_order
+    end
+    
+    # def actor
+    #   Card[ actor_id ]
+    # end
+
+    # def card
+ #      Card[ card_id ]
+ #    end
+    
+    def action_on card_id
+      actions.find_by_card_id(card_id)
+    end
+        
+    def elapsed_time
+      DateTime.new(acted_at).distance_of_time_in_words_to_now
+    end
+    
+    def relevant_drafts_for card
+      drafts.select do |action|
+        card.included_card_ids.include?(action.card_id) || (card == action.card)
+      end
+    end
+    
+    def relevant_actions_for card, with_drafts=false
+      actions.select do |action|
+        card.included_card_ids.include?(action.card_id) || (card == action.card)
+      end
+    end
+    
+  private
+    def timestamp_attributes_for_create
+      super << :acted_at
+    end
+    
+  end
+end

data/lib/card/action.rb

@@ -0,0 +1,194 @@
+# -*- encoding : utf-8 -*-
+class Card
+  
+  #fixme - these Card class methods should probably be in a set module
+  def find_action_by_params args
+    case 
+    when args[:rev]
+      nth_action(args[:rev].to_i-1)
+    when args[:rev_id]
+      if action = Action.fetch(args[:rev_id]) and action.card_id == id 
+        action 
+      end
+    end
+  end
+  
+  def nth_action index
+    Action.where("(draft IS NULL OR draft = :draft) AND card_id = ':id'", {:draft=>false, :id=>id})[index-1]
+  end
+  
+  def revision action
+    # a "revision" refers to the state of all tracked fields at the time of a given action
+    if action.is_a? Integer
+      action = Card::Action.fetch(action)
+    end
+    action and Card::TRACKED_FIELDS.inject({}) do |attr_changes, field|
+      last_change = action.changes.find_by_field(field) || last_change_on(field, :not_after=>action)
+      attr_changes[field.to_sym] = (last_change ? last_change.value : self[field])
+      attr_changes
+    end
+  end
+  
+  def delete_old_actions
+    Card::TRACKED_FIELDS.each do |field|
+      # assign previous changes on each tracked field to the last action
+      if (not last_action.change_for(field).present?) and (last_change = last_change_on(field))
+        last_change = Card::Change.find(last_change.id)   # last_change comes as readonly record
+        last_change.update_attributes!(:card_action_id=>last_action_id)
+      end
+    end
+    actions.where('id != ?', last_action_id ).delete_all
+  end
+  
+  
+  class Action < ActiveRecord::Base
+    belongs_to :card
+    belongs_to :act,  :foreign_key=>:card_act_id, :inverse_of=>:actions 
+    has_many   :changes, :foreign_key=>:card_action_id, :inverse_of=>:action, :dependent=>:delete_all
+    
+    belongs_to :super_action, class_name: "Action", :inverse_of=>:sub_actions
+    has_many   :sub_actions,  class_name: "Action", :inverse_of=>:super_action
+    
+    scope :created_by, lambda { |actor_id| joins(:act).where('card_acts.actor_id = ?', actor_id) }
+    
+    # replace with enum if we start using rails 4 
+    TYPE = [:create, :update, :delete]
+    
+    class << self
+      def cache
+        Wagn::Cache[Action]
+      end
+    
+      def fetch id
+        cache.read(id.to_s) or begin
+          cache.write id.to_s, Action.find(id.to_i)
+        end
+      end
+      
+    
+      def delete_cardless
+        Card::Action.where( Card.where( :id=>arel_table[:card_id] ).exists.not ).delete_all
+      end
+    
+      def delete_old 
+        Card.find_each do |card|
+          card.delete_old_actions
+        end    
+        Card::Act.delete_actionless
+      end
+    end
+    
+    def edit_info
+      @edit_info ||= {
+        :action_type  => "#{action_type}d",
+        :new_content  => new_values[:content],
+        :new_name     => new_values[:name],
+        :new_cardtype => new_values[:cardtype],
+        :old_content  => old_values[:content],
+        :old_name     => old_values[:name],
+        :old_cardtype => old_values[:cardtype]
+      }
+    end
+    
+    def new_values
+      @new_values ||= {
+        :content  => new_value_for(:db_content),
+        :name     => new_value_for(:name),
+        :cardtype => ( typecard = Card[new_value_for(:type_id).to_i] and typecard.name.capitalize )
+      }
+    end
+    
+    def old_values
+      @old_values ||= {
+        :content  => last_value_for(:db_content),
+        :name     => last_value_for(:name),
+        :cardtype => ( value = last_value_for(:type_id) and 
+                       typecard = Card.find(value) and  typecard.name.capitalize )
+      }
+    end
+    
+    def last_value_for field
+       ch = self.card.last_change_on(field, :before=>self) and ch.value
+    end
+    
+    def new_value_for(field)
+       ch = changes.find_by_field(field) and ch.value
+    end
+    def change_for(field) 
+      changes.where('card_changes.field = ?', field)
+    end
+    
+    
+    def new_type?
+      new_value_for(:type_id)
+    end
+    def new_content?
+      new_value_for(:db_content)
+    end
+    def new_name?
+      new_value_for(:name)
+    end
+    
+    
+    def action_type=(value)
+      write_attribute(:action_type, TYPE.index(value))
+    end
+    
+    def action_type
+      TYPE[read_attribute(:action_type)]
+    end
+    
+    def set_act
+      self.set_act ||= self.acts.last
+    end
+    
+    def revision_nr 
+      self.card.actions.index_of(self)
+    end
+    
+    def red?
+      content_diff_builder.red?
+    end
+    
+    def green?
+      content_diff_builder.green?
+    end
+    
+    
+    # def diff
+    #   @diff ||= { :cardtype=>type_diff, :content=>content_diff, :name=>name_diff}
+    # end
+      
+  
+    def name_diff
+      if new_name?
+        Card::Diff::DiffBuilder.new(old_values[:name],new_values[:name]).complete
+      end
+    end
+  
+    def cardtype_diff
+      if new_type?
+        Card::Diff::DiffBuilder.new(old_values[:cardtype],new_values[:cardtype]).complete
+      end
+    end
+  
+    def content_diff diff_type=:expanded
+      if new_content?
+        if diff_type == :summary
+          content_diff_builder.summary
+        else
+          content_diff_builder.complete
+        end
+      end
+    end
+    
+    def content_diff_builder
+      @content_diff_builder ||= begin
+        Card::Diff::DiffBuilder.new(old_values[:content], new_values[:content], :compare_html=>false)
+      end
+    end
+    
+  end
+end
+
+

data/lib/card/change.rb

@@ -0,0 +1,29 @@
+# -*- encoding : utf-8 -*-
+class Card
+  class Change < ActiveRecord::Base
+    belongs_to :action, :foreign_key=>:card_action_id, :inverse_of=>:changes
+    
+    # replace with enum if we start using rails 4 
+    def field=(value)
+      write_attribute(:field, Card::TRACKED_FIELDS.index(value.to_s))
+    end
+    
+    def field
+      Card::TRACKED_FIELDS[read_attribute(:field)]
+    end
+    
+    def self.delete_actionless
+      Card::Change.where(
+        "card_action_id NOT IN (?)",
+        Card::Action.pluck("id"),
+      ).delete_all
+    end
+    
+    def self.find_by_field(value)
+      index = value.is_a?(Integer) ? value : Card::TRACKED_FIELDS.index(value.to_s)
+      super(index)
+    end
+  end
+end
+
+

data/lib/card/content.rb

@@ -16,7 +16,7 @@ class Card
       @opts = opts || {}
       
       unless Array === content
-        content = parse_content content
+        content = parse_content content  
       end
       super content
     end

data/lib/card/diff.rb

@@ -1,317 +1,270 @@
 # -*- encoding : utf-8 -*-
 module Card::Diff
   
-  def diff(a, b)
-    DiffBuilder.new(a, b).build
+  def diff_complete(a, b)
+    DiffBuilder.new(a, b).complete
   end
-
-
-  Match = Struct.new(:start_in_old, :start_in_new, :size)
-  class Match
-    def end_in_old
-      self.start_in_old + self.size
-    end
-
-    def end_in_new
-      self.start_in_new + self.size
-    end
+  
+  def diff_summary(a, b)
+    DiffBuilder.new(a, b).summary
+  end
+  
+  def self.render_added_chunk text
+    "<ins class='diffins diff-green'>#{text}</ins>"
+  end
+  
+  def self.render_deleted_chunk text, count=true
+    "<del class='diffdel diff-red'>#{text}</del>"
   end
-
-  Operation = Struct.new(:action, :start_in_old, :end_in_old, :start_in_new, :end_in_new)
 
   class DiffBuilder
-
-    def initialize(old_version, new_version)
+    def initialize(old_version, new_version, opts={})
       @old_version, @new_version = old_version, new_version
-      @content = []
+      @opts = opts
+      @new_version ||= ''
+      if !opts[:compare_html]
+        @old_version.gsub! /<[^>]*>/,'' if @old_version
+        @new_version.gsub! /<[^>]*>/,''
+      else
+        @old_version = CGI::escapeHTML(@old_version) if @old_version
+        @new_version = CGI::escapeHTML(@new_version)
+      end
+      @summary = false
+      @complete = false
+      @adds = 0
+      @dels = 0
     end
 
-    def build
-      split_inputs_to_words
-      index_new_words
-      operations.each { |op| perform_operation(op) }
-      return @content.join
+    
+    def red?
+      complete and @dels > 0 
     end
-
-    def split_inputs_to_words
-      @old_words = convert_html_to_list_of_words(explode(@old_version))
-      @new_words = convert_html_to_list_of_words(explode(@new_version))
+    def green?
+      complete and @adds > 0 
     end
-
-    def index_new_words
-      @word_indices = Hash.new { |h, word| h[word] = [] }
-      @new_words.each_with_index { |word, i| @word_indices[word] << i }
+    
+    def summary  max_length = 50, joint = '...'
+      @summary ||= begin
+        if @old_version 
+          last_position = 0
+          remaining_chars = max_length
+          res = ''
+          new_aggregated_lcs.each do |change|
+            if change[:position] > last_position
+              res += joint
+            end
+            res += render_chunk change[:action], change[:text][0..remaining_chars], false
+            remaining_chars -= change[:text].size
+            if remaining_chars < 0  # no more space left
+              res += joint
+              break
+            end
+            last_position = change[:position]
+          end
+          res
+        else
+          res = @new_version[0..max_length]
+          res += joint if @new_version.size > max_length 
+          added_chunk(res, false) 
+        end
+      end
     end
-
-    def operations
-      position_in_old = position_in_new = 0
-      operations = []
-
-      matches = matching_blocks
-      # an empty match at the end forces the loop below to handle the unmatched tails
-      # I'm sure it can be done more gracefully, but not at 23:52
-      matches << Match.new(@old_words.length, @new_words.length, 0)
-
-      matches.each_with_index do |match, i|
-        match_starts_at_current_position_in_old = (position_in_old == match.start_in_old)
-        match_starts_at_current_position_in_new = (position_in_new == match.start_in_new)
-
-        action_upto_match_positions =
-          case [match_starts_at_current_position_in_old, match_starts_at_current_position_in_new]
-          when [false, false]
-            :replace
-          when [true, false]
-            :insert
-          when [false, true]
-            :delete
+  
+    def complete
+      @complete ||= begin 
+        clear_stats
+        if @old_version
+          if @old_version.size < 1000
+            better_complete_lcs_diff
           else
-            # this happens if the first few words are same in both versions
-            :none
+            fast_diff
           end
-
-        if action_upto_match_positions != :none
-          operation_upto_match_positions =
-              Operation.new(action_upto_match_positions,
-                  position_in_old, match.start_in_old,
-                  position_in_new, match.start_in_new)
-          operations << operation_upto_match_positions
-        end
-        if match.size != 0
-          match_operation = Operation.new(:equal,
-              match.start_in_old, match.end_in_old,
-              match.start_in_new, match.end_in_new)
-          operations << match_operation
-        end
-
-        position_in_old = match.end_in_old
-        position_in_new = match.end_in_new
+        else
+          added_chunk(@new_version) 
+        end 
       end
-
-      operations
     end
-
-    def matching_blocks
-      matching_blocks = []
-      recursively_find_matching_blocks(0, @old_words.size, 0, @new_words.size, matching_blocks)
-      matching_blocks
+    
+    private
+    
+    def clear_stats
+      @adds = 0
+      @dels = 0
     end
-
-    def recursively_find_matching_blocks(start_in_old, end_in_old, start_in_new, end_in_new, matching_blocks)
-      match = find_match(start_in_old, end_in_old, start_in_new, end_in_new)
-      if match
-        if start_in_old < match.start_in_old and start_in_new < match.start_in_new
-          recursively_find_matching_blocks(
-              start_in_old, match.start_in_old, start_in_new, match.start_in_new, matching_blocks)
-        end
-        matching_blocks << match
-        if match.end_in_old < end_in_old and match.end_in_new < end_in_new
-          recursively_find_matching_blocks(
-              match.end_in_old, end_in_old, match.end_in_new, end_in_new, matching_blocks)
-        end
+    
+    def added_chunk text, count=true
+      @adds += 1 if count
+      Card::Diff.render_added_chunk text
+    end
+  
+    def deleted_chunk text, count=true
+      @dels += 1 if count
+      Card::Diff.render_deleted_chunk text
+    end
+  
+  
+    def render_chunk action, text, count=true
+      case action
+      when '+'      then added_chunk(text,count)
+      when :added   then added_chunk(text,count)
+      when '-'      then deleted_chunk(text,count)
+      when :deleted then deleted_chunk(text,count)
+      else text
       end
     end
 
-    def find_match(start_in_old, end_in_old, start_in_new, end_in_new)
 
-      best_match_in_old = start_in_old
-      best_match_in_new = start_in_new
-      best_match_size = 0
-
-      match_length_at = Hash.new { |h, index| h[index] = 0 }
-
-      start_in_old.upto(end_in_old - 1) do |index_in_old|
-
-        new_match_length_at = Hash.new { |h, index| h[index] = 0 }
-
-        @word_indices[@old_words[index_in_old]].each do |index_in_new|
-          next  if index_in_new < start_in_new
-          break if index_in_new >= end_in_new
-
-          new_match_length = match_length_at[index_in_new - 1] + 1
-          new_match_length_at[index_in_new] = new_match_length
-
-          if new_match_length > best_match_size
-            best_match_in_old = index_in_old - new_match_length + 1
-            best_match_in_new = index_in_new - new_match_length + 1
-            best_match_size = new_match_length
+    def better_complete_lcs_diff old_v=@old_version, new_v=@new_version
+      old_v = old_v.split(' ')
+      new_v = new_v.split(' ')
+      res = ''
+      dels = []
+      adds = []
+      prev_action = nil
+      ::Diff::LCS.traverse_balanced(old_v, new_v) do |chunk|
+        if prev_action and prev_action != chunk.action and
+          !(prev_action == '-' and chunk.action == '!') and 
+          !(prev_action == '!' and chunk.action == '+')
+       
+          if dels.present?
+            res << deleted_chunk(dels.join(' '))
+            dels = []
+          end
+          if !adds.empty?
+            res << added_chunk(adds.join(' '))
+            adds = []
           end
         end
-        match_length_at = new_match_length_at
-      end
-
-#      best_match_in_old, best_match_in_new, best_match_size = add_matching_words_left(
-#          best_match_in_old, best_match_in_new, best_match_size, start_in_old, start_in_new)
-#      best_match_in_old, best_match_in_new, match_size = add_matching_words_right(
-#          best_match_in_old, best_match_in_new, best_match_size, end_in_old, end_in_new)
-
-      return (best_match_size != 0 ? Match.new(best_match_in_old, best_match_in_new, best_match_size) : nil)
-    end
-
-    def add_matching_words_left(match_in_old, match_in_new, match_size, start_in_old, start_in_new)
-      while match_in_old > start_in_old and
-            match_in_new > start_in_new and
-            @old_words[match_in_old - 1] == @new_words[match_in_new - 1]
-        match_in_old -= 1
-        match_in_new -= 1
-        match_size += 1
+        
+        case chunk.action
+        when '-' then dels << chunk.old_element
+        when '+' then adds << chunk.new_element
+        when '!' 
+          dels << chunk.old_element
+          adds << chunk.new_element
+        else
+          res += ' ' + chunk.new_element
+        end
+        prev_action = chunk.action
       end
-      [match_in_old, match_in_new, match_size]
+      res += deleted_chunk(dels.join(' ')) if dels.present?
+      res += added_chunk(adds.join(' ')) if adds.present?
+      res
     end
-
-    def add_matching_words_right(match_in_old, match_in_new, match_size, end_in_old, end_in_new)
-      while match_in_old + match_size < end_in_old and
-            match_in_new + match_size < end_in_new and
-            @old_words[match_in_old + match_size] == @new_words[match_in_new + match_size]
-        match_size += 1
+    
+    
+    
+    def complete_lcs_diff old_v=@old_version, new_v=@new_version
+      last_position = 0
+      res = ''
+      dels = ''
+      adds = ''
+      prev_action = nil
+      ::Diff::LCS.traverse_balanced(old_v, new_v) do |chunk|
+        if prev_action and prev_action != chunk.action and
+          !(prev_action == '-' and chunk.action == '!') and 
+          !(prev_action == '!' and chunk.action == '+')
+       
+          if dels.present?
+            res += deleted_chunk(dels)
+            dels = ''
+          end
+          if !adds.empty?
+            res += added_chunk(adds)
+            adds = ''
+          end
+        end
+        
+        case chunk.action
+        when '-' then dels += chunk.old_element
+        when '+' then adds += chunk.new_element
+        when '!' 
+          dels += chunk.old_element
+          adds += chunk.new_element
+        else
+          res += chunk.new_element
+        end
+        prev_action = chunk.action
       end
-      [match_in_old, match_in_new, match_size]
+      res += deleted_chunk(dels) if dels.present?
+      res += added_chunk(adds) if adds.present?
+      res
     end
-
-    VALID_METHODS = [:replace, :insert, :delete, :equal]
-
-    def perform_operation(operation)
-      @operation = operation
-      self.send operation.action, operation
-    end
-
-    def replace(operation)
-      delete(operation, 'diffmod')
-      insert(operation, 'diffmod')
+    
+    def complete_diffy_diff
+      new_diffy.to_s(:html)
     end
-
-    def insert(operation, tagclass = 'diffins')
-      insert_tag('ins', tagclass, @new_words[operation.start_in_new...operation.end_in_new])
-    end
-
-    def delete(operation, tagclass = 'diffdel')
-       insert_tag('del', tagclass, @old_words[operation.start_in_old...operation.end_in_old])
-    end
-
-    def equal(operation)
-      # no tags to insert, simply copy the matching words from one of the versions
-      @content += @new_words[operation.start_in_new...operation.end_in_new]
-    end
-
-    def opening_tag?(item)
-      item =~ %r!^\s*<[^>]+>\s*$!
-    end
-
-    def closing_tag?(item)
-      item =~ %r!^\s*</[^>]+>\s*$!
-    end
-
-    def tag?(item)
-      opening_tag?(item) or closing_tag?(item)
-    end
-
-    def extract_consecutive_words(words, &condition)
-      index_of_first_tag = nil
-      words.each_with_index do |word, i|
-        if !condition.call(word)
-          index_of_first_tag = i
-          break
+    
+    # combines diffy and lcs:
+    # find with diffy line changes
+    # whenever added lines follow immediately after deleted lines compare them with lcs
+    def fast_diff
+      lines = { :deleted => [], :added=>[], :unchanged=>[], :eof=>[] }
+      prev_action = nil
+      res = ''
+      inspect = false
+      new_diffy.each_chunk do |line|
+        action = case line
+        when /^\+/ then :added
+        when /^-/ then :deleted
+        when /^ / then :unchanged
+        else 
+          next
+        end
+        lines[action] << line.sub(/^./,'')
+        if action == :added and prev_action == :deleted
+          inspect = true
+        end
+    
+        if inspect 
+          if action != :added
+            res += better_complete_lcs_diff lines[:deleted].join, lines[:added].join
+            inspect = false
+            lines[:deleted].clear
+            lines[:added].clear
+          end
+        elsif prev_action and action != prev_action
+          text = lines[prev_action].join
+          res += render_chunk prev_action, text
+          lines[prev_action].clear
         end
+        prev_action = action
       end
-      if index_of_first_tag
-        return words.slice!(0...index_of_first_tag)
+      
+      res += if inspect
+        better_complete_lcs_diff lines[:deleted].join, lines[:added].join
+      elsif lines[prev_action].present?
+        render_chunk prev_action, lines[prev_action].join
       else
-        return words.slice!(0..words.length)
+        ''
       end
     end
-
-    # This method encloses words within a specified tag (ins or del), and adds this into @content,
-    # with a twist: if there are words contain tags, it actually creates multiple ins or del,
-    # so that they don't include any ins or del. This handles cases like
-    # old: '<p>a</p>'
-    # new: '<p>ab</p><p>c</b>'
-    # diff result: '<p>a<ins>b</ins></p><p><ins>c</ins></p>'
-    # this still doesn't guarantee valid HTML (hint: think about diffing a text containing ins or
-    # del tags), but handles correctly more cases than the earlier version.
-    #
-    # P.S.: Spare a thought for people who write HTML browsers. They live in this ... every day.
-
-    def insert_tag(tagname, cssclass, words)
-      loop do
-        break if words.empty?
-        non_tags = extract_consecutive_words(words) { |word| not tag?(word) }
-        @content << wrap_text(non_tags.join, tagname, cssclass) unless non_tags.empty?
-
-        break if words.empty?
-        @content += extract_consecutive_words(words) { |word| tag?(word) }
-      end
-    end
-
-    def wrap_text(text, tagname, cssclass)
-      %(<#{tagname} class="#{cssclass}">#{text}</#{tagname}>)
-    end
-
-    def explode(sequence)
-      sequence.is_a?(String) ? sequence.split(//) : sequence
-    end
-
-    def end_of_tag?(char)
-      char == '>'
-    end
-
-    def start_of_tag?(char)
-      char == '<'
-    end
-
-    def whitespace?(char)
-      char =~ /\s/
-    end
-
-    def convert_html_to_list_of_words(x, use_brackets = false)
-      mode = :char
-      current_word  = ''
-      words = []
-
-      explode(x).each do |char|
-        case mode
-        when :tag
-          if end_of_tag? char
-            current_word << (use_brackets ? ']' : '>')
-            words << current_word
-            current_word = ''
-            if whitespace?(char)
-              mode = :whitespace
-            else
-              mode = :char
-            end
+    
+ 
+    def new_aggregated_lcs
+      new_lcs.inject([]) do |res, change_block|
+        last_action = nil
+        change_block.each do |change| 
+          if change.action != last_action
+            res << { :position => change.position,
+                   :action   => change.action,
+                   :text   => change.element
+                 }
           else
-            current_word << char
+            res.last[:text] += change.element
           end
-        when :char
-          if start_of_tag? char
-            words << current_word unless current_word.empty?
-            current_word = (use_brackets ? '[' : '<')
-            mode = :tag
-          elsif /\s/.match char
-            words << current_word unless current_word.empty?
-            current_word = char
-            mode = :whitespace
-          else
-            current_word << char
-          end
-        when :whitespace
-          if start_of_tag? char
-            words << current_word unless current_word.empty?
-            current_word = (use_brackets ? '[' : '<')
-            mode = :tag
-          elsif /\s/.match char
-            current_word << char
-          else
-            words << current_word unless current_word.empty?
-            current_word = char
-            mode = :char
-          end
-        else
-          raise "Unknown mode #{mode.inspect}"
+          last_action = change.action
         end
+        res
       end
-      words << current_word unless current_word.empty?
-      words
     end
-
+    
+    def new_diffy
+      ::Diffy::Diff.new(@old_version, @new_version)
+    end
+  
+    def new_lcs
+      ::Diff::LCS.diff(@old_version,@new_version)
+    end
   end
 end