card 1.18.0 → 1.18.1

data/lib/card/diff/lcs.rb

@@ -0,0 +1,247 @@
+class Card
+  class Diff
+    # Use LCS algorithm to create a Diff::Result
+    class LCS
+      def initialize opts
+        # regex; remove matches completely from diff
+        @reject_pattern = opts[:reject]
+        # regex; put matches back to the result after diff
+        @exclude_pattern = opts[:exclude]
+
+        @preprocess   = opts[:preprocess]  # block; called with every word
+        @postprocess  = opts[:postprocess] # block; called with complete diff
+
+        @splitters = %w( <[^>]+>  \[\[[^\]]+\]\]  \{\{[^}]+\}\}  \s+ )
+        @disjunction_pattern = /^\s/
+      end
+
+      def run old_text, new_text, result
+        @result = result
+        compare old_text, new_text
+        @result.complete = postprocess @result.complete
+      end
+
+      private
+
+      def compare old_text, new_text
+        if old_text
+          old_words, old_ex = separate_comparables_from_excludees old_text
+          new_words, new_ex = separate_comparables_from_excludees new_text
+          ChunkProcessor.new(old_words, new_words, old_ex, new_ex).run(@result)
+        else
+          list = split_and_preprocess(new_text)
+          if @exclude_pattern
+            list = list.reject { |word| word.match @exclude_pattern }
+          end
+          # CAUTION: postproces and added_chunk changed order
+          # and no longer postprocess for summary
+          @result.write_added_chunk list.join
+        end
+      end
+
+      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
+          check_exclude_and_disjunction_pattern list
+        else
+          [list, []]
+        end
+      end
+
+      def check_exclude_and_disjunction_pattern list
+        list.each_with_index.each_with_object([[], []]) do |pair, res|
+          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
+        end
+      end
+
+      def split_and_preprocess text
+        splitted = split_to_list_of_words(text).select do |s|
+          !s.empty? && (!@reject_pattern || !s.match(@reject_pattern))
+        end
+        @preprocess ? splitted.map { |s| @preprocess.call(s) } : splitted
+      end
+
+      def split_to_list_of_words text
+        split_regex = /(#{@splitters.join '|'})/
+        text.split(split_regex)
+      end
+
+      def preprocess text
+        @preprocess ? @preprocess.call(text) : text
+      end
+
+      def postprocess text
+        @postprocess ? @postprocess.call(text) : text
+      end
+
+      # Compares two lists of chunks and generates a diff
+      class ChunkProcessor
+        attr_reader :result, :summary, :dels_cnt, :adds_cnt
+        def initialize old_words, new_words, old_excludees, new_excludees
+          @adds = []
+          @dels = []
+          @words = {
+            old: old_words,
+            new: new_words
+          }
+          @excludees = {
+            old: ExcludeeIterator.new(old_excludees),
+            new: ExcludeeIterator.new(new_excludees)
+          }
+        end
+
+        def run result
+          @result = result
+          prev_action = nil
+          ::Diff::LCS.traverse_balanced(@words[:old], @words[:new]) do |word|
+            if prev_action
+              if prev_action != word.action &&
+                 !(prev_action == '-' && word.action == '!') &&
+                 !(prev_action == '!' && word.action == '+')
+
+                # delete and/or add section stops here; write changes to result
+                write_dels
+                write_adds
+
+                # new neutral section starts
+                # we can just write excludees to result
+                write_excludees
+
+              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
+              write_excludees
+            end
+
+            process_word word
+            prev_action = word.action
+          end
+          write_dels
+          write_adds
+          write_excludees
+
+          @result
+        end
+
+        private
+
+        def write_unchanged text
+          @result.write_unchanged_chunk text
+        end
+
+        def write_dels
+          return if @dels.empty?
+          @result.write_deleted_chunk @dels.join
+          @dels = []
+        end
+
+        def write_adds
+          return if @adds.empty?
+          @result.write_added_chunk @adds.join
+          @adds = []
+        end
+
+        def write_excludees
+          while (ex = @excludees[:new].next)
+            @result.write_excluded_chunk ex[:element]
+          end
+        end
+
+        def del_old_excludees
+          while (ex = @excludees[:old].next)
+            if ex[:type] == :disjunction
+              @dels << ex[:element]
+            else
+              write_dels
+              @result.write_excluded_chunk ex[:element]
+            end
+          end
+        end
+
+        def add_new_excludees
+          while (ex = @excludees[:new].next)
+            if ex[:type] == :disjunction
+              @adds << ex[:element]
+            else
+              write_adds
+              @result.complete << ex[:element]
+            end
+          end
+        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 '-'
+            minus old_element
+          when '+'
+            plus new_element
+          when '!'
+            minus old_element
+            plus new_element
+          else
+            write_unchanged new_element
+            @excludees[:new].word_step
+          end
+        end
+
+        def plus new_element
+          @adds << new_element
+          @excludees[:new].word_step
+        end
+
+        def minus old_element
+          @dels << old_element
+          @excludees[:old].word_step
+        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 &&
+             @list[@index][:chunk_index] == @chunk_index
+            res = @list[@index]
+            @index += 1
+            @chunk_index += 1
+            res
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/diff/result.rb

@@ -0,0 +1,131 @@
+class Card
+  class Diff
+    class Result
+      attr_accessor :complete, :summary, :dels_cnt, :adds_cnt
+      def initialize summary_opts=nil
+        @dels_cnt = 0
+        @adds_cnt = 0
+        @complete = ''
+        @summary = Summary.new summary_opts
+      end
+
+      def summary
+        @summary.rendered
+      end
+
+      def write_added_chunk text
+        @adds_cnt += 1
+        @complete << Card::Diff.render_added_chunk(text)
+        @summary.add text
+      end
+
+      def write_deleted_chunk text
+        @dels_cnt += 1
+        @complete << Card::Diff.render_deleted_chunk(text)
+        @summary.delete text
+      end
+
+      def write_unchanged_chunk text
+        @complete << text
+        @summary.omit
+      end
+
+      def write_excluded_chunk text
+        @complete << text
+      end
+
+      class Summary
+        def initialize opts
+          opts ||= {}
+          @remaining_chars = opts[:length] || 50
+          @joint = opts[:joint] || '...'
+
+          @summary = nil
+          @chunks = []
+        end
+
+        def rendered
+          @summary ||=
+            begin
+              truncate_overlap
+              @chunks.map do |chunk|
+                render_chunk chunk[:action], chunk[:text]
+              end.join
+            end
+        end
+
+        def add text
+          add_chunk text, :added
+        end
+
+        def delete text
+          add_chunk text, :deleted
+        end
+
+        def omit
+          if @chunks.empty? || @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_chunk action, text
+          case action
+          when '+', :added then Card::Diff.render_added_chunk text
+          when '-', :deleted then Card::Diff.render_deleted_chunk text
+          else text
+          end
+        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 && index >= 0
+              if @remaining_chars + @chunks[index][:text].size == @joint.size
+                replace_with_joint index
+                break
+              elsif @remaining_chars + @chunks[index][:text].size > @joint.size
+                cut_with_joint index
+                break
+              else
+                @remaining_chars += @chunks[index][:text].size
+                @chunks.delete_at(index)
+              end
+              index -= 1
+            end
+          end
+        end
+
+        def cut_with_joint index
+          @chunks[index][:text] =
+            @chunks[index][:text][0..(@remaining_chars - @joint.size - 1)]
+          @chunks[index][:text] += @joint
+        end
+
+        def replace_with_joint index
+          @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
+        end
+      end
+    end
+  end
+end

data/lib/card/director_register.rb

@@ -60,6 +60,11 @@ class Card
       def delete director
         return unless @directors
         @directors.delete director.card
+        director.delete
+      end
+
+      def to_s
+        directors.values.map(&:to_s).join "\n"
       end
     end
   end

data/lib/card/query/attributes.rb

@@ -163,14 +163,21 @@ class Card
         r = Reference.new(key, val, self)
         refjoin = Join.new(from: self, to: r, to_field: r.infield)
         joins << refjoin
-        if r.cardquery
-          join_cards r.cardquery, from: refjoin, from_field: r.outfield
-        end
+        restrict_reference r, refjoin if r.cardquery
         r.conditions.each do |condition|
           refjoin.conditions << "#{r.table_alias}.#{condition}"
         end
       end
 
+      def restrict_reference ref, refjoin
+        val = ref.cardquery
+        if (id = id_from_val(val))
+          add_condition "#{ref.table_alias}.#{ref.outfield} = #{id}"
+        else
+          join_cards val, from: refjoin, from_field: ref.outfield
+        end
+      end
+
       def conjunction val
         return unless [String, Symbol].member? val.class
         CONJUNCTIONS[val.to_sym]
@@ -183,15 +190,13 @@ class Card
 
         if sort_field == 'count'
           sort_by_count val, item
+        elsif (join_field = SORT_JOIN_TO_ITEM_MAP[item.to_sym])
+          sq = join_cards(val, to_field: join_field,
+                               side: 'LEFT',
+                               conditions_on_join: true)
+          @mods[:sort] ||= "#{sq.table_alias}.#{sort_field}"
         else
-          if (join_field = SORT_JOIN_TO_ITEM_MAP[item.to_sym])
-            sq = join_cards(val, to_field: join_field,
-                                 side: 'LEFT',
-                                 conditions_on_join: true)
-            @mods[:sort] ||= "#{sq.table_alias}.#{sort_field}"
-          else
-            raise BadQuery, "sort item: #{item} not yet implemented"
-          end
+          raise BadQuery, "sort item: #{item} not yet implemented"
         end
       end
 
@@ -204,7 +209,7 @@ class Card
             group: 'sort_join_field',
             superquery: self
           )
-          subselect = Query.new(val.merge return: 'id', superquery: self)
+          subselect = Query.new val.merge(return: 'id', superquery: self)
           cs.add_condition "referer_id in (#{subselect.sql})"
           # FIXME: - SQL generated before SQL phase
           cs.joins << Join.new(
@@ -248,7 +253,8 @@ class Card
       def join_cards val, opts={}
         conditions_on_join = opts.delete :conditions_on_join
         s = subquery
-        card_join = Join.new({ from: self, to: s }.merge opts)
+        join_opts = { from: self, to: s }.merge opts
+        card_join = Join.new join_opts
         joins << card_join unless opts[:from].is_a? Join
         s.conditions_on_join = card_join if conditions_on_join
         s.interpret val