card 1.107.0 → 1.108.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df537d34eb8d348b41930c7ce3e6de5ed600b4d7e8df87ba2d935b2e259ae8e6
-  data.tar.gz: e108f9e1f0833c0aac0248c6ec59bf41c18aef70e09e42ea8bd364f94705fe7c
+  metadata.gz: 2f065584dd5d9ec2de2f500efa89435c0270d1ed25178cb88dfa77432573068b
+  data.tar.gz: 10507be87eed39bbddb2db5414d6746f72f2637a912a8762834340718c3539f2
 SHA512:
-  metadata.gz: ec38c34b70331bf7a919963b7337682e1456286ec5007db1d6d5408f270bb326bb6c55cd2c8af455bb7ed2794d8bd7ae1012dc3eb741d89ba2ce575a63c804bd
-  data.tar.gz: 901b1dc8198578fac3b59040919c02520b177ff8e240c4cebb0a1adb6c978054491b62aa4cc44a3a3514b114645b914a23515ffb36d71ab39b36054fe31c7cd7
+  metadata.gz: d25bdb2406dd6d40700ecd945954b3fe9eb2e1a311e92677c446ba622b6f64e6c01c7547ce9ea91df52676fa1ac978b868a0f5840f6aa9bdb46360fe01eeadd0
+  data.tar.gz: 78333d7e0400f187119d593e68d05ed9481e3e194dfdeb7b1c2e431a71af07e58124027536c2a236e27b6b7dcf84ae36066b7e737e53828ff0e9565236674fa2

data/VERSION

@@ -1 +1 @@
-0.17.0
+0.18.0

data/config/environments/development.rb

@@ -4,7 +4,7 @@ Cardio.application.class.configure do
   # Settings specified here will take precedence over those in config/application.rb
 
   config.view_cache = false
-
+  # config.cache_log_level = :debug
   config.eager_load = false
 
   config.asset_refresh = :eager
@@ -38,14 +38,6 @@ Cardio.application.class.configure do
   # in the nest where the error occurred
   config.raise_all_rendering_errors = true
 
-  # config.performance_logger = {
-  #     methods:   [:event, :search, :fetch, :view],  # choose methods to log
-  #     min_time:  100,               # show only method calls that are slower than 100ms
-  #     max_depth: 3,                 # show nested method calls only up to depth 3
-  #     details:   true               # show method arguments and sql
-  #     log_level: :info
-  # }
-
   # Only use best-standards-support built into browsers
   config.action_dispatch.best_standards_support = :builtin
 

data/config/environments/test.rb

@@ -16,8 +16,8 @@ Cardio.application.class.configure do
 
   config.assets.enabled = true if Object.const_defined?(:JasmineRails)
 
-  config.persistent_cache = false
-  config.prepopulate_cache = true
+  config.shared_cache = false
+  config.seed_cache_from_stash = true
 
   # Configure static asset server for tests with Cache-Control for performance
   config.serve_static_files = true

data/config/initializers/01_core_extensions/integer.rb

@@ -0,0 +1,13 @@
+require_relative "persistent_identifier"
+
+module CoreExtensions
+  # extensions to Integer class
+  module Integer
+    include PersistentIdentifier
+
+    # interpret integer as id
+    def cardname
+      Card::Lexicon.name self
+    end
+  end
+end

data/config/initializers/01_core_extensions/{persistent_identifiers.rb → persistent_identifier.rb}

@@ -7,11 +7,6 @@ module CoreExtensions
       Card[self]
     end
 
-    # interpret symbol/integer as codename/id
-    def cardname
-      Card.quick_fetch(self)&.name
-    end
-
     # don't interpret symbol/integer as codename/id
     def to_name
       Card::Name.new to_s

data/config/initializers/01_core_extensions/symbol.rb

@@ -0,0 +1,11 @@
+module CoreExtensions
+  # extensions to Symbol class
+  module Symbol
+    include PersistentIdentifier
+
+    # interpret symbol as codename
+    def cardname
+      Card::Codename.name self
+    end
+  end
+end

data/config/initializers/core_extensions.rb

