card 1.107.0 → 1.108.1

data/lib/card/format/render.rb

@@ -69,9 +69,10 @@ class Card
                                       '\1: ')}:#{source_location.second}"
       end
 
-      # :standard, :always, :never
+      # see {Abstract::Format}
+      # (:default), :yes, :deep, :always, :never
       def view_cache_setting view
-        voo&.cache || view_setting(:cache, view) || :standard
+        voo&.cache || view_setting(:cache, view) || :default
       end
 
       def view_setting setting_name, view
@@ -79,19 +80,19 @@ class Card
       end
 
       def stub_render cached_content
-        stub_debugging do
-          expand_stubs cached_content
-        end
-      end
-
-      def stub_debugging
-        result = yield
-        if Rails.env.development? && result =~ /stub/
-          Rails.logger.debug "STUB IN RENDERED VIEW: #{card.name}: " \
-                            "#{voo.ok_view}\n#{result}"
-        end
-        result
-      end
+        # stub_debugging do
+        expand_stubs cached_content
+        # end
+      end
+
+      # def stub_debugging
+      #   result = yield
+      #   if Rails.env.development? && result.is_a?(String) && result =~ /StUb/
+      #     Rails.logger.debug "STUB IN RENDERED VIEW: #{card.name}: " \
+      #                       "#{voo.ok_view}\n#{result}"
+      #   end
+      #   result
+      # end
 
       def prepare_stub_nest stub_hash
         stub_card = Card.fetch_from_cast stub_hash[:cast]

data/lib/card/format.rb

@@ -36,8 +36,14 @@ class Card
     delegate :basket, to: Set
     delegate :session, :params, to: Env
 
-    def self.view_caching?
-      true
+    @symbol = :base
+
+    class << self
+      attr_writer :symbol
+
+      def view_caching?
+        true
+      end
     end
 
     def initialize card, opts={}
@@ -85,8 +91,9 @@ class Card
       literal
     end
 
-    def to_sym
-      Card::Format.format_sym self
+    def symbol
+      self.class.symbol
     end
+    alias_method :to_sym, :symbol
   end
 end

data/lib/card/lexicon.rb

@@ -2,9 +2,8 @@ class Card
   # Translates names to ids and vice versa via a cached "lex" representation:
   # name for simple cards, [left_id, right_id] for compound cards.
   #
-  # Note, unlike Card::Fetch, Card::Lexicon:
-  #   1. does NOT distinguish between trashed and untrashed cards.
-  #   2. does NOT respect local name changes
+  # Note, unlike Card::Fetch, Card::Lexicon: does NOT return local name changes
+  # until stored
   module Lexicon
     class << self
       # param id [Integer]
@@ -33,10 +32,10 @@ class Card
         expire_lex card.lex_before_act
       end
 
-      # def delete card
-      #   cache.delete card.id.to_s
-      #   cache.delete cache_key(card.lex_before_act)
-      # end
+      def delete card
+        cache.delete card.id.to_s
+        cache.delete cache_key(card.lex_before_act)
+      end
 
       def lex_to_name lex
         return lex unless lex.is_a? Array
@@ -44,6 +43,18 @@ class Card
         lex.map { |side_id| name side_id or return }.join(Card::Name.joint).to_name
       end
 
+      def cache_key lex
+        "L-#{lex.is_a?(Array) ? lex.join('-') : lex.to_name.key}"
+      end
+
+      def lex_query lex
+        if lex.is_a?(Array)
+          { left_id: lex.first, right_id: lex.last }
+        else
+          { key: lex.to_name.key }
+        end
+      end
+
       # this is to address problems whereby renaming errors leave the lexicon broken.
       # NEEDS TESTING
       def rescuing
@@ -57,14 +68,23 @@ class Card
         raise e
       end
 
+      def write_to_temp_cache id, name, lex
+        cache.temp.write id.to_s, name if id.present?
+        cache.temp.write cache_key(lex), id if lex
+      end
+
+      def write id, name, lex
+        cache.write id.to_s, name
+        cache.write cache_key(lex), id
+      end
+
       private
 
       def add card
         lex = card.lex
         @act_lexes << lex
         @act_ids << card.id
-        cache.write card.id.to_s, lex
-        cache.write cache_key(lex), card.id
+        write card.id, card.name, card.lex
       end
 
       def expire_lex lex
