card 1.18.6 → 1.19.0

data/lib/card/cache/prepopulate.rb

@@ -0,0 +1,26 @@
+class Card
+  class Cache
+    # pre-populate cache for testing purposes
+    module Prepopulate
+      def restore
+        reset_soft
+        prepopulate
+      end
+
+      private
+
+      def prepopulate
+        return unless @prepopulating
+        soft = Card.cache.soft
+        @rule_cache ||= Card.rule_cache
+        @user_ids_cache ||= Card.user_ids_cache
+        @read_rule_cache ||= Card.read_rule_cache
+        @rule_keys_cache ||= Card.rule_keys_cache
+        soft.write "RULES", @rule_cache
+        soft.write "READRULES", @read_rule_cache
+        soft.write "USER_IDS", @user_ids_cache
+        soft.write "RULE_KEYS", @rule_keys_cache
+      end
+    end
+  end
+end

data/lib/card/cache/temporary.rb

@@ -1,38 +1,57 @@
-class Card::Cache::Temporary
-  attr_reader :store
-
-  def initialize
-    @store = {}
-  end
-
-  def read key
-    return unless @store.key? key
-    @store[key]
-  end
-
-  def write key, value
-    @store[key] = value
-  end
-
-  def fetch key, &_block
-    read(key) || write(key, yield)
-  end
-
-  def delete key
-    @store.delete key
-  end
-
-  def dump
-    @store.each do |k, v|
-      p "#{k} --> #{v.inspect[0..30]}"
+class Card
+  class Cache
+    # The {Temporary} cache is intended for a single request, script,
+    # migration, etc. It allows you to alter a card and then retrieve
+    # the card with those alterations intact _without_ saving those
+    # changes to the database.
+    #
+    # In practice, it's a set of Cache-like methods for using a
+    # simple Hash.
+    #
+    # Unlike the Persistent cache, the Temporary cache can handle objects with
+    # singleton classes.
+    class Temporary
+      attr_reader :store
+
+      def initialize
+        @store = {}
+      end
+
+      # @param key [String]
+      def read key
+        return unless @store.key? key
+        @store[key]
+      end
+
+      # @param key [String]
+      def write key, value
+        @store[key] = value
+      end
+
+      # @param key [String]
+      def fetch key, &_block
+        read(key) || write(key, yield)
+      end
+
+      # @param key [String]
+      def delete key
+        @store.delete key
+      end
+
+      def dump
+        @store.each do |k, v|
+          p "#{k} --> #{v.inspect[0..30]}"
+        end
+      end
+
+      def reset
+        @store = {}
+      end
+
+      # @param key [String]
+      def exist? key
+        @store.key? key
+      end
     end
   end
-
-  def reset
-    @store = {}
-  end
-
-  def exist? key
-    @store.key? key
-  end
 end

data/lib/card/cache/view_cache.rb