@@ -9,8 +9,8 @@ module CoreExtensions
   ::String.include String
   ::Array.include Array
   ::Hash.include Hash::Merging
-  ::Symbol.include PersistentIdentifier
-  ::Integer.include PersistentIdentifier
+  ::Symbol.include Symbol
+  ::Integer.include Integer
   ::Hash.extend Hash::ClassMethods::Nesting
   ::MatchData.include MatchData
 end

data/db/schema.rb

@@ -9,6 +9,10 @@
 # migrations use external dependencies or application code.
 #
 # It's strongly recommended that you check this file into your version control system.
+#
+# Remark: We used to use size: medium for text columns. This option is supported by mysql but not by postgres.
+# limit: 16.megabytes - 1 translates to the same size in mysql databases.
+
 
 ActiveRecord::Schema.define(version: 2022_10_31_182227) do
 
@@ -36,7 +40,7 @@ ActiveRecord::Schema.define(version: 2022_10_31_182227) do
   create_table "card_changes", id: :integer, charset: "utf8mb3", force: :cascade do |t|
     t.integer "card_action_id"
     t.integer "field"
-    t.text "value", size: :medium
+    t.text "value", limit: 16.megabytes - 1
     t.index ["card_action_id"], name: "card_changes_card_action_id_index"
   end
 
@@ -65,7 +69,7 @@ ActiveRecord::Schema.define(version: 2022_10_31_182227) do
     t.integer "left_id"
     t.integer "right_id"
     t.string "left_key"
-    t.text "content", size: :medium
+    t.text "content", limit: 16.megabytes - 1
     t.datetime "updated_at"
     t.index ["left_id"], name: "right_id_index"
     t.index ["right_id"], name: "left_id_index"
@@ -87,7 +91,7 @@ ActiveRecord::Schema.define(version: 2022_10_31_182227) do
     t.integer "references_expired"
     t.boolean "trash", null: false
     t.integer "type_id", null: false
-    t.text "db_content", size: :medium
+    t.text "db_content", limit: 16.megabytes - 1
     t.index ["codename"], name: "cards_codename_index"
     t.index ["created_at"], name: "cards_created_at_index"
     t.index ["key"], name: "cards_key_index", unique: true
@@ -102,7 +106,7 @@ ActiveRecord::Schema.define(version: 2022_10_31_182227) do
   create_table "delayed_jobs", charset: "utf8mb3", force: :cascade do |t|
     t.integer "priority", default: 0, null: false
     t.integer "attempts", default: 0, null: false
-    t.text "handler", size: :medium, null: false
+    t.text "handler", limit: 16.megabytes - 1, null: false
     t.text "last_error"
     t.datetime "run_at"
     t.datetime "locked_at"

data/lib/card/auth/token.rb

@@ -4,7 +4,7 @@ class Card
   module Auth
     # methods for setting current account
     module Token
-      SECRET_KEY = Rails.application.secrets.secret_key_base.to_s
+      SECRET_KEY = Rails.application.credentials.secret_key_base.to_s
 
       class << self
         def encode user_id, extra_payload={}

data/lib/card/cache/all.rb

@@ -2,12 +2,25 @@ class Card
   class Cache
     # cache-related instance methods available to all Cards
     module All
+      def write_lexicon
+        Lexicon.write_to_temp_cache id, name, lex
+      end
+
+      def lex
+        if simple?
+          name
+        elsif left_id && right_id
+          [left_id, right_id]
+        end
+      end
+
       def expire cache_type=nil
         return unless (cache_class = cache_class_from_type cache_type)
 
         expire_views
         expire_names cache_class
         expire_id cache_class
+        expire_left cache_type
       end
 
       def view_cache_clean?
@@ -18,18 +31,28 @@ class Card
         return if view_cache_keys.include? cache_key
 
         view_cache_keys << cache_key
-        hard_write_view_cache_keys
+        shared_write_view_cache_keys
       end
 
       private
 