@@ -80,7 +100,9 @@ class Card
           result = Card.where(id: id).pluck(:name, :left_id, :right_id).first
           return unless result
 
-          result[0] || [result[1], result[2]]
+          (result[0] || [result[1], result[2]]).tap do |lex|
+            cache.write cache_key(lex), id
+          end
         end
       end
 
@@ -94,21 +116,13 @@ class Card
 
       def lex_to_id lex
         cache.fetch cache_key(lex) do
-          Card.where(lex_query(lex)).pluck(:id).first
-        end
-      end
-
-      def lex_query lex
-        if lex.is_a?(Array)
-          { left_id: lex.first, right_id: lex.last }
-        else
-          { key: lex.to_name.key }
+          query = lex_query(lex).merge trash: false
+          Card.where(query).pluck(:id).first.tap do |id|
+            # don't store name, because lex might not be the canonical name
+            cache.write id.to_s, lex if lex.is_a?(Array)
+          end
         end
       end
-
-      def cache_key lex
-        "L-#{lex.is_a?(Array) ? lex.join('-') : lex.to_name.key}"
-      end
     end
   end
 end

data/lib/card/mark.rb

@@ -2,9 +2,6 @@ class Card
   # Card::Mark provides class methods for Card to translate all different kind
   # of card identifiers to card objects.
   module Mark
-    ID_MARK_RE = /^~(?<id>\d+)$/.freeze
-    CODENAME_MARK_RE = /^:(?<codename>\w+)$/.freeze
-
     # translates marks (and other inputs) into a Card
     #
     # @param cardish [Card, Card::Name, String, Symbol, Integer]
@@ -26,42 +23,13 @@ class Card
       id_from_mark(mark) || Card::Name[mark]
     end
 
-    # translates string identifiers into an id:
-    #   - string id notation (eg "~75")
-    #   - string codename notation (eg ":options")
-    #
-    # @param mark [String]
-    # @return [Integer or nil]
-    def id_from_string mark
-      case mark
-      when ID_MARK_RE       then Regexp.last_match[:id].to_i
-      when CODENAME_MARK_RE then Card::Codename.id! Regexp.last_match[:codename]
-      end
-    end
-
-    def name_from_id_from_string id, string
-      fetch_name(id) { bad_mark string }
-    end
-
     private
 
-    def bad_mark string
-      case string
-      when ID_MARK_RE
-        raise Card::Error::NotFound, "id doesn't exist: #{Regexp.last_match[:id]}"
-      when CODENAME_MARK_RE
-        raise Card::Error::CodenameNotFound,
-              "codename doesn't exist: #{Regexp.last_match[:codename]}"
-      else
-        raise Card::Error, "invalid mark: #{string}"
-      end
-    end
-
     def id_from_mark mark
       case mark
       when Integer then mark
-      when Symbol  then Card::Codename.id! mark
-      when String  then id_from_string mark
+      when Symbol  then Codename.id! mark
+      when String  then Name.id_from_string! mark
       when Card    then mark.id
       end
     end

data/lib/card/name/all.rb

@@ -36,12 +36,8 @@ class Card
         end
       end
 
-      def lex
-        simple? ? name : [left_id, right_id]
-      end
-
       def autoname name
-        if Card.exists?(name) || Director.include?(name)
+        if Card.exist?(name) || Director.include?(name)
           autoname name.next
         else
           name
@@ -107,8 +103,8 @@ class Card
 
       def update_cache_key oldkey
         yield
-        was_in_cache = Card.cache.soft.delete oldkey
-        Card.write_to_soft_cache self if was_in_cache
+        was_in_cache = Card.cache.temp.delete oldkey
+        Card.write_to_temp_cache self if was_in_cache
       end
 
       def update_subcard_name subcard, new_name, name_to_replace

data/lib/card/name/card_class.rb

@@ -8,7 +8,7 @@ class Card
 
       def uniquify_name name, rename=:new
         name = name.to_name
-        return name unless Card.exists? name
+        return name unless Card.exist? name
 
         uniq_name = generate_alternative_name name
         return uniq_name unless rename == :old
@@ -19,7 +19,7 @@ class Card
 
       def generate_alternative_name name
         uniq_name = "#{name} 1"