@@ -0,0 +1,103 @@
+class Card
+  class Cache
+    module ViewCache
+      class << self
+        SIZE = 500
+        LIMIT = 1000 # reduce cache size to SIZE if LIMIT is reached
+        CNT_KEY = "view_cache_cnt".freeze
+        FREQUENCY_KEY = "view_cache_frequency".freeze
+
+        def cache
+          Card::Cache[Card::Cache::ViewCache]
+        end
+
+        def fetch format, view, args, &block
+          return yield unless cacheable_view?(view, format)
+
+          key = cache_key view, format, args
+          update_cache_accounting! key
+
+          if Card.config.view_cache == "debug"
+            verbose_fetch key, &bloack
+          else
+            cache.fetch key, &block
+          end
+        end
+
+        def reset
+          cache.reset
+        end
+
+        private
+
+        def update_cache_accounting! key
+          unless cache.exist?(key)
+            increment_cached_views_cnt
+            reduce_cache if cached_views_cnt > LIMIT
+          end
+          increment_frequency key
+        end
+
+        def verbose_fetch
+          if cache.exist? key
+            "fetched from view cache: #{cache.read key}"
+          else
+            "written to view cache: #{cache.fetch(key, &block)}"
+          end
+        end
+
+        def increment_cached_views_cnt
+          cache.write(CNT_KEY, cached_views_cnt + 1)
+        end
+
+        def cached_views_cnt
+          cache.fetch(CNT_KEY) { 0 }
+        end
+
+        def reduce_cache
+          update_frequency do |freq|
+            cnts_with_key = freq.keys.map { |key| [freq[key], key] }
+            index = 1
+            SortedSet.new(cnts_with_key).each do |_cnt, key|
+              if index < (LIMIT - SIZE)
+                cache.delete(key)
+                freq.delete(key)
+              else
+                freq[key] = 0
+              end
+              index += 1
+            end
+          end
+        end
+
+        def update_frequency
+          freq = cache.read(FREQUENCY_KEY) || {}
+          yield(freq)
+          cache.write(FREQUENCY_KEY, freq)
+        end
+
+        def increment_frequency key
+          update_frequency do |freq|
+            freq[key] ||= 0
+            freq[key] += 1
+          end
+        end
+
+        def cache_key view, format, args
+          roles_key = Card::Auth.current.all_roles.sort.join "_"
+          args_key = Card::Cache.obj_to_key(args)
+          "%s#%s__args__%s__roles__%s" %
+            [format.card.key, view, args_key, roles_key]
+        end
+
+        def cacheable_view? view, format
+          Card.config.view_cache &&
+            format.view_caching? &&
+            format.main? &&
+            format.class == Format::HtmlFormat &&
+            (view == :open || view == :content)
+        end
+      end
+    end
+  end
+end

data/lib/card/codename.rb

@@ -1,67 +1,86 @@
 # -*- encoding : utf-8 -*-
-require_dependency 'card/cache'
-require_dependency 'card/name'
+require_dependency "card/cache"
+require_dependency "card/name"
 
 class Card
+  # {Card}'s names can be changed, and therefore names should not be directly
+  # mentioned in code, lest a name change break the application. Instead, a
+  # {Card} that needs specific code manipulations should be given a {Codename},
+  # a unique string identifier that will not change even if the card's name
+  # does.
+  #
+  # The {Codename} class provides a fast cache for this slow-changing data.
+  # Every process maintains a complete cache that is not frequently reset
+  #
+  # Generally speaking, _codenames_ are represented by Symbols, _names_ are
+  # Strings, and _ids_ are Integers.
+  #
   class Codename
-    @@codehash = nil
-
     class << self
-      # returns codename for id and vice versa.  not in love with this api --efm
+      # returns codename for id and id for codename
+      # @param key [Integer, String]
+      # @return [String, Integer]
       def [] key
         return if key.nil?
-        key = key.to_sym unless key.is_a? Integer
-        codehash[key]
+        codehash[key.is_a?(Integer) ? key : key.to_sym]
       end
 
+      # a Hash in which String keys have Integer values and vice versa
+      # @return [Hash]
       def codehash
-        @@codehash || load_hash
+        @codehash ||= load_codehash
       end
 
+      # clear cache both locally and in cache
       def reset_cache
-        @@codehash = nil
-        cache.write 'CODEHASH', nil
-      end
-
-      # only used in migration
-      def bootdata hash
-        @@codehash = hash
+        @codehash = nil
+        Card.cache.delete "CODEHASH"
       end
 
       private
 
-      def cache
-        Card::Cache[Codename]
-      end
-
+      # iterate through every card with a codename
+      # @yieldparam codename [Symbol]
+      # @yieldparam id [Integer]
       def each_codenamed_card
-        sql = 'select id, codename from cards where codename is not NULL'
+        sql = "select id, codename from cards where codename is not NULL"
         ActiveRecord::Base.connection.select_all(sql).each do |row|
-          yield row['codename'].to_sym, row['id'].to_i
+          yield row["codename"].to_sym, row["id"].to_i
         end
       end
 
