card 1.99.2 → 1.100.0

data/mod/core/chunk/{literal.rb → escaped_literal.rb}

@@ -19,7 +19,7 @@ class Card
         end
 
         def interpret match, _content
-          @process_chunk = match[0].sub(/^\\(.)/, '<span>\\1</span>')
+          @process_chunk = match[0].sub(/^\\(.)/, format.escape_literal('\1'))
         end
       end
     end

data/mod/core/chunk/keep_escaped_literal.rb

@@ -0,0 +1,26 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  class Content
+    module Chunk
+      # These are basic chunks that have a pattern and can be protected.
+      # This chunk is used for markdown processing to ensure that
+      # the escaping survives the markdown rendering.
+      class KeepEscapedLiteral < Abstract
+        FULL_RE = { "[" => /\A\\\[\[[^\]]*\]\]/,
+                    "{" => /\A\\\{\{[^\}]*\}\}/ }.freeze
+        Card::Content::Chunk.register_class self,
+                                            prefix_re: '\\\\(?:\\[\\[|\\{\\{)',
+                                            idx_char:  '\\'
+
+        def self.full_re prefix
+          FULL_RE[prefix[1, 1]]
+        end
+
+        def interpret match, _content
+          @process_chunk = match[0].sub(/^\\(.)/, '\\\\\\\\\1')
+        end
+      end
+    end
+  end
+end

data/mod/core/chunk/uri.rb

@@ -89,7 +89,7 @@ module Card::Content::Chunk
   # FIXME: DRY, merge these two into one class
   class EmailURI < URI
     PREPEND_STR = "mailto:".freeze