-      def hard_read_view_cache_keys key_root=key
-        Card.cache.hard&.read_attribute key_root, :view_cache_keys
+      def expire_left cache_type
+        return unless name.compound? && expire_left?
+
+        Card.cache.read(name.left_name.key)&.expire cache_type
+      end
+
+      def expire_left?
+        true
+      end
+
+      def shared_read_view_cache_keys key_root=key
+        Card.cache.shared&.read_attribute key_root, :view_cache_keys
       end
 
-      def hard_write_view_cache_keys
+      def shared_write_view_cache_keys
         # puts "WRITE VIEW CACHE KEYS (#{name}): #{view_cache_keys}"
-        Card.cache.hard&.write_attribute key, :view_cache_keys, view_cache_keys
+        Card.cache.shared&.write_attribute key, :view_cache_keys, view_cache_keys
       end
 
       def cache_class_from_type cache_type
@@ -37,7 +60,7 @@ class Card
       end
 
       def view_cache_keys
-        @view_cache_keys ||= hard_read_view_cache_keys(key) || []
+        @view_cache_keys ||= shared_read_view_cache_keys(key) || []
       end
 
       def expire_names cache
@@ -58,7 +81,7 @@ class Card
       def expire_views
         each_key_version do |key|
           # puts "EXPIRE VIEW CACHE (#{name}): #{view_cache_keys}"
-          view_keys = hard_read_view_cache_keys key
+          view_keys = shared_read_view_cache_keys key
           next unless view_keys.present?
 
           expire_view_cache_keys view_keys

data/lib/card/cache/card_class.rb

@@ -2,10 +2,16 @@ class Card
   class Cache
     # cache-related class methods
     module CardClass
-      def retrieve_from_cache cache_key, local_only=false
-        return unless cache
+      def cache
+        Card::Cache[Card]
+      end
 
-        local_only ? cache.soft.read(cache_key) : cache.read(cache_key)
+      def after_write_to_temp_cache card
+        card.write_lexicon if card.is_a? Card
+      end
+
+      def retrieve_from_cache cache_key, local_only=false
+        local_only ? cache.temp.read(cache_key) : cache.read(cache_key)
       end
 
       def retrieve_from_cache_by_id id, local_only=false
@@ -21,16 +27,16 @@ class Card
 
       def write_to_cache card, local_only=false
         if local_only
-          write_to_soft_cache card
+          write_to_temp_cache card
         elsif cache
           cache.write card.key, card
         end
       end
 
-      def write_to_soft_cache card
+      def write_to_temp_cache card
         return unless cache
 
-        cache.soft.write card.key, card
+        cache.temp.write card.key, card, callback: false
       end
 
       def expire name

data/lib/card/cache/class_methods.rb