+      # @todo remove duplicate checks here; should be caught upon creation
       def check_duplicates codehash, codename, card_id
-        # FIXME: remove duplicate checks here; should be caught upon creation
         return unless codehash.key?(codename) || codehash.key?(card_id)
         warn "dup code ID:#{card_id} (#{codehash[codename]}), " \
              "CD:#{codename} (#{codehash[card_id]})"
       end
 
-      def load_hash
-        @@codehash = cache.read('CODEHASH') || begin
-          codehash = {}
-          each_codenamed_card do |codename, card_id|
-            check_duplicates codehash, codename, card_id
-            codehash[codename] = card_id
-            codehash[card_id] = codename
-          end
-          cache.write 'CODEHASH', codehash
+      # generate Hash for @codehash and put it in the cache
+      def load_codehash
+        Card.cache.fetch("CODEHASH") do
+          generate_codehash
+        end
+      end
+
+      def generate_codehash
+        hash = {}
+        each_codenamed_card do |codename, card_id|
+          check_duplicates hash, codename, card_id
+          hash[codename] = card_id
+          hash[card_id] = codename
         end
+        hash
       end
     end
   end
 
+  # If a card has the codename _example_, then Card::ExampleID should
+  # return the id for that card. This method makes that help.
+  #
+  # @param const [Const]
+  # @return [Integer]
+  # @raise error if codename is missing
   def self.const_missing const
     if const.to_s =~ /^([A-Z]\S*)ID$/ &&
        (code = Regexp.last_match(1).underscore.to_sym)

data/lib/card/content.rb

@@ -1,185 +1,97 @@
 # -*- encoding : utf-8 -*-
 
-require_dependency 'card/content/chunk'
-require_dependency 'card/content/parser'
+require_dependency "card/content/chunk"
+require_dependency "card/content/parser"
+require_dependency "card/content/clean"
+require_dependency "card/content/truncate"
 
 class Card
+  # Content objects support the parsing of content strings into arrays that
+  # contain semantically meaningful "chunks" like nests, links, urls, etc.
+  #
+  # Each chunk has an object whose class inherits from {Card::Chunk::Abstract}
+  #
   class Content < SimpleDelegator
+    extend Card::Content::Clean
+    extend Card::Content::Truncate
+
     attr_reader :revision, :format, :chunks, :opts
 
+    # initialization parses String, detects chunks
+    # @param content [String]
+    # @param format_or_card [Card::Format or Card]
+    # @param opts [Hash]
+    # @option opts [Symbol] :chunk_list - name of registered list of chunk
+    # classes to be used in parsing
     def initialize content, format_or_card, opts={}
-      @format =
-        if format_or_card.is_a?(Card)
-          Format.new format_or_card, format: nil
-        else
-          format_or_card
-        end
-      @opts = opts || {}
-
-      @chunks = Parser.new(chunk_list).parse(content, self)
+      @format = resolve_format format_or_card
+      opts ||= {}
+      chunk_list = opts[:chunk_list] || @format.chunk_list
+      @chunks = Parser.new(chunk_list, self).parse(content)
       super(@chunks.any? ? @chunks : content)
     end
 
+    # Content must be associated with a Format object, which in turn must be
+    # associated with a Card
+    # @return [Card]
     def card
-      format.card
-    end
-
-    def chunk_list
-      @opts[:chunk_list] || @format.chunk_list
-    end
-
-    def to_s
-      case __getobj__
-      when Array    then map(&:to_s) * ''
-      when String   then __getobj__
-      when NilClass then '' # 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  then each_value { |v| yield v if v.is_a?(Chunk::Abstract) }
-      when Array then each       { |e| yield e if e.is_a?(Chunk::Abstract) }
-      when String # noop. strings are parsed in self, so no chunks in a String
-      else
-        Rails.logger.warn 'error self is unrecognized type' \
-                          " #{self.class} #{__getobj__.class}"
-      end
+      @format.card
     end
 