-        uniq_name.next! while Card.exists?(uniq_name)
+        uniq_name.next! while Card.exist?(uniq_name)
         uniq_name
       end
     end

data/lib/card/name/name_variants.rb

@@ -15,7 +15,13 @@ class Card
 
       # @return [Card::Name] standardized based on card names
       def standard
-        self.class.compose(parts.map { |part| Card.fetch_name(part) || part })
+        if simple?
+          id = Lexicon.id self
+          std = Lexicon.name id
+          std.present? ? std : self
+        else
+          self.class.compose(parts.map { |part| part.cardname.standard })
+        end
       end
 
       def card

data/lib/card/name.rb

@@ -13,16 +13,13 @@ class Card
     include NameVariants
 
     class << self
+      ID_MARK_RE = /^~(?<id>\d+)$/
+      CODENAME_MARK_RE = /^:(?<codename>\w+)$/
+
+      # @return [Card::Name]
       def [] *cardish
         cardish = cardish.first if cardish.size <= 1
-        case cardish
-        when Card             then cardish.name
-        when Symbol, Integer  then Card.fetch_name(cardish)
-        when Array            then compose cardish
-        when String, NilClass then new cardish
-        else
-          raise ArgumentError, "#{cardish.class} not supported as name identifier"
-        end
+        from_cardish(cardish) || unsupported_class!(cardish)
       end
 
       def session
@@ -39,9 +36,9 @@ class Card
         str = str.to_s
 
         if !validated_parts && str.include?(joint)
-          string_compose Cardname.split_parts(str)
-        elsif (id = Card.id_from_string str)  # handles ~[id] and :[codename]
-          Card.name_from_id_from_string id, str
+          new_from_compound_string str
+        elsif (id = id_from_string str)  # handles ~[id] and :[codename]
+          from_id_from_string id, str
         else
           super str
         end
@@ -52,9 +49,43 @@ class Card
         new_from_parts(parts) { |part| self[part] }
       end
 
+      # translates string identifiers into an id:
+      #   - string id notation (eg "~75")
+      #   - string codename notation (eg ":options")
+      #
+      # @param string [String]
+      # @return [Integer or nil]
+      def id_from_string string
+        case string
+        when ID_MARK_RE       then Regexp.last_match[:id].to_i
+        when CODENAME_MARK_RE then Card::Codename.id! Regexp.last_match[:codename]
+        end
+      end
+
+      def id_from_string! string
+        return unless (id = id_from_string string)
+
+        Lexicon.name(id) ? id : bad_mark(string)
+      end
+
       private
 
-      def string_compose parts
+      def from_cardish cardish
+        case cardish
+        when Card             then cardish.name
+        when Integer          then Lexicon.name cardish
+        when Symbol           then Codename.name! cardish
+        when Array            then compose cardish
+        when String, NilClass then new cardish
+        end
+      end
+
+      def unsupported_class! cardish
+        raise ArgumentError, "#{cardish.class} not supported as name identifier"
+      end
+
+      def new_from_compound_string string
+        parts = Cardname.split_parts string
         new_from_parts(parts) { |part| new part }
       end
 
@@ -62,6 +93,23 @@ class Card
         name_parts = parts.flatten.map(&block)
         new name_parts.join(joint), true
       end
+
+      def from_id_from_string id, str
+        name = Lexicon.name id
+        name.present? ? name : bad_mark(str)
+      end
+
+      def bad_mark string
+        case string
+        when ID_MARK_RE
+          raise Card::Error::NotFound, "id doesn't exist: #{Regexp.last_match[:id]}"
+        when CODENAME_MARK_RE
+          raise Card::Error::CodenameNotFound,
+                "codename doesn't exist: #{Regexp.last_match[:codename]}"
+        else
+          raise Card::Error, "invalid mark: #{string}"
+        end
+      end
     end
 
     def star?

data/lib/card/query/card_class.rb

@@ -25,7 +25,7 @@ class Card
         if block_given?
           super do |records|
             yield(records)
-            Card::Cache.reset_soft
+            Card::Cache.reset_temp
           end
         else
           super

data/lib/card/query/card_query/match_attributes.rb

@@ -21,21 +21,31 @@ class Card
         def complete val
           val = val.to_name
           if val.compound?
-            interpret left: val.left
-            interpret right: { complete: val.right } if val.right.present?
+            complete_compound val
           else