@@ -0,0 +1,122 @@
+
+class Card
+  class Cache
+    # class methods for Card::Cache
+    module ClassMethods
+      include Populate
+
+      attr_accessor :no_renewal
+      attr_accessor :counter
+
+      # create a new cache for the ruby class provided
+      # @param klass [Class]
+      # @return [{Card::Cache}]
+      def [] klass
+        raise "nil klass" if klass.nil?
+
+        cache_by_class[klass] ||= new class: klass, store: (shared_cache || nil)
+      end
+
+      # clear the temporary caches and ensure we're using the latest stamp
+      # on the shared caches.
+      def renew
+        # Cardio.config.cache_log_level = :debug
+        # Cardio.config.view_cache = true
+        # Cardio.config.asset_refresh = :cautious
+        # Cache.reset_all
+
+        Card::Cache.counter = nil
+        return if no_renewal
+
+        renew_shared
+        cache_by_class.each_value do |cache|
+          cache.temp.reset
+          cache.shared&.renew
+        end
+
+        populate_temp_cache
+      end
+
+      def renew_shared
+        Card::Cache::Shared.renew if shared_cache
+      end
+
+      # reset standard cached for all classes
+      def reset
+        reset_shared
+        reset_temp
+      end
+
+      # reset all caches for all classes
+      def reset_all
+        reset_shared
+        reset_temp
+        reset_other
+      end
+
+      # completely wipe out all caches, often including the Shared cache of
+      # other decks using the same mechanism.
+      # Generally prefer {.reset_all}
+      # @see .reset_all
+      def reset_global
+        cache_by_class.each_value do |cache|
+          cache.temp.reset
+          cache.shared&.annihilate
+        end
+        reset_other
+      end
+
+      # reset the Shared cache for all classes
+      def reset_shared
+        Card::Cache::Shared.reset if shared_cache
+        cache_by_class.each_value do |cache|
+          cache.shared&.reset
+        end
+      end
+
+      # reset the Temporary cache for all classes
+      def reset_temp
+        cache_by_class.each_value { |cache| cache.temp.reset }
+      end
+
+      # reset Codename cache and delete tmp files
+      # (the non-standard caches)
+      def reset_other
+        Card::Codename.reset_cache
+        Cardio::Utils.delete_tmp_files!
+      end
+
+      def restore
+        reset_temp
+        seed_from_stash
+      end
+
+      def shared_on!
+        return if @shared_cache
+
+        @cache_by_class = {}
+        @shared_cache = Cardio.config.shared_cache && Cardio.cache
+      end
+
+      def cache_by_class
+        @cache_by_class ||= {}
+      end
+
+      def shared_cache
+        return @shared_cache unless @shared_cache.nil?
+
+        @shared_cache = (ENV["NO_RAILS_CACHE"] != "true") && shared_on!
+      end
+
+      def tallies
+        "#{tally_total} Cache calls (" + counter.map { |k, v| "#{k}=#{v} " }.join + ")"
+      end
+
+      private
+
+      def tally_total
+        counter.values.map(&:values).flatten.sum
+      end
+    end
+  end
+end

data/lib/card/cache/populate.rb

@@ -0,0 +1,64 @@
+class Card
+  class Cache
+    # population-related class methods for Card::Cache
+    module Populate
+      def populate_ids ids
+        # use ids to look up names
+        results = Lexicon.cache.read_multi(ids.map(&:to_s)).values
+        names = []
+        pairs = []
+        results.each do |result|
+          result.is_a?(String) ? (names << result) : (pairs << result)
+        end
+
+        if pairs.any?
+          populate_ids pairs.flatten
+          names += pairs.map(&:cardname)
+        end
+
+        # use keys to look up
+        populate_names names
+      end
+
+      def populate_names names
+        keys = names.map { |n| n.to_name.key }
+        Card.cache.read_multi keys
+      end
+
+      def populate_fields list, *fields
+        name_arrays = list.each_with_object([]) do |item, arrays|
+          fields.flatten.each do |field|
+            arrays << [item, field]
+          end
+        end
+        populate_names name_arrays
+      end
+
+      private
+
+      def populate_temp_cache
+        return unless shared_cache
+
+        populate_ids Codename.ids
+        # Codename.process_codenames if result.blank?
+        Card.cache.read_multi Set.basket[:cache_seed_strings]
+        populate_names Set.basket[:cache_seed_names]
+      end
+
+      # for testing, stash rules in variable and use that to re-seed cache
+      def seed_from_stash
+        return unless Cardio.config.seed_cache_from_stash
+
+        stash_to_cache("RULES") { Card::Rule.rule_cache }
+        stash_to_cache("READRULES") { Card::Rule.read_rule_cache }
+        stash_to_cache("PREFERENCES") { Card::Rule.preference_cache }
+      end
+
+      def stash_to_cache variable
+        @stash ||= {}
+        value = @stash[variable] ||= yield
+        Card.cache.temp.write variable, value.clone
+      end
+    end
+  end
+end

data/lib/card/cache/{persistent.rb → shared.rb}

@@ -2,23 +2,20 @@
 
 class Card
   class Cache
-    # _Persistent_ (or _Hard_) caches closely mirror the database and are
+    # _Shared_ caches closely mirror the database and are
     # intended to be altered only upon database alterations.
     #
-    # Unlike the database, the persistent cache stores records of records that
+    # Unlike the database, the shared cache stores records of records that
     # have been requested but are missing or, in the case of some {Card cards},
     # "virtual", meaning that they follow known patterns but do not exist in the
     # database.
     #
