wagn 1.14.1 → 1.14.2

data/db/migrate_core_cards/20140629222005_add_email_cards.rb

@@ -125,36 +125,13 @@ class AddEmailCards < Wagn::CoreMigration
     Card.create! :name => '*following+*right+*default', :type_code=>:pointer
     Card.create! :name => '*following+*right+*update', :content=>'_left'
     Card.create! :name => '*following+*right+*create', :content=>'_left'
-    Card::Codename.reset_cache      
-    
-    # move old watch rules
-    # +watchers
-    follower_hash = Hash.new { |h, v| h[v] = [] } 
 
-    Card.search(:right_plus => {:codename=> "watchers"}).each do |card|
-      if watched = card.left
-        card.item_names.each do |user_name|
-          follower_hash[user_name] << watched.name
-        end
-      end
-    end
-    
-    follower_hash.each do |user, items|
-      if card=Card.fetch(user) and card.account
-        following = card.fetch :trait=>"following", :new=>{}
-        following.items = items
-      end
-    end
-    
-    if watchers = Card[:watchers]
-      watchers.update_attributes :codename=>nil
-      watchers.delete!
-    end
-    
     if send = Card[:send]
       send.update_attributes :codename=>nil
       send.delete!
     end
+    
+    
   end
 end
 

data/db/migrate_core_cards/20141204061304_watchers_to_following.rb

@@ -0,0 +1,38 @@
+# -*- encoding : utf-8 -*-
+
+class WatchersToFollowing < Wagn::CoreMigration
+  def up
+    
+    follower_hash = Hash.new { |h, v| h[v] = [] } 
+
+    #NOTE: this migration must find cards in the trash, because the original (1.14.0) migration attempt
+    # did not successfully migration to the +*following card but did successfully delete +*watchers cards.
+    # Therefore cards migrated using 1.14.0 or 1.14.1 will not have the correct migrations
+    
+    if watcher_card = Card.find_by_key('*watcher')
+      Card.find_by_sql("select * from cards where right_id = #{watcher_card.id}").each do |card|
+        card.include_set_modules
+
+        if watched = card.left
+          card.item_names.each do |user_name|
+            follower_hash[user_name] << watched.name
+          end
+        end
+      end
+    
+      follower_hash.each do |user, items|
+        if card=Card.fetch(user) and card.account
+          following = card.fetch :trait=>"following", :new=>{}
+          items.each { |item| following.add_item item }
+          following.save!
+        end
+      end    
+    end
+    
+    if watchers = Card[:watchers]
+      watchers.update_attributes :codename=>nil
+      watchers.delete!
+    end
+
+  end
+end

data/db/version_core_cards.txt

@@ -1 +1 @@
-20141120120605
+20141204061304

data/features/history.feature

@@ -0,0 +1,21 @@
+@javascript
+Feature: History
+  As an editor 
+  I want to be able to browse through the history and save an old version as current.
+  
+  Background:
+    Given I am signed in as Joe Admin
+    Then the card First should not contain "chicken"
+    
+  Scenario: view history and rollback 
+    When I go to url "/First?view=history" 
+    Then In the main card content I should see a del with content "egg"
+    
+    When I expand act 2
+    And In the main card content I click "Hide changes"
+    Then In the main card content I should not see a del with content "egg"
+
+    When In the main card content I click "Save as current"
+    Then the card First should contain "chicken"
+    
+    

data/features/step_definitions/history_steps.rb

@@ -0,0 +1,3 @@
+When /^I expand act (\d+)$/ do |index|
+  all("a.arrow-right")[-index.to_i].click
+end

data/features/step_definitions/wagn_steps.rb

@@ -150,7 +150,8 @@ end
 
 Then /debug/ do
   if RUBY_VERSION =~ /^2/
-    byebug
+    require 'pry'
+    binding.pry
   else
     debugger
   end