-            add_condition "#{table_alias}.key LIKE '#{val.to_name.key}%'"
+            add_condition "#{table_alias}.key LIKE '#{val.to_name.key}%'" if val.present?
+            name_not_null
           end
         end
 
         # match term anywhere in name
         # DEPRECATE - move handling to name: ["match", val]
         def name_match val
-          interpret name: [:match, val]
+          interpret name: [:match, val] if val.present?
+          name_not_null
         end
 
         private
 
+        def complete_compound val
+          interpret left: val.left
+          interpret right: { complete: val.right } if val.right.present?
+        end
+
+        def name_not_null
+          add_condition "#{table_alias}.key IS NOT NULL"
+        end
+
         def or_join conditions
           "(#{Array(conditions).join ' OR '})"
         end

data/lib/card/query/card_query/relational_attributes.rb

@@ -67,6 +67,8 @@ class Card
           junction val, :right, :left_id
         end
 
+        # DEPRECATED - do not use until/unless optimized, especially with large dbs
+        # Multiple joins of cards to cards makes this difficult to scale
         def plus val
           any(left_plus: val, right_plus: val.deep_clone)
         end

data/lib/card/query/card_query/run.rb

@@ -19,11 +19,17 @@ class Card
         # @return [Array]
         def return_list sql_results, retrn
           large_list sql_results.length if sql_results.length > 1000
+          seed_cache sql_results, retrn
           sql_results.map do |record|
             return_simple record, retrn
           end
         end
 
+        def seed_cache sql_results, retrn
+          id_field = retrn.match?(/id$/) ? retrn : "id"
+          Cache.populate_ids(sql_results.map { |record| record[id_field] })
+        end
+
         def large_list length
           Rails.logger.info "#{length} records returned by #{@statement}"
         end
@@ -31,9 +37,9 @@ class Card
         def result_method retrn
           case
           when respond_to?(:"#{retrn}_result") then :"#{retrn}_result"
-          when (retrn =~ /id$/)                then :id_result
-          when (retrn =~ /_\w+/)               then :name_result
-          when (retrn == "key")                then :key_result
+          when retrn.match?(/id$/)             then :id_result
+          when retrn.match?(/_\w+/)            then :name_result
+          when retrn == "key"                  then :key_result
           else                                      :default_result
           end
         end

data/lib/card/query/sql_statement.rb

@@ -38,7 +38,7 @@ class Card
       end
 
       def select
-        "#{leading_space}SELECT DISTINCT #{@fields}"
+        "#{leading_space}SELECT #{'DISTINCT' if @joins.present?} #{@fields}"
       end
 
       def from

data/lib/card/reference/all.rb

@@ -59,7 +59,7 @@ class Card
         end
         return if ref_hash.empty?
 
-        Reference.mass_insert reference_values_array(ref_hash)
+        Reference.insert_in_slices reference_values_array(ref_hash)
       end
 
       # replace references in card content
@@ -101,9 +101,14 @@ class Card
       def reference_values_array ref_hash
         [].tap do |values|
           ref_hash.each do |referee_key, hash_val|
-            referee_id = hash_val.shift || "null"
+            referee_id = hash_val.shift
             each_reference_type hash_val.uniq do |ref_type|
-              values << [id, referee_id, "'#{referee_key}'", "'#{ref_type}'"]
+              values << {
+                referer_id: id,
+                referee_id: referee_id,
+                referee_key: referee_key,
+                ref_type: ref_type
+              }
             end
           end
         end

data/lib/card/reference.rb

@@ -16,9 +16,10 @@ class Card
 
     class << self
       # bulk insert improves performance considerably
-      # array takes form [ [referer_id, referee_id, referee_key, ref_type], ...]
-      def mass_insert array
-        Card.connection.execute mass_insert_sql(array) if array.present?
+      def insert_in_slices array
+        array.each_slice(5000) do |slice|
+          insert_all slice
+        end
       end
 
       # map existing reference to name to card via id
@@ -69,12 +70,6 @@ class Card
           yield card.include_set_modules
         end
       end
-
-      def mass_insert_sql array
-        value_statements = array.map { |values| "\n(#{values.join ', '})" }
-        "INSERT into card_references (referer_id, referee_id, referee_key, ref_type) " \
-        "VALUES #{value_statements.join ', '}"
-      end
     end
   end
 end

