card 1.18.6 → 1.19.0

data/lib/card/content/chunk.rb

@@ -1,38 +1,55 @@
 # -*- encoding : utf-8 -*-
 
-require 'uri/common'
+require "uri/common"
 
-class Card #::Content
+class Card
   class Content < SimpleDelegator
     # A chunk is a pattern of text that can be protected
     # and interrogated by a format. Each Chunk class has a
     # +pattern+ that states what sort of text it matches.
     # Chunks are initalized by passing in the result of a
     # match by its pattern.
+    #
     module Chunk
-      mattr_accessor :raw_list, :prefix_regexp_by_list, :prefix_map
+      mattr_accessor :raw_list, :prefix_regexp_by_list,
+                     :prefix_map_by_list, :prefix_map_by_chunkname
       @@raw_list = {}
       @@prefix_regexp_by_list = {}
-      @@prefix_map = {}
+      @@prefix_map_by_chunkname = {}
+      @@prefix_map_by_list = Hash.new { |h, k| h[k] = {} }
 
       class << self
         def register_class klass, hash
           klass.config = hash.merge class: klass
           prefix_index = hash[:idx_char] || :default
           # ^ this is gross and needs to be moved out.
-          prefix_map[prefix_index] = klass.config
+
+          klassname = klass.name.split("::").last.to_sym
+          prefix_map_by_chunkname[klassname] = { prefix_index => klass.config }
+          raw_list.each do |key, list|
+            next unless list.include? klassname
+            prefix_map_by_list[key].merge! prefix_map_by_chunkname[klassname]
+          end
         end
 
         def register_list key, list
           raw_list[key] = list
+          prefix_map_by_list[key] =
+            list.each_with_object({}) do |chunkname, h|
+              next unless (p_map = prefix_map_by_chunkname[chunkname])
+              h.merge! p_map
+            end
+          prefix_map_by_list[key]
         end
 
-        def find_class_by_prefix prefix
+        def find_class_by_prefix prefix, chunk_list_key=:default
+          prefix_map = prefix_map_by_list[chunk_list_key]
           config = prefix_map[prefix[0, 1]] ||
                    prefix_map[prefix[-1, 1]] ||
                    prefix_map[:default]
           # prefix identified by first character, last character, or default.
           # a little ugly...
+
           config[:class]
         end
 
@@ -47,7 +64,8 @@ class Card #::Content
         end
       end
 