-    EMAIL = '[a-zA-Zd](?:[-a-zA-Zd]*[a-zA-Zd])?\\@'.freeze
+    EMAIL = '[a-zA-Z\\d](?:[-a-zA-Z\\d.]*[a-zA-Z\\d])?\\@'.freeze
 
     Card::Content::Chunk.register_class(
       self, prefix_re: "(?:(?!#{REJECTED_PREFIX_RE})#{EMAIL})\\b",
@@ -129,7 +129,7 @@ module Card::Content::Chunk
     # TLDS = "(?:#{GENERIC})"
 
     PREPEND_STR = "http://".freeze
-    HOST = "(?:[a-zA-Z\d](?:[-a-zA-Z\d]*[a-zA-Z\d])?\\.)+#{TLDS}".freeze
+    HOST = "(?:[a-zA-Z\\d](?:[-a-zA-Z\\d]*[a-zA-Z\\d])?\\.)+#{TLDS}".freeze
 
     Card::Content::Chunk.register_class(
       self, prefix_re: "(?:(?!#{REJECTED_PREFIX_RE})#{HOST})\\b",

data/mod/core/format/html_format.rb

@@ -28,6 +28,10 @@ class Card
         :bar
       end
 
+      def escape_literal literal
+        "<span>#{literal}</span>"
+      end
+
       def mime_type
         "text/html"
       end

data/mod/core/lib/card/fetch.rb

@@ -0,0 +1,54 @@
+class Card
+  # retrieve card from cache or database, or (where needed) instantiate new card
+  class Fetch
+    include Retrieve
+    include Results
+    include Store
+
+    attr_reader :card, :mark, :opts
+
+    # see arg options in all/fetch
+    def initialize *args
+      normalize_args args
+      absolutize_mark
+      validate_opts!
+    end
+
+    def retrieve_or_new
+      retrieve_existing
+      update_cache
+      results
+    end
+
+    def local_only?
+      opts[:local_only]
+    end
+
+    def skip_modules?
+      opts[:skip_modules]
+    end
+
+    def normalize_args args
+      @opts = args.last.is_a?(Hash) ? args.pop : {}
+      @mark = Card.id_or_name args
+    end
+
+    def absolutize_mark
+      return unless mark.name? && (supercard = opts.dig(:new, :supercard))
+      @mark = mark.absolute_name supercard.name
+    end
+
+    def validate_opts!
+      return unless opts[:new] && opts[:skip_virtual]
+      raise Card::Error, "fetch called with new args and skip_virtual"
+    end
+
+    def look_in_trash?
+      @opts[:look_in_trash]
+    end
+
+    def skip_type_lookup?
+      opts[:skip_virtual] || opts[:skip_type_lookup] # || opts[:new]
+    end
+  end
+end

data/mod/core/lib/card/fetch/results.rb

@@ -0,0 +1,125 @@
+class Card
+  class Fetch
+    # polishing fetch results
+    module Results
+      def results
+        return if card.nil?
+        card.new_card? ? new_result_card : finalize_result_card
+      end
+
+      def finalize_result_card
+        card.include_set_modules unless skip_modules?
+        card
+      end
+
+      def new_result_card
+        with_new_card do
+          finalize_result_card
+          # must include_set_modules before checking `card.known?`,
+          # in case, eg, set modules override #virtual?
+          card if new_opts || card.known?
+        end
+      end
+
+      def with_new_card
+        if new_opts
+          quick_renew || renew
+        elsif opts[:skip_virtual]
+          return nil
+        else
+          assign_name_from_mark
+        end
+        yield
+      end
+
+      def renew
+        return if new_opts.blank?
+        # Rails.logger.info "renewing: #{mark}, #{new_opts}"
+        @card = card.dup
+        @card.newish newish_opts
+      end
+
+      def newish_opts
+        hash = new_opts.clone.reverse_merge name: mark
+        if (content = assignable_content(hash.delete(:default_content)))
+          hash[:content] = content
+        end
+        hash[:type_lookup] = :force if @force_type_lookup
+        hash
+      end
+
+      def quick_renew
+        return false unless quick_renew?
+
+        # Rails.logger.info "QUICK renewing: #{mark}, #{new_opts}"
+        update_supercard
+        assign_name_from_mark
+        true
+      end
+
+      def update_supercard
+        return unless (sc = new_opts[:supercard])
+        @card.supercard = sc
+        @card.update_superleft @card.name
+      end
+
+      def quick_renew?
+        return true if new_opts.blank?
+        return false if type_change? || name_change?
+        return false if fancy_renew?
+        quick_content
+        true
+      end
+
+      # contains subcards, etc, that quick_renew can't handle
+      def fancy_renew?
+        test_opts = new_opts.slice :supercard, :name, :type_id, :type, :type_code,
+                                   :content, :default_content
+        new_opts.keys.size > test_opts.keys.size
+      end
+
+      def assignable_content default_content
+        new_opts[:content] || (@card.db_content.blank? && default_content)
+      end
+
+      def quick_content
+        return unless (content = assignable_content(new_opts[:default_content]))
+        @card.content = content
+      end
+
+      def name_change?
+        return false unless (new_name = new_opts[:name]&.to_name)
+        return false if new_name.relative? && mark.name? && mark.absolute?
+        new_name.to_s != @card.name.to_s
+      end
+
+      def type_change?
+        return true if @card.type_id.nil?
+        type_id = type_id_from_new_opts
+        return true if !type_id && supercard_might_change_type?
+        type_id && (type_id != @card.type_id)
+      end
+
+      def type_id_from_new_opts
+        type_id = new_opts[:type_id] || new_opts[:type] || new_opts[:type_code]&.to_sym
+        type_id.is_a?(Symbol) ? Codename.id(type_id) : type_id
+      end
+
+      def supercard_might_change_type?
+        # ...via type_plus_right rule
+        sc = new_opts[:supercard]
+        @force_type_lookup = sc&.new? && (sc.type_id != sc.default_type_id)
+      end
+
+      def new_opts
+        @new_opts ||= opts[:new]
+      end
+
+      def assign_name_from_mark
+        return if opts[:local_only]
+        return unless mark&.to_s != card.name
+        card.name = mark.to_s
+      end
+    end
+  end
+end

data/mod/core/lib/card/fetch/retrieve.rb

@@ -0,0 +1,56 @@
+class Card
+  class Fetch
+    # retrieval and instantiation methods for Card::Fetch
+    module Retrieve
+      # look for card in cache.  if that doesn't work, look in database
+      def retrieve_existing
+        return unless mark.present?
+        retrieve_from_cache || retrieve_from_db
+      end
+
+      def retrieve_from_cache
+        @card = Card.send "retrieve_from_cache_by_#{mark_type}",
+                          mark_value, @opts[:local_only]
+        @card = nil if card&.new? && look_in_trash?
+        # don't return cached cards if looking in trash -
+        # we want the db version
+        card
+      end
+
+      def retrieve_from_db
+        query = retrieval_from_db_query
+        @card = query ? Card.where(query).take : nil
+        @cache_ready = true if card.present? && !card.trash
+        card
+      end
+
+      def retrieval_from_db_query
+        return unless (query = retrieval_from_db_query_base)
+        query[:trash] = false unless look_in_trash?
+        query
+      end
+
+      def retrieval_from_db_query_base
+        if mark_type == :key && mark.simple?
+          { key: mark_value }
+        elsif (id = id_from_mark)
+          { id: id }
+        end
+      end
+
+      def id_from_mark
+        mark_type == :id ? mark_value : Lexicon.id(mark_value)
+      end
+
+      # In both the cache and the db, ids and keys are used to retrieve card data.
+      # These methods identify the kind of mark to use and its value
+      def mark_type
+        @mark_type ||= mark.is_a?(Integer) ? :id : :key
+      end
+
+      def mark_value
+        @mark_value ||= mark.is_a?(Integer) ? mark : mark.key
+      end
+    end
+  end
+end

data/mod/core/lib/card/fetch/store.rb

@@ -0,0 +1,66 @@
+class Card
+  class Fetch
+    # lazy cache updates based on results
+    module Store
+      def update_cache
+        return unless update_cache?
+
+        prep_for_cache
+        Card.write_to_cache card, local_only?
+      end
+
+      def update_cache?
+        (cache_ready? || new_for_cache || needs_prep?) && !card&.uncacheable?
+      end
+
+      def cache_ready?
+        @cache_ready
+      end
+
+      # instantiate a card as a cache placeholder
+      def new_for_cache
+        return unless new_for_cache?
+        args = { name: mark, skip_modules: true }
+        args[:type_lookup] = :skip if skip_type_lookup?
+        args.merge! new_opts.slice(:type, :type_id, :type_code) if eager_caching?
+        @card = Card.new args
+      end
+
+      def eager_caching?
+        opts[:eager_cache] && mark.name? && mark.absolute? && new_opts.present?
+      end
+
+      def new_for_cache?
+        reusable? && new_card_needed?
+      end
+
+      def needs_prep?
+        return unless card.present?
+
+        !(skip_modules? || card.patterns?)
+      end
+
+      def new_card_needed?
+        !(card.present? && (card.type_id.present? || skip_type_lookup?))
+      end
+
+      def reusable?
+        !(mark.is_a?(Integer) || (mark.blank? && !opts[:new]))
+      end
+
+      # Because Card works by including set-specific ruby modules on singleton classes and
+      # singleton classes generally can't be cached, we can never cache the cards in a
+      # completely ready-to-roll form.
+      #
+      # However, we can optimize considerably by saving the list of ruby modules in
+      # environments where they won't be changing (eg production) or at least the list of
+      # matching set patterns
+      def prep_for_cache
+        # return # DELETE ME
+        return if skip_modules?
+
+        Cardio.config.cache_set_module_list ? card.set_modules : card.patterns
+      end
+    end
+  end
+end

data/mod/core/lib/card/rule.rb

@@ -0,0 +1,227 @@
+class Card
+  # Optimized handling of card "rules" (Set+Setting) and preferences.
+  module Rule
+    RULE_SQL = %(
+      SELECT
+        rules.id      AS rule_id,
+        settings.id   AS setting_id,
+        sets.id       AS set_id,
+        sets.left_id  AS anchor_id,
+        sets.right_id AS set_tag_id
+      FROM cards rules
+      JOIN cards sets     ON rules.left_id  = sets.id
+      JOIN cards settings ON rules.right_id = settings.id
+      WHERE     sets.type_id = #{SetID}
+        AND settings.type_id = #{SettingID}
+        AND (settings.codename != 'follow' OR rules.db_content != '')
+        AND    rules.trash is false
+        AND     sets.trash is false
+        AND settings.trash is false;
+    ).freeze
+
+    # FIXME: "follow" hardcoded above
+
+    READ_RULE_SQL = %(
+      SELECT
+        refs.referee_id AS party_id,
+        read_rules.id   AS read_rule_id
+      FROM cards read_rules
+      JOIN card_references refs ON refs.referer_id    = read_rules.id
+      JOIN cards sets           ON read_rules.left_id = sets.id
+      WHERE read_rules.right_id = #{ReadID}
+        AND       sets.type_id  = #{SetID}
+        AND read_rules.trash is false
+        AND       sets.trash is false;
+    ).freeze
+
+    PREFERENCE_SQL = %(
+      SELECT
+        preferences.id AS rule_id,
+        settings.id    AS setting_id,
+        sets.id        AS set_id,
+        sets.left_id   AS anchor_id,
+        sets.right_id  AS set_tag_id,
+        users.id       AS user_id
+      FROM cards preferences
+      JOIN cards user_sets ON preferences.left_id  = user_sets.id
+      JOIN cards settings  ON preferences.right_id = settings.id
+      JOIN cards users     ON user_sets.right_id   = users.id
+      JOIN cards sets      ON user_sets.left_id    = sets.id
+      WHERE sets.type_id     = #{SetID}
+        AND settings.type_id = #{SettingID}
+        AND (%s or users.codename = 'all')
+        AND sets.trash        is false
+        AND settings.trash    is false
+        AND users.trash       is false
+        AND user_sets.trash   is false
+        AND preferences.trash is false;
+    ).freeze
+
+    class << self
+      def global_setting name
+        Auth.as_bot do
+          (card = Card[name]) && !card.db_content.strip.empty? && card.db_content
+        end
+      end
+
+      def toggle val
+        val.to_s.strip == "1"
+      end
+
+      def rule_cache
+        Card.cache.read("RULES") || populate_rule_caches
+      end
+
+      def read_rule_cache
+        Card.cache.read("READRULES") || populate_read_rule_cache
+      end
+
+      # all users that have a user-specific rule for a given rule key
+      def user_ids_cache
+        Card.cache.read("USER_IDS") || fresh_rule_cache { @user_ids_hash }
+      end
+
+      # all keys of user-specific rules for a given user
+      def rule_keys_cache
+        Card.cache.read("RULE_KEYS") || fresh_rule_cache { @rule_keys_hash }
+      end
+
+      def clear_rule_cache
+        write_rule_cache nil
+        write_user_ids_cache nil
+        write_rule_keys_cache nil
+      end
+
+      def clear_preference_cache
+        # FIXME: too entwined!
+        clear_rule_cache
+      end
+
+      def clear_read_rule_cache
+        Card.cache.write "READRULES", nil
+      end
+
+      def preference_names user_name, setting_code
+        Card.search({ right: { codename: setting_code },
+                      left: { left: { type_id: SetID },
+                              right: user_name },
+                      return: :name },
+                    "preference cards for user: #{user_name}")
+      end
+
+      def all_user_ids_with_rule_for set_card, setting_code
+        cache_key = "#{user_cache_key_base set_card}+#{setting_code}"
+        user_ids = user_ids_cache[cache_key] || []
+        user_ids.include?(AllID) ? all_user_ids : user_ids
+      end
+
+      private
+
+      def populate_rule_caches
+        @rule_hash = {}
+        @user_ids_hash = {}
+        @rule_keys_hash = {}
+
+        interpret_simple_rules
+        interpret_preferences
+
+        write_user_ids_cache @user_ids_hash
+        write_rule_keys_cache @rule_keys_hash
+        write_rule_cache @rule_hash
+      end
+
+      def populate_read_rule_cache
+        hash = rows(READ_RULE_SQL).each_with_object({}) do |row, h|
+          party_id = row["party_id"].to_i
+          h[party_id] ||= []
+          h[party_id] << row["read_rule_id"].to_i
+        end
+        Card.cache.write "READRULES", hash
+      end
+
+      def rule_cache_key row
+        return false unless (setting_code = Card::Codename[row["setting_id"].to_i])
+
+        anchor_id = row["anchor_id"]
+        set_class_id = anchor_id.nil? ? row["set_id"] : row["set_tag_id"]
+        return false unless (set_class_code = Card::Codename[set_class_id.to_i])
+
+        [anchor_id, set_class_code, setting_code].compact.map(&:to_s) * "+"
+      end
+
+      def interpret_simple_rules
+        rows(RULE_SQL).each do |row|
+          next unless (key = rule_cache_key row)
+          @rule_hash[key] = row["rule_id"].to_i
+        end
+      end
+
+      def interpret_preferences
+        rows(preference_sql).each do |row|
+          next unless (key = rule_cache_key row) && (user_id = row["user_id"])
+          add_preference_hash_values key, row["rule_id"].to_i, user_id.to_i
+        end
+      end
+
+      # User-specific rule use the pattern
+      # user+set+setting
+      def preference_sql user_id=nil
+        PREFERENCE_SQL % user_restriction(user_id)
+      end
+
+      def user_restriction user_id
+        if user_id
+          "users.id = #{user_id}"
+        else
+          "users.type_id = #{UserID}"
+        end
+      end
+
+      def rows sql
+        Card.connection.select_all sql
+      end
+
+      def add_preference_hash_values key, rule_id, user_id
+        @rule_hash[preference_key(key, user_id)] = rule_id
+        @user_ids_hash[key] ||= []
+        @user_ids_hash[key] << user_id
+        @rule_keys_hash[user_id] ||= []
+        @rule_keys_hash[user_id] << key
+      end
+
+      def user_cache_key_base set_card
+        if (l = set_card.left) && (r = set_card.right)
+          "#{l.id}+#{Card::Codename[r.id]}"
+        else
+          Card::Codename[set_card.id].to_s
+        end
+      end
+
+      def preference_key key, user_id
+        "#{key}+#{user_id}"
+      end
+
+      def fresh_rule_cache
+        clear_rule_cache
+        rule_cache
+        yield
+      end
+
+      def all_user_ids
+        Card.where(type_id: UserID).pluck :id
+      end
+
+      def write_rule_cache hash
+        Card.cache.write "RULES", hash
+      end
+
+      def write_user_ids_cache hash
+        Card.cache.write "USER_IDS", hash
+      end
+
+      def write_rule_keys_cache hash
+        Card.cache.write "RULE_KEYS", hash
+      end
+    end
+  end
+end