wagn 1.12.7

data/lib/card/chunk.rb

@@ -0,0 +1,103 @@
+# -*- encoding : utf-8 -*-
+
+require 'uri/common'
+
+# 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 Card::Chunk
+  mattr_accessor :raw_list, :prefix_regexp_by_list, :prefix_map
+  @@raw_list, @@prefix_regexp_by_list, @@prefix_map = {}, {}, {}
+  
+  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
+    end
+    
+    def register_list key, list
+      raw_list[key] = list
+    end
+    
+    def find_class_by_prefix prefix
+      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
+    
+    def get_prefix_regexp chunk_list_key
+      prefix_regexp_by_list[chunk_list_key] ||= begin
+        chunk_types = raw_list[chunk_list_key].map { |chunkname| const_get chunkname }
+        prefix_res = chunk_types.map do |chunk_class|
+          chunk_class.config[:prefix_re]
+        end
+        /(?:#{ prefix_res * '|' })/m
+      end
+    end
+
+  end
+  
+  
+  #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 ]
+  register_list :references,                         [ :EscapedLiteral, :Include, :Link ]
+
+  
+  class Abstract
+    class_attribute :config
+    attr_reader :text, :process_chunk
+    
+    class << self
+      def full_match content, prefix=nil
+#        warn "attempting full match on #{content}.  class = #{self}"
+        content.match full_re( prefix )
+      end
+
+      def full_re prefix
+        config[:full_re]
+      end
+      
+      def context_ok? content, chunk_start
+        true
+      end
+    end
+
+    def initialize match, content
+      @text = match[0]
+      @processed = nil
+      @content = content
+      interpret match, content
+      self
+    end
+    
+    def interpret match_string, content, params
+      Rails.logger.info "no #interpret method found for chunk class: #{self.class}"
+    end
+    
+    def format
+      @content.format
+    end
+    
+    def card
+      @content.card
+    end
+
+    def to_s
+      @process_chunk || @processed || @text
+    end
+
+    def inspect
+      "<##{self.class}##{to_s}>"
+    end
+
+    def as_json(options={})
+      @process_chunk || @processed|| "not rendered #{self.class}, #{card and card.name}"
+    end
+  end
+  
+  Card.load_chunks
+end

data/lib/card/codename.rb

@@ -0,0 +1,47 @@
+# -*- encoding : utf-8 -*-
+
+class Card::Codename
+
+  @@codehash=nil
+
+  class << self
+    # returns codename for id and vice versa.  not in love with this api --efm
+    def [] key
+      if !key.nil?
+        key = key.to_sym unless Integer===key
+        codehash[key]
+      end
+    end
+
+    def codehash
+      @@codehash || load_hash
+    end
+
+    def reset_cache
+      @@codehash = nil
+    end
+
+    #only used in migration
+    def bootdata hash
+      @@codehash = hash
+    end
+
+
+    private
+
+    def load_hash
+      @@codehash = {}
+      sql = 'select id, codename from cards where codename is not NULL'
+      ActiveRecord::Base.connection.select_all(sql).each do |row|
+        #FIXME: remove duplicate checks, put them in other tools
+        code, cid = row['codename'].to_sym, row['id'].to_i
+        if @@codehash.has_key?(code) or @@codehash.has_key?(cid)
+          warn "dup code ID:#{cid} (#{@@codehash[code]}), CD:#{code} (#{@@codehash[cid]})"
+        end
+        @@codehash[code] = cid; @@codehash[cid] = code
+      end
+
+      @@codehash
+    end
+  end
+end

data/lib/card/constant.rb

@@ -0,0 +1,20 @@
+module Card::Constant
+  ID_CONST_ALIAS = {
+    :anon         => :anonymous,
+    :auth         => :anyone_signed_in,
+    :admin        => :administrator
+  }
+
+  def const_missing const
+    if const.to_s =~ /^([A-Z]\S*)ID$/ and code=$1.underscore.to_sym
+      code = ID_CONST_ALIAS[code] || code
+      if card_id = Card::Codename[code]
+        const_set const, card_id
+      else
+        raise "Missing codename #{code} (#{const}) #{caller*"\n"}"
+      end
+    else
+      super
+    end
+  end
+end

data/lib/card/content.rb

@@ -0,0 +1,206 @@
+# -*- encoding : utf-8 -*-
+
+require_dependency 'card/chunk'
+# you could make the case that Card::Chunk should be Card::Content::Chunk, which would make the above unnecessary (but create noise elsewhere)
+
+class Card
+  class Content < SimpleDelegator
+    attr_reader :revision, :format, :chunks
+
+    def initialize content, format_or_card
+      @format = if Card===format_or_card
+        Format.new format_or_card, :format=>nil
+      else
+        format_or_card
+      end
+
+      unless Array === content
+        content = parse_content content
+      end
+      super content
+    end
+
+    def card
+      format.card
+    end
+
+    def to_s
+      case __getobj__
+      when Array;    map(&:to_s)*''
+      when String;   __getobj__
+      when NilClass; raise "Nil Card::Content"
+      else           __getobj__.to_s
+      end
+    end
+
+    def inspect
+      "<#{__getobj__.class}:#{card}:#{self}>"
+    end
+
+    def each_chunk
+      return enum_for(:each_chunk) unless block_given?
+      case __getobj__
+        when Hash;   each { |k,v| yield v if Chunk::Abstract===v }
+        when Array;  each { |e|   yield e if Chunk::Abstract===e }
+        when String; # strings are all parsed in self, so no chunks in a String
+        else
+          Rails.logger.warn "error self is unrecognized type #{self.class} #{self.__getobj__.class}"
+      end
+    end
+
+    def find_chunks chunk_type
+      each_chunk.select { |chunk| chunk.kind_of?(chunk_type) }
+    end
+
+    def process_content_object &block
+      each_chunk { |chunk| chunk.process_chunk &block }
+      self
+    end
+
+    def parse_content content
+      @chunks = []
+
+      if String===content
+        position = last_position = 0
+        prefix_regexp = Chunk.get_prefix_regexp card.chunk_list
+        interval_string = ''
+
+        while prefix_match = content[position..-1].match( prefix_regexp )
+          prefix = prefix_match[0]                                                 # prefix of matched chunk
+          chunk_start = prefix_match.begin(0) + position                           # content index of beginning of chunk
+
+          if prefix_match.begin(0) > 0                                             # if matched chunk is not beginning of test string
+            interval_string += content[ position..chunk_start-1 ]                  # hold onto the non-chunk part of the string
+          end
+
+          chunk_class = Chunk.find_class_by_prefix prefix                          # get the chunk class from the prefix
+          match, offset = chunk_class.full_match content[chunk_start..-1], prefix  # see whether the full chunk actually matches (as opposed to bogus prefix)
+          context_ok = chunk_class.context_ok? content, chunk_start                # make sure there aren't contextual reasons for ignoring this chunk
+          position = chunk_start                                                   # move scanning position up to beginning of chunk
+
+          if match                                                                 # we have a chunk match
+            position += ( match.end(0) - offset.to_i )                             # move scanning position up to end of chunk
+            if context_ok                                                          #
+              @chunks << interval_string if interval_string.size > 0                # add the nonchunk string to the chunk list
+              @chunks << chunk_class.new( match, self )                             # add the chunk to the chunk list
+              interval_string = ''                                                 # reset interval string for next go-round
+              last_position = position                                             # note that the end of the chunk was the last place where a chunk was found (so far)
+            end
+          else
+            position += 1                                                          # no match.  look at the next character
+          end
+
+          if !match || !context_ok
+            interval_string += content[chunk_start..position-1]                    # moving beyond the alleged chunk.  append failed string to "nonchunk" string
+          end
+        end
+      end
+
+      if chunks.any?
+        if last_position < content.size
+          remainder = content[ last_position..-1]                                  # handle any leftover nonchunk string at the end of content
+          @chunks << remainder
+        end
+        chunks
+      else
+        content
+      end
+    end
+
+
+
+
+    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' => ['href', 'title', 'target' ],
+      'img' => ['src', 'alt', 'title'],
+      'code' => ['lang'],
+      'blockquote' => ['cite']
+    )
+
+    if Wagn.config.allow_inline_styles
+      ALLOWED_TAGS['table'] += %w[ cellpadding align border cellspacing ]
+    end
+
+    ALLOWED_TAGS.each_key {|k|
+      ALLOWED_TAGS[k] << 'class'
+      ALLOWED_TAGS[k] << 'style' if Wagn.config.allow_inline_styles
+      ALLOWED_TAGS[k].freeze
+    }
+    ALLOWED_TAGS.freeze
+
+    ATTR_VALUE_RE = [ /(?<=^')[^']+(?=')/, /(?<=^")[^"]+(?=")/, /\S+/ ]
+
+    class << self
+
+      ## Method that cleans the String of HTML tags
+      ## and attributes outside of the allowed list.
+
+      # this has been hacked for wagn to allow classes if
+      # the class begins with "w-"
+      def clean!( string, tags = ALLOWED_TAGS )
+        string.gsub( /<(\/*)(\w+)([^>]*)>/ ) do
+          raw = $~
+          tag = raw[2].downcase
+          if attrs = tags[tag]
+            "<#{raw[1]}#{
+              attrs.inject([tag]) do |pcs, attr|
+                q='"'
+                rest_value=nil
+                if raw[3] =~ /\b#{attr}\s*=\s*(?=(.))/i
+                  rest_value = $'
+                  idx = %w{' "}.index($1) and q = $1
+                  re = ATTR_VALUE_RE[ idx || 2 ]
+                  if match = rest_value.match(re)
+                    rest_value = match[0]
+                    if attr == 'class'
+                      rest_value = rest_value.split(/\s+/).find_all {|s| s=~/^w-/i}*' '
+                    end
+                  end
+                end
+                pcs << "#{attr}=#{q}#{rest_value}#{q}" unless rest_value.blank?
+                pcs
+              end * ' '
+            }>"
+          else
+            " "
+          end
+        end.gsub(/<\!--.*?-->/, '')
+      end
+
+      def truncatewords_with_closing_tags(input, words = 25, truncate_string = "...")
+        if input.nil? then return end
+        wordlist = input.to_s.split
+        l = words.to_i - 1
+        l = 0 if l < 0
+        wordstring = wordlist.length > l ? wordlist[0..l].join(" ") : input.to_s
+        # nuke partial tags at end of snippet
+        wordstring.gsub!(/(<[^\>]+)$/,'')
+
+        tags = []
+
+        # match tags with or without self closing (ie. <foo />)
+        wordstring.scan(/\<([^\>\s\/]+)[^\>]*?\>/).each { |t| tags.unshift(t[0]) }
+        # match tags with self closing and mark them as closed
+        wordstring.scan(/\<([^\>\s\/]+)[^\>]*?\/\>/).each { |t| if !(x=tags.index(t[0])).nil? then tags.slice!(x) end }
+        # match close tags
+        wordstring.scan(/\<\/([^\>\s\/]+)[^\>]*?\>/).each { |t|  if !(x=tags.rindex(t[0])).nil? then tags.slice!(x) end  }
+
+        tags.each {|t| wordstring += "</#{t}>" }
+
+        wordstring +='<span class="closed-content-ellipses">...</span>' if wordlist.length > l
+    #    wordstring += '...' if wordlist.length > l
+        wordstring.gsub! /<[\/]?br[\s\/]*>/, ' ' ## Also a hack -- get rid of <br>'s -- they make line view ugly.
+        wordstring.gsub! /<[\/]?p[^>]*>/, ' ' ## Also a hack -- get rid of <br>'s -- they make line view ugly.
+        wordstring
+      end
+
+    end
+  end
+end

data/lib/card/diff.rb

@@ -0,0 +1,317 @@
+# -*- encoding : utf-8 -*-
+module Card::Diff
+  
+  def diff(a, b)
+    DiffBuilder.new(a, b).build
+  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
+  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)
+      @old_version, @new_version = old_version, new_version
+      @content = []
+    end
+
+    def build
+      split_inputs_to_words
+      index_new_words
+      operations.each { |op| perform_operation(op) }
+      return @content.join
+    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))
+    end
+
+    def index_new_words
+      @word_indices = Hash.new { |h, word| h[word] = [] }
+      @new_words.each_with_index { |word, i| @word_indices[word] << i }
+    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
+          else
+            # this happens if the first few words are same in both versions
+            :none
+          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
+      end
+
+      operations
+    end
+
+    def matching_blocks
+      matching_blocks = []
+      recursively_find_matching_blocks(0, @old_words.size, 0, @new_words.size, matching_blocks)
+      matching_blocks
+    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
+      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
+          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
+      end
+      [match_in_old, match_in_new, match_size]
+    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
+      end
+      [match_in_old, match_in_new, match_size]
+    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')
+    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
+        end
+      end
+      if index_of_first_tag
+        return words.slice!(0...index_of_first_tag)
+      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
+          else
+            current_word << char
+          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}"
+        end
+      end
+      words << current_word unless current_word.empty?
+      words
+    end
+
+  end
+end