data/lib/card/rule/cache.rb

@@ -36,6 +36,8 @@ class Card
           Card.cache.write cache_key, nil
         end
 
+        private
+
         def lookup_hash
           rows.each_with_object({}) do |row, hash|
             next unless (key = lookup_key row)

data/lib/card/rule/read_rule_cache.rb

@@ -17,6 +17,8 @@ class Card
       self.cache_key = "READRULES".freeze
 
       class << self
+        private
+
         def lookup_hash
           rows.each_with_object({}) do |row, h|
             party_id = row["party_id"].to_i

data/lib/card/set/event.rb

@@ -166,10 +166,7 @@ class Card
 
   # one failed integration event should not harm others.
   def rescuing_integration
-    yield
-  rescue StandardError => e
-    # puts "integration error: #{e.message}".red
-    Card::Error.report e, self
+    Error.rescue_card(self) { yield }
   ensure
     true
   end

data/lib/card/set/format/abstract_format/view_opts.rb

@@ -14,7 +14,7 @@ class Card
 
           # view setting values can be accessed from Format objects (eg within format
           # blocks in set modules) using #view_setting(:setting_name, :view_name)
-          VIEW_SETTINGS = %i[cache compact denial perms unknown wrap].freeze
+          VIEW_SETTINGS = %i[cache compact denial perms unknown wrap expire].freeze
 
           # view def opts are used in defining views but are not available
           # at any later point

data/lib/card/set/format/abstract_format.rb

@@ -42,14 +42,31 @@ class Card
         #   and then completing a request. Only applies to HtmlFormat
         #
         # * __:cache__ directs how to handle caching for this view. Supported values:
-        #     * *:standard* - (default)
+        #     * *:default* - (default) do not independently cache this view. However, if
+        #       this view is rendered by another view of the same card, and that view is
+        #       cached, it's ok to cache it.
+        #     * *:yes* - cache this view whenever it's safe to do so. Do NOT start
+        #       a new caching when this view is rendered inside another view of the same
+        #       card. And do NOT include
+        #       nested cards in your cache. (Instead, stub them and process them
+        #       separately)
         #     * *:always* - cache even when rendered within another cached view
-        #     * *:never* - don't ever cache this view. Frequently used to prevent caching
-        #       problems
+        #     * *:deep* cache this view and include nested cards
+        #     * *:never* - don't ever cache this view, even if it's rendered by another
+        #       view of the same card. Frequently used to prevent caching problems, when
+        #       dynamic context (eg params) can alter the view.
         #
         #   You should certainly {Card::View::Cache learn more about caching} if you want
         #   to develop mods that are safe in a caching environment.
         #
+        # * __:expire__ handles cache expiration. (can only apply when cache setting is
+        #     yes, always, or deep)
+        #
+        #     * *:hour* - expire when the hour next changes
+        #     * *:day* - expire when the day next changes
+        #     * *:week* - expire when the week next changes
+        #     * *:month* - expire when the month next changes
+        #
         # * __:compact__ [True/False]. Is view acceptable for rendering inside `compact`
         #   view?  Default is false.
         #

data/lib/card/set/inheritance.rb

@@ -49,7 +49,7 @@ class Card
       #   include_set_formats Type::Basic, except: :css
       def include_set_formats set, opts={}
         each_format set do |format, format_mods|
-          format_sym = Card::Format.format_sym format
+          format_sym = format.to_sym
           next unless applicable_format?(format_sym, opts[:except], opts[:only])
 
           format_mods.each do |format_mod|
@@ -77,8 +77,7 @@ class Card
         Set.modules[format_type].each_pair { |*args| yield(*args) }
       end
 
-      def applicable_format? format, except, only
-        format_sym = Card::Format.format_sym format
+      def applicable_format? format_sym, except, only
         return false if except && Array(except).include?(format_sym)
         return false if only && !Array(only).include?(format_sym)
 

data/lib/card/set/pattern/all.rb

@@ -3,6 +3,18 @@ class Card
     module Pattern
       # pattern-related Card instance methods
       module All
+        # 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_modules_for_caching
+          patterns
+          set_modules if Cardio.config.cache_set_module_list
+        end
+
         def patterns?
           defined? @patterns
         end