@@ -251,6 +252,14 @@ Then /^In (.*) I should (not )?see a ([^\"]*) with class "([^\"]*)"$/ do |select
   end
 end
 
+Then /^In (.*) I should (not )?see a ([^\"]*) with content "([^\"]*)"$/ do |selection, neg, element, content|
+  # checks for existence of a element with a class in a selection context
+  element = 'a' if element == 'link'
+  within scope_of(selection) do
+    page.send( ( neg ? :should_not : :should ), have_css( element, :text=>content ) )
+  end
+end
+
 Then /^the "([^"]*)" field should contain "([^"]*)"$/ do |field, value|
   expect(field_labeled(field).value).to match(/#{value}/)
 end

data/lib/card/act.rb

@@ -18,9 +18,9 @@ class Card
     
     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)'
+        'card_actions.card_id IN (:card_ids) AND ( (draft is false 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) )'
+        'card_actions.card_id IN (:card_ids) AND ( (draft is false 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

data/lib/card/action.rb

@@ -160,31 +160,31 @@ class Card
     # end
       
   
-    def name_diff
+    def name_diff opts={}
       if new_name?
-        Card::Diff::DiffBuilder.new(old_values[:name],new_values[:name]).complete
+        Card::Diff.complete old_values[:name], new_values[:name], opts
       end
     end
   
-    def cardtype_diff
+    def cardtype_diff opts={}
       if new_type?
-        Card::Diff::DiffBuilder.new(old_values[:cardtype],new_values[:cardtype]).complete
+        Card::Diff.complete old_values[:cardtype], new_values[:cardtype], opts
       end
     end
   
-    def content_diff diff_type=:expanded
+    def content_diff diff_type=:expanded, opts=nil
       if new_content?
         if diff_type == :summary
-          content_diff_builder.summary
+          content_diff_builder(opts).summary
         else
-          content_diff_builder.complete
+          content_diff_builder(opts).complete 
         end
       end
     end
     
-    def content_diff_builder
+    def content_diff_builder opts=nil
       @content_diff_builder ||= begin
-        Card::Diff::DiffBuilder.new(old_values[:content], new_values[:content], :compare_html=>false)
+        Card::Diff::DiffBuilder.new(old_values[:content], new_values[:content], opts || card.diff_args)
       end
     end
     

data/lib/card/diff.rb

@@ -1,12 +1,12 @@
 # -*- encoding : utf-8 -*-
 module Card::Diff
   
-  def diff_complete(a, b)
-    DiffBuilder.new(a, b).complete
+  def self.complete a, b, opts={}
+    DiffBuilder.new(a, b, opts).complete
   end
   
-  def diff_summary(a, b)
-    DiffBuilder.new(a, b).summary
+  def self.summary a, b, opts={}
+    DiffBuilder.new(a, b, opts).summary
   end
   
   def self.render_added_chunk text
@@ -16,255 +16,414 @@ module Card::Diff
   def self.render_deleted_chunk text, count=true
     "<del class='diffdel diff-red'>#{text}</del>"
   end
+  
+  def self.render_chunk action, text
+    case action
+    when '+'      then render_added_chunk text
+    when :added   then render_added_chunk text
+    when '-'      then render_deleted_chunk text
+    when :deleted then render_deleted_chunk text
+    else text
+    end
+  end
 
   class DiffBuilder
+    attr_reader :summary, :complete
+    
+    # diff options 
+    # :format  => :html|:text|:pointer|:raw 
+    #   :html    = maintain html structure, but compare only content
+    #   :text    = remove all html tags; compare plain text
+    #   :pointer = remove all double square brackets
+    #   :raw     = escape html tags and compare everything
+    #
+    # :summary => {:length=><number> , :joint=><string> }
+    
     def initialize(old_version, new_version, opts={})
-      @old_version, @new_version = old_version, new_version
-      @opts = opts
-      @new_version ||= ''
-      if !opts[:compare_html]
-        @old_version.gsub! /<[^>]*>/,'' if @old_version
-        @new_version.gsub! /<[^>]*>/,''
+      @new_version = new_version
+      @old_version = old_version
+      @lcs_opts = lcs_opts_for_format opts[:format]
+      @lcs_opts[:summary] = opts[:summary]
+      @dels_cnt = 0
+      @adds_cnt = 0
+      
+      if not @new_version
+        @complete = ''
+        @summary  = ''
       else
-        @old_version = CGI::escapeHTML(@old_version) if @old_version
-        @new_version = CGI::escapeHTML(@new_version)
+        lcs_diff
       end
-      @summary = false
-      @complete = false
-      @adds = 0
-      @dels = 0
     end
 
-    
     def red?
-      complete and @dels > 0 
+      @dels_cnt > 0 
     end
+    
     def green?
-      complete and @adds > 0 
+      @adds_cnt > 0 
     end
     
-    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]
+    def lcs_opts_for_format format
+      opts = {}
+      case format
+      when :html
+        opts[:exclude] = /^</
+      when :text
+        opts[:reject] =  /^</
+        opts[:postprocess] = Proc.new do |word|
+          word.gsub("\n",'<br>')
+        end
+      when :pointer
+        opts[:preprocess] = Proc.new do |word|
+          word.gsub('[[','').gsub(']]','')
+        end
+      else #:raw
+        opts[:preprocess] = Proc.new do |word|
+          CGI::escapeHTML(word)
+        end
+      end
+      opts
+    end
+    
+    def lcs_diff
+      @lcs = LCS.new(@old_version, @new_version, @lcs_opts)
+      @summary  = @lcs.summary
+      @complete = @lcs.complete
+      @dels_cnt = @lcs.dels_cnt
+      @adds_cnt = @lcs.adds_cnt
+    end
+
+    
+    class LCS
+      attr_reader :adds_cnt, :dels_cnt
+      def initialize old_text, new_text, opts, summary=nil
+        @reject_pattern  = opts[:reject]        # regex; remove match completely from diff
+        @exclude_pattern = opts[:exclude]       # regex; put back to the result after diff
+        @preprocess      = opts[:preprocess]    # block; called with every word
+        @postprocess     = opts[:postprocess]   # block; called with complete diff
+        
+        @adds_cnt = 0
+        @dels_cnt = 0
+        
+        @splitters = %w( <[^>]+>  \[\[[^\]]+\]\]  \{\{[^}]+\}\}  \s+ )
+        @disjunction_pattern = /^\s/ 
+        @summary ||= Summary.new opts[:summary]
+        if not old_text
+          list = split_and_preprocess(new_text)
+          if @exclude_pattern
+            list = list.reject{ |word| word.match @exclude_pattern }
           end
-          res
+          text = postprocess list.join
+          @result = added_chunk text
+          @summary.add text
         else
-          res = @new_version[0..max_length]
-          res += joint if @new_version.size > max_length 
-          added_chunk(res, false) 
+          init_diff old_text, new_text
+          run_diff
         end
       end
-    end
-  
-    def complete
-      @complete ||= begin 
-        clear_stats
-        if @old_version
-          if @old_version.size < 1000
-            better_complete_lcs_diff
+      
+      def summary 
+        @summary.result
+      end
+      
+      def complete
+        @result
+      end
+      
+      private 
+      
+      def init_diff old_text, new_text
+        @adds = []
+        @dels = []
+        @result = ''
+        old_words, old_ex = separate_comparables_from_excludees old_text
+        new_words, new_ex = separate_comparables_from_excludees new_text
+        
+        @words = {
+          :old => old_words,
+          :new => new_words
+        }
+        @excludees = {
+          :old => ExcludeeIterator.new(old_ex),
+          :new => ExcludeeIterator.new(new_ex)
+        }
+      end
+        
+      def run_diff 
+        prev_action = nil        
+        ::Diff::LCS.traverse_balanced(@words[:old], @words[:new]) do |word|
+
+          if prev_action 
+            if prev_action != word.action and
+              !(prev_action == '-' and word.action == '!') and 
+              !(prev_action == '!' and word.action == '+')
+
+              # delete and/or add section stops here; write changes to result
+              write_dels
+              write_adds
+                  
+              write_excludees # new neutral section starts, we can just write excludees to result
+              
+            else # current word belongs to edit of previous word
+              case word.action
+              when '-'
+                del_old_excludees
+              when '+'
+                add_new_excludees
+              when '!'
+                del_old_excludees
+                add_new_excludees
+              else
+                write_excludees
+              end             
+            end
           else
-            fast_diff
+            write_excludees
           end
-        else
-          added_chunk(@new_version) 
-        end 
+          
+          process_word word
+          prev_action = word.action      
+        end
+        write_dels
+        write_adds
+        write_excludees
+      
+        @result = postprocess @result
+      end
+
+      
+      def added_chunk text, count=true
+        @adds_cnt += 1 if count
+        Card::Diff.render_added_chunk text
       end
-    end
-    
-    private
-    
-    def clear_stats
-      @adds = 0
-      @dels = 0
-    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
+      def deleted_chunk text, count=true
+        @dels_cnt += 1 if count
+        Card::Diff.render_deleted_chunk text
       end
-    end
 
-
-    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 = []
+      
+      def write_unchanged text
+        @result << text
+        @summary.omit
+      end
+      
+      def write_dels
+        if !@dels.empty?
+          @result << deleted_chunk(@dels.join)
+          @summary.delete @dels.join
+          @dels = []
+        end
+      end
+      
+      def write_adds
+        if !@adds.empty?
+          @result << added_chunk(@adds.join)
+          @summary.add @adds.join
+          @adds = []
+        end
+      end
+      
+      def write_excludees
+        while ex = @excludees[:new].next
+          @result << ex[:element]
+        end
+      end
+      
+      def del_old_excludees
+        while ex = @excludees[:old].next
+          if ex[:type] == :disjunction
+            @dels << ex[:element]
+          else
+            write_dels
+            @result << ex[:element]
           end
-          if !adds.empty?
-            res << added_chunk(adds.join(' '))
-            adds = []
+        end
+      end
+      
+      def add_new_excludees
+        while ex = @excludees[:new].next
+          if ex[:type] == :disjunction
+            @adds << ex[:element]
+          else
+            write_adds
+            @result << ex[:element]
           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
+      end
+      
+      def process_word word
+        process_element word.old_element, word.new_element, word.action
+      end
+      
+      def process_element old_element, new_element, action
+        case action
+        when '-'
+          @dels << old_element
+          @excludees[:old].word_step
+        when '+'
+          @adds << new_element
+          @excludees[:new].word_step
+        when '!'
+          @dels << old_element
+          @adds << new_element
+          @excludees[:old].word_step
+          @excludees[:new].word_step
         else
-          res += ' ' + chunk.new_element
+          write_unchanged new_element
+          @excludees[:new].word_step
         end
-        prev_action = chunk.action
       end
-      res += deleted_chunk(dels.join(' ')) if dels.present?
-      res += added_chunk(adds.join(' ')) if adds.present?
-      res
-    end
-    
-    
-    
-    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 = ''
+      
+      def separate_comparables_from_excludees text
+        # return two arrays, one with all words, one with pairs (index in word list, html_tag)
+        list = split_and_preprocess text
+        if @exclude_pattern
+          list.each_with_index.inject([[],[]]) do |res, pair|
+            element, index = pair  
+            if element.match @disjunction_pattern
+              res[1] << {:chunk_index=>index, :element=>element, :type=>:disjunction}
+            elsif element.match @exclude_pattern
+              res[1] << {:chunk_index=>index, :element=>element, :type=>:excludee}
+            else
+              res[0] << element
+            end
+            res
           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
+          [list, []]
         end
-        prev_action = chunk.action
       end
-      res += deleted_chunk(dels) if dels.present?
-      res += added_chunk(adds) if adds.present?
-      res
-    end
-    
-    def complete_diffy_diff
-      new_diffy.to_s(:html)
-    end
     
-    # 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
+      def split_and_preprocess text
+        splitted = split_to_list_of_words(text).select do |s|
+          s.size > 0 and (!@reject_pattern or !s.match @reject_pattern)
         end
+        @preprocess ? splitted.map {|s| @preprocess.call(s) } : splitted
+      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
+      def split_to_list_of_words text
+        split_regex = /(#{@splitters.join '|'})/
+        text.split(split_regex)
+      end
+          
+      def preprocess text
+        if @preprocess
+          @preprocess.call(text)
+        else
+          text
         end
-        prev_action = action
       end
       
-      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
-        ''
+      def postprocess text
+        if @postprocess
+          @postprocess.call(text)
+        else
+          text
+        end
       end
-    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
-            res.last[:text] += change.element
+      
+  
+      class Summary 
+        def initialize opts
+          opts ||= {}
+          @remaining_chars = opts[:length] || 50 
+          @joint = opts[:joint] || '...'
+          
+          @summary = nil
+          @chunks = []
+        end
+        
+        def result
+          @summary ||= render_chunks
+        end
+        
+        def add text
+          add_chunk text, :added
+        end
+        
+        def delete text
+          add_chunk text, :deleted
+        end
+        
+        def omit 
+           if @chunks.empty? or @chunks.last[:action] != :ellipsis
+            add_chunk @joint, :ellipsis
+          end
+        end  
+        
+        private
+        
+        def add_chunk text, action
+          if @remaining_chars > 0
+            @chunks << {:action => action, :text=>text}
+            @remaining_chars -= text.size
+          end
+        end
+        
+        def render_chunks
+          truncate_overlap
+          @chunks.map do |chunk|
+              Card::Diff.render_chunk chunk[:action], chunk[:text]
+          end.join 
+        end
+   
+        def truncate_overlap
+          if @remaining_chars < 0
+            if @chunks.last[:action] == :ellipsis
+              @chunks.pop
+              @remaining_chars += @joint.size
+            end
+            
+            index = @chunks.size - 1
+            while @remaining_chars < @joint.size and index >= 0
+              if @remaining_chars + @chunks[index][:text].size == @joint.size   # d
+                @chunks.pop
+                if index-1 >= 0 
+                  if @chunks[index-1][:action] == :added
+                    @chunks << {:action => :ellipsis, :text=>@joint}
+                  elsif @chunks[index-1][:action] == :deleted
+                    @chunks << {:action => :added, :text=>@joint}
+                  end
+                end
+                break
+              elsif @remaining_chars + @chunks[index][:text].size > @joint.size
+                @chunks[index][:text] =  @chunks[index][:text][0..(@remaining_chars-@joint.size-1)] 
+                @chunks[index][:text] += @joint
+                break
+              else
+                @remaining_chars += @chunks[index][:text].size
+                @chunks.delete_at(index)
+              end
+              index -= 1
+            end
+          end
+        end 
+        
+      end
+     
+      class ExcludeeIterator     
+        def initialize list
+          @list = list
+          @index = 0
+          @chunk_index = 0
+        end
+        
+        def word_step
+          @chunk_index += 1
+        end
+        
+        def next
+          if @index < @list.size and @list[@index][:chunk_index] == @chunk_index
+            res = @list[@index]
+            @index += 1
+            @chunk_index +=1
+            res
           end
-          last_action = change.action
         end
-        res
       end
-    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
+