+    # Find all chunks of a given type
+    # @param chunk_type [Chunk Class]
+    # @return [Array of Chunk instances]
     def find_chunks chunk_type
       each_chunk.select { |chunk| chunk.is_a?(chunk_type) }
     end
 
+    # sends &block to #process_chunk on each Chunk object
     def process_each_chunk &block
       each_chunk { |chunk| chunk.process_chunk(&block) }
-      self
-    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' => %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.freeze
-
-    ATTR_VALUE_RE = [/(?<=^')[^']+(?=')/, /(?<=^")[^"]+(?=")/, /\S+/].freeze
-
-    class << self
-      ## Method that cleans the String of HTML tags
-      ## and attributes outside of the allowed list.
-
-      # this has been hacked for card to allow classes if
-      # the class begins with "w-"
-      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
+    def each_chunk
+      return enum_for(:each_chunk) unless block_given?
 
-      def process_attribute attr, all_attributes
-        return ['"', nil] unless all_attributes =~ /\b#{attr}\s*=\s*(?=(.))/i
-        q = '"'
-        rest_value = $'
-        (idx = %w(' ").index(Regexp.last_match(1))) &&
-          (q = Regexp.last_match(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+/).select { |s| s =~ /^w-/i }.join(' ')
-          end
+      iterator =
+        case __getobj__
+        when Hash   then :each_value
+        when Array  then :each
+        when String then return # no chunks
+        else
+          Rails.logger.warn "unrecognized type for #each_chunk: " \
+                            " #{self.class} #{__getobj__.class}"
+          return
         end
-        [q, rest_value]
-      end
+      send(iterator) { |item| yield item if item.is_a?(Chunk::Abstract) }
+    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
+    # convert content to String.
+    # the common cases here are that either
+    #
+    # - (a) content is already a String, or
+    # - (b) it's an Array that needs to be iterated over and converted into a
+    # a string by running to_s on each item.
+    def to_s
+      case __getobj__
+      when Array    then map(&:to_s) * ""
+      when String   then __getobj__
+      when NilClass then "" # raise "Nil Card::Content"
+      else               __getobj__.to_s
       end
+    end
 
-      def truncatewords_with_closing_tags input, words=25,
-                                          _truncate_string='...'
-        return if input.nil?
-        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 = find_tags wordstring
-        tags.each { |t| wordstring += "</#{t}>" }
-
-        if wordlist.length > l
-          wordstring += '<span class="closed-content-ellipses">...</span>'
-        end
-
-        # wordstring += '...' if wordlist.length > l
-        wordstring.gsub! %r{<[/]?br[\s/]*>}, ' '
-        # Also a hack -- get rid of <br>'s -- they make line view ugly.
-        wordstring.gsub! %r{<[/]?p[^>]*>}, ' '
-        ## Also a hack -- get rid of <br>'s -- they make line view ugly.
-        wordstring
-      end
+    def inspect
+      "<#{__getobj__.class}:#{card}:#{self}>"
+    end
 
-      def find_tags wordstring
-        tags = []
+    private
 
-        # match tags with or without self closing (ie. <foo />)
-        wordstring.scan(%r{\<([^\>\s/]+)[^\>]*?\>}).each do |t|
-          tags.unshift(t[0])
-        end
-        # match tags with self closing and mark them as closed
-        wordstring.scan(%r{\<([^\>\s/]+)[^\>]*?/\>}).each do |t|
-          next unless (x = tags.index(t[0]))
-          tags.slice!(x)
-        end
-        # match close tags
-        wordstring.scan(%r{\</([^\>\s/]+)[^\>]*?\>}).each do |t|
-          next unless (x = tags.rindex(t[0]))
-          tags.slice!(x)
-        end
-        tags
+    def resolve_format format_or_card
+      if format_or_card.is_a?(Card)
+        Format.new format_or_card, format: nil
+      else
+        format_or_card
       end
     end
   end