-      # not sure whether this is best place.  Could really happen almost anywhere
+      # not sure whether this is best place.
+      # Could really happen almost anywhere
       # (even before chunk classes are loaded).
       register_list :default, [
         :URI, :HostURI, :EmailURI, :EscapedLiteral, :Include, :Link
@@ -76,7 +94,7 @@ class Card #::Content
         end
 
         def reference_code
-          'I'
+          "I"
         end
 
         def initialize match, content
@@ -88,7 +106,7 @@ class Card #::Content
         end
 
         def interpret _match_string, _content, _params
-          Rails.logger.info 'no #interpret method found for chunk class: ' \
+          Rails.logger.info "no #interpret method found for chunk class: " \
                             "#{self.class}"
         end
 
@@ -115,5 +133,5 @@ class Card #::Content
       end
     end
   end
-  Card::Loader.load_chunks
+  Card::Mod::Loader.load_chunks
 end

data/lib/card/content/clean.rb

@@ -0,0 +1,84 @@
+class Card
+  class Content
+    # tools for cleaning content, especially for restricing unwanted HTML
+    module Clean
+      allowed_tags = {}
+      %w(
+        br i b pre cite caption strong em ins sup sub del ol hr ul li p
+        div h1 h2 h3 h4 h5 h6 span table tr td th tbody thead tfoot
+      ).each { |tag| allowed_tags[tag] = [] }
+
+      # allowed attributes
+      allowed_tags.merge!(
+        "a" => %w(href title target),
+        "img" => %w(src alt title),
+        "code" => ["lang"],
+        "blockquote" => ["cite"]
+      )
+
+      if Card.config.allow_inline_styles
+        allowed_tags["table"] += %w(cellpadding align border cellspacing)
+      end
+
+      allowed_tags.each_key do |k|
+        allowed_tags[k] << "class"
+        allowed_tags[k] << "style" if Card.config.allow_inline_styles
+        allowed_tags[k]
+      end
+
+      ALLOWED_TAGS = allowed_tags.freeze
+
+      ATTR_VALUE_RE = [/(?<=^')[^']+(?=')/, /(?<=^")[^"]+(?=")/, /\S+/].freeze
+
+      ## Method that cleans the String of HTML tags
+      ## and attributes outside of the allowed list.
+      def clean! string, tags=ALLOWED_TAGS
+        string.gsub(%r{<(/*)(\w+)([^>]*)>}) do
+          raw = $LAST_MATCH_INFO
+          tag = raw[2].downcase
+          if (attrs = tags[tag])
+            html_attribs =
+              attrs.each_with_object([tag]) do |attr, pcs|
+                q, rest_value = process_attribute attr, raw[3]
+                pcs << "#{attr}=#{q}#{rest_value}#{q}" unless rest_value.blank?
+              end * " "
+            "<#{raw[1]}#{html_attribs}>"
+          else
+            " "
+          end
+        end.gsub(/<\!--.*?-->/, "")
+      end
+
+      if Card.config.space_last_in_multispace
+        def clean_with_space_last! string, tags=ALLOWED_TAGS
+          cwo = clean_without_space_last!(string, tags)
+          cwo.gsub(/(?:^|\b) ((?:&nbsp;)+)/, '\1 ')
+        end
+        alias_method_chain :clean!, :space_last
+      end
+
+      def process_attribute attrib, all_attributes
+        return ['"', nil] unless all_attributes =~ /\b#{attrib}\s*=\s*(?=(.))/i
+        q = '"'
+        rest_value = $'
+        if (idx = %w(' ").index Regexp.last_match(1))
+          q = Regexp.last_match(1)
+        end
+        reg_exp = ATTR_VALUE_RE[idx || 2]
+        rest_value = process_attribute_match rest_value, reg_exp, attrib
+        [q, rest_value]
+      end
+
+      # NOTE allows classes beginning with "w-" (deprecated)
+      def process_attribute_match rest_value, reg_exp, attrib
+        return rest_value unless (match = rest_value.match reg_exp)
+        rest_value = match[0]
+        if attrib == "class"
+          rest_value.split(/\s+/).select { |s| s =~ /^w-/i }.join(" ")
+        else
+          rest_value
+        end
+      end
+    end
+  end
+end

data/lib/card/content/diff.rb

@@ -0,0 +1,71 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  class Content
+    class Diff
+      class << self
+        def complete a, b, opts={}
+          Card::Content::Diff.new(a, b, opts).complete
+        end
+
+        def summary a, b, opts={}
+          Card::Content::Diff.new(a, b, opts).summary
+        end
+
+        def render_added_chunk text
+          "<ins class='diffins diff-green'>#{text}</ins>"
+        end
+
+        def render_deleted_chunk text, _count=true
+          "<del class='diffdel diff-red'>#{text}</del>"
+        end
+      end
+
+      attr_reader :result
+      delegate :summary, :complete, to: :result
+
+      # 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={}
+        @result = Result.new opts[:summary]
+        if new_version
+          lcs_opts = lcs_opts_for_format opts[:format]
+          LCS.new(lcs_opts).run(old_version, new_version, @result)
+        end
+      end
+
+      def red?
+        @result.dels_cnt > 0
+      end
+
+      def green?
+        @result.adds_cnt > 0
+      end
+
+      private
+
+      def lcs_opts_for_format format
+        opts = {}
+        case format
+        when :html
+          opts[:exclude] = /^</
+        when :text
+          opts[:reject] =  /^</
+          opts[:postprocess] = proc { |word| word.gsub("\n", "<br>") }
+        when :pointer
+          opts[:preprocess] = proc { |word| word.gsub("[[", "").gsub("]]", "") }
+        else # :raw
+          opts[:preprocess] = proc { |word| CGI.escapeHTML(word) }
+        end
+        opts
+      end
+    end
+  end
+end

data/lib/card/content/diff/lcs.rb

@@ -0,0 +1,94 @@
+require_dependency "card/content/diff/processor"
+
+class Card
+  class Content
+    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
+            processor = Processor.new old_words, new_words, old_ex, new_ex
+            processor.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
+      end
+    end
+  end
+end

data/lib/card/content/diff/processor.rb

@@ -0,0 +1,161 @@
+class Card
+  class Content
+    class Diff
+      class LCS
+        # Compares two lists of chunks and generates a diff
+        class Processor
+          def initialize old_words, new_words, old_excludees, new_excludees
+            @adds = []
+            @dels = []
+            @words = { old: old_words, new: new_words }
+            @excludees =
+              ExcludeeIterator.old_and_new old_excludees, new_excludees
+          end
+
+          def run result
+            @result = result
+            prev_action = nil
+            ::Diff::LCS.traverse_balanced(@words[:old], @words[:new]) do |word|
+              if prev_action
+                interpret_action prev_action, word
+              else
+                write_excludees
+              end
+              process_element word.old_element, word.new_element, word.action
+              prev_action = word.action
+            end
+            write_all
+            @result
+          end
+
+          def interpret_action prev_action, word
+            if (prev_action == word.action) ||
+               (prev_action == "-" && word.action == "!") ||
+               (prev_action == "!" && word.action == "+")
+              handle_action word.action
+            else
+              write_all
+            end
+          end
+
+          def handle_action action
+            case action
+            when "-" then del_old_excludees
+            when "+" then add_new_excludees
+            when "!" then
+              del_old_excludees
+              add_new_excludees
+            else
+              write_excludees
+            end
+          end
+
+          def write_all
+            write_dels
+            write_adds
+            write_excludees
+          end
+
+          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
+            @excludees[:old].scan_and_record(@dels) do |element|
+              write_dels
+              @result.write_excluded_chunk element
+            end
+          end
+
+          def add_new_excludees
+            @excludees[:new].scan_and_record(@adds) do |element|
+              write_adds
+              @result.complete << element
+            end
+          end
+
+          def process_element old_element, new_element, action
+            case action
+            when "-" then minus old_element
+            when "+" then 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
+
+        # support class for LCS::Processor
+        class ExcludeeIterator
+          def self.old_and_new old_excludees, new_excludees
+            {
+              old: new(old_excludees),
+              new: new(new_excludees)
+            }
+          end
+
+          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
+
+          def scan_and_record record_array
+            while (ex = self.next)
+              if ex[:type] == :disjunction
+                record_array << ex[:element]
+              else
+                yield ex[:element]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end