-    # Most persistent cache implementations cannot store objects with singleton
+    # Most shared cache implementations cannot store objects with singleton
     # classes, therefore {Card cards} generally must have set_modules
-    # re-included after retrieval from the persistent cache.
+    # re-included after retrieval from the shared cache.
     #
-    class Persistent
-      extend PersistentClass
-
-      attr_accessor :prefix
-
+    class Shared
+      extend SharedClass
       # @param opts [Hash]
       # @option opts [Rails::Cache] :store
       # @option opts [ruby Class] :class, typically ActiveRecord descendant
@@ -82,27 +79,36 @@ class Card
         @store.read full_key(key)
       end
 
+      def read_multi keys
+        map = keys.each_with_object({}) { |k, h| h[full_key k] = k }
+        raw = @store.read_multi(*map.keys)
+        raw.each_with_object({}) { |(k, v), h| h[map[k]] = v }
+      end
+
       # update an attribute of an object already in the cache
       # @param key [String]
       # @param attribute [String, Symbol]
       def write_attribute key, attribute, value
         return value unless @store
 
-        if (object = deep_read key)
+        # if (object = deep_read key)
+        if (object = read key)
           object.instance_variable_set "@#{attribute}", value
           write key, object
         end
         value
       end
 
-      def deep_read key
-        local_cache = @store.send :local_cache
-        local_cache&.clear
-        read key
-      end
+      # def deep_read key
+      #   binding.pry
+      #   # local_cache = @store.send :local_cache
+      #   # local_cache&.clear
+      #   read key
+      # end
 
       def read_attribute key, attribute
-        object = deep_read key
+        # object = deep_read key
+        object = read key
         object.instance_variable_get "@#{attribute}"
       end
 

data/lib/card/cache/{persistent_class.rb → shared_class.rb}

@@ -1,7 +1,7 @@
 class Card
   class Cache
-    # class methods for Card::Cache::Persistent
-    module PersistentClass
+    # class methods for Card::Cache::Shared
+    module SharedClass
       def stamp
         @stamp ||= Cardio.cache.fetch(stamp_key) { new_stamp }
       end

data/lib/card/cache/temporary.rb

@@ -8,30 +8,47 @@ class Card
     # 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
+    # Unlike the Shared cache, the Temporary cache can handle objects with
     # singleton classes.
     class Temporary
+      MAX_KEYS = 10_000
       attr_reader :store
 
-      def initialize
+      def initialize klass
+        @klass = klass
         @store = {}
+        @reps = 0
       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
+      def write key, value, callback: true
+        within_key_counts do
+          @store[key] = value.tap do
+            @reps += 1
+            @klass.try :after_write_to_temp_cache, value if callback
+          end
+        end
       end
 
       # @param key [String]
-      def fetch key, &_block
-        read(key) || write(key, yield)
+      def fetch key
+        # read(key) || write(key, yield)
+        exist?(key) ? read(key) : write(key, yield)
+      end
+
+      def fetch_multi keys
+        @store.slice(*keys).tap do |found|
+          missing = keys - found.keys
+          if (newfound = missing.present? && yield(missing))
+            found.merge! newfound
+            newfound.each { |key, value| write key, value }
+          end
+        end
       end
 
       # @param key [String]
@@ -46,6 +63,7 @@ class Card
       end
 
       def reset
+        @reps = 0
         @store = {}
       end
 
@@ -53,6 +71,20 @@ class Card
       def exist? key
         @store.key? key
       end
+
+      private
+
+      # enforces MAX_KEYS. The @reps count increments with each write but may
+      # overestimate the store size, because of multiple writes to the same key.
+      # (but this approach avoids recounting each time)
+      def within_key_counts
+        if @reps >= MAX_KEYS && (@reps = @store.size) > MAX_KEYS
+          Rails.logger.info "RESETTING temporary #{@klass} cache. " \
+                              "MAX_KEYS (#{MAX_KEYS}) exceeded"
+          reset
+        end
+        yield
+      end
     end
   end
 end