card 1.101.0 → 1.101.5

data/lib/card/auth/token.rb

@@ -25,14 +25,20 @@ class Card
         def decode token
           decoded = JWT.decode(token, SECRET_KEY)[0]
           HashWithIndifferentAccess.new decoded
-        rescue JWT::DecodeError => error
-          error.message
+        rescue JWT::DecodeError => e
+          e.message
         end
 
         def expiration
           Card.config.token_expiry.from_now.to_i
         end
       end
+
+      # set the current user based on token
+      def signin_with_token token
+        payload = Token.validate! token
+        signin payload[:anonymous] ? Card::AnonymousID : payload[:user_id]
+      end
     end
   end
 end

data/lib/card/cache.rb

@@ -53,6 +53,7 @@ class Card
       # on the persistent caches.
       def renew
         return if no_renewal
+
         renew_persistent
         cache_by_class.each_value do |cache|
           cache.soft.reset
@@ -175,7 +176,7 @@ class Card
     # test for the existence of the key in either cache
     # @return [true/false]
     def exist? key
-      @soft.exist?(key) || (@hard&.exist?(key))
+      @soft.exist?(key) || @hard&.exist?(key)
     end
   end
 end

data/lib/card/cache/all.rb

@@ -0,0 +1,88 @@
+class Card
+  class Cache
+    # cache-related instance methods available to all Cards
+    module All
+      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
+      end
+
+      def view_cache_clean?
+        !db_content_changed?
+      end
+
+      def ensure_view_cache_key cache_key
+        return if view_cache_keys.include? cache_key
+
+        view_cache_keys << cache_key
+        hard_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
+      end
+
+      def hard_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
+      end
+
+      def cache_class_from_type cache_type
+        cache_type ? Card.cache.send(cache_type) : Card.cache
+      end
+
+      def view_cache_keys
+        @view_cache_keys ||= hard_read_view_cache_keys(key) || []
+      end
+
+      def expire_names cache
+        each_key_version do |key_version|
+          expire_name key_version, cache
+        end
+      end
+
+      def expire_name name_version, cache
+        return unless name_version.present?
+
+        key_version = name_version.to_name.key
+        return unless key_version.present?
+
+        cache.delete key_version
+      end
+
+      def expire_views
+        each_key_version do |key|
+          # puts "EXPIRE VIEW CACHE (#{name}): #{view_cache_keys}"
+          view_keys = hard_read_view_cache_keys key
+          next unless view_keys.present?
+
+          expire_view_cache_keys view_keys
+        end
+        @view_cache_keys = []
+      end
+
+      def expire_id cache
+        return unless id.present?
+
+        cache.delete "~#{id}"
+      end
+
+      def expire_view_cache_keys view_keys
+        Array.wrap(view_keys).each do |view_key|
+          Card::View.cache.delete view_key
+        end
+      end
+
+      def each_key_version
+        [name, name_before_act].uniq.compact.each do |name_version|
+          yield name_version.to_name.key
+        end
+      end
+    end
+  end
+end

data/lib/card/cache/card_class.rb

@@ -0,0 +1,44 @@
+class Card
+  class Cache
+    # cache-related class methods
+    module CardClass
+      def retrieve_from_cache cache_key, local_only=false
+        return unless cache
+
+        local_only ? cache.soft.read(cache_key) : cache.read(cache_key)
+      end
+
+      def retrieve_from_cache_by_id id, local_only=false
+        key = Card::Lexicon.name(id)&.key
+        return unless key.present?
+
+        retrieve_from_cache key, local_only if key
+      end
+
+      def retrieve_from_cache_by_key key, local_only=false
+        retrieve_from_cache key, local_only
+      end
+
+      def write_to_cache card, local_only=false
+        if local_only
+          write_to_soft_cache card
+        elsif cache
+          cache.write card.key, card
+        end
+      end
+
+      def write_to_soft_cache card
+        return unless cache
+
+        cache.soft.write card.key, card
+      end
+
+      def expire name
+        key = name.to_name.key
+        return unless (card = Card.cache.read key)
+
+        card.expire
+      end
+    end
+  end
+end

data/lib/card/cache/persistent.rb

@@ -15,40 +15,9 @@ class Card
     # re-included after retrieval from the persistent cache.
     #
     class Persistent
-      attr_accessor :prefix
-
-      class << self
-        # name of current database; used here to insure that different databases
-        # are cached separately
-        # TODO: find better home for this method
-        def database_name
-          @database_name ||= (cfg = Cardio.config) &&
-                             (dbcfg = cfg.database_configuration) &&
-                             dbcfg[Rails.env]["database"]
-        end
-
-        def stamp
-          @stamp ||= Cardio.cache.fetch(stamp_key) { new_stamp }
-        end
-
-        # stamp generator
-        def new_stamp
-          Time.now.to_i.to_s(36) + rand(999).to_s(36)
-        end
+      extend PersistentClass
 
-        def stamp_key
-          "#{database_name}-stamp"
-        end
-
-        def renew
-          @stamp = nil
-        end
-
-        def reset
-          @stamp = new_stamp
-          Cardio.cache.write stamp_key, @stamp
-        end
-      end
+      attr_accessor :prefix
 
       # @param opts [Hash]
       # @option opts [Rails::Cache] :store
@@ -58,7 +27,7 @@ class Card
         @store = opts[:store]
         @klass = opts[:class]
         @class_key = @klass.to_s.to_name.key
-        @database = opts[:database] || self.class.database_name
+        @database = opts[:database] || Cardio.database_name
       end
 
       # renew insures you're using the most current cache version by

data/lib/card/cache/persistent_class.rb

@@ -0,0 +1,28 @@
+class Card
+  class Cache
+    # class methods for Card::Cache::Persistent
+    module PersistentClass
+      def stamp
+        @stamp ||= Cardio.cache.fetch(stamp_key) { new_stamp }
+      end
+
+      # stamp generator
+      def new_stamp
+        Time.now.to_i.to_s(36) + rand(999).to_s(36)
+      end
+
+      def stamp_key
+        "#{Cardio.database_name}-stamp"
+      end
+
+      def renew
+        @stamp = nil
+      end
+
+      def reset
+        @stamp = new_stamp
+        Cardio.cache.write stamp_key, @stamp
+      end
+    end
+  end
+end

data/lib/card/codename.rb

@@ -137,14 +137,13 @@ class Card
       end
 
       def unknown_codename! mark
-        raise Card::Error::CodenameNotFound, I18n.t(:exception_unknown_codename,
-                                                    scope: "lib.card.codename",
-                                                    codename: mark)
+        raise Card::Error::CodenameNotFound,
+              Cardio.t(:lib_exception_unknown_codename, codename: mark)
       end
 
       def id_constant codename, id=nil
         id ||= id! codename
-        Card.const_get_or_set(codename.to_s.camelize + "ID") { id }
+        Card.const_get_or_set("#{codename.to_s.camelize}ID") { id }
       end
     end
 

data/lib/card/content.rb

@@ -36,9 +36,10 @@ class Card
     end
 
     # Find all chunks of a given type
-    # @param chunk_type [Chunk Class]
+    # @param chunk_type [Chunk Class or Symbol]
     # @return [Array of Chunk instances]
-    def find_chunks chunk_type
+    def find_chunks chunk_type=nil
+      chunk_type = interpret_chunk_type chunk_type
       each_chunk.select { |chunk| chunk.is_a?(chunk_type) }
     end
 
@@ -98,16 +99,12 @@ class Card
       "<#{__getobj__.class}:#{card}:#{self}>"
     end
 
-    def without_nests
-      without_chunks Chunk::Nest do |content|
-        yield content
-      end
+    def without_nests &block
+      without_chunks Chunk::Nest, &block
     end
 
-    def without_references
-      without_chunks Chunk::Nest, Chunk::Link do |content|
-        yield content
-      end
+    def without_references &block
+      without_chunks Chunk::Nest, Chunk::Link, &block
     end
 
     def without_chunks *chunk_classes
@@ -119,6 +116,19 @@ class Card
 
     private
 
+    def interpret_chunk_type chunk_type
+      case chunk_type
+      when nil
+        Chunk
+      when Symbol, String
+        Chunk.const_get chunk_type
+      when Class
+        chunk_type
+      else
+        raise ArgumentError, "unknown chunk type: #{chunk_type}"
+      end
+    end
+
     def stash_chunks chunk_classes
       chunks = []
       each_chunk do |chunk|

data/lib/card/content/all.rb

@@ -0,0 +1,59 @@
+class Card
+  class Content
+    # content-related methods for cards
+    module All
+      def content
+        structured_content || standard_content
+      end
+      alias_method :raw_content, :content # DEPRECATED!
+
+      def content= value
+        self.db_content = standardize_content(value)
+      end
+
+      def content?
+        content.present?
+      end
+
+      def standard_content
+        db_content || (new_card? && template.db_content)
+      end
+
+      def standardize_content value
+        value.is_a?(Array) ? value.join("\n") : value
+      end
+
+      def structured_content
+        structure && template.db_content
+      end
+
+      def refresh_content
+        self.content = Card.find(id)&.db_content
+      end
+
+      def save_content_draft _content
+        clear_drafts
+      end
+
+      def clear_drafts
+        drafts.created_by(Card::Auth.current_id).each(&:delete)
+      end
+
+      def last_draft_content
+        drafts.last.card_changes.last.value
+      end
+
+      def blank_content?
+        content.blank? || content.strip.blank?
+      end
+
+      def nests?
+        content_object.has_chunk? Content::Chunk::Nest
+      end
+
+      def content_object
+        Card::Content.new content, self
+      end
+    end
+  end
+end

data/lib/card/content/chunk.rb

@@ -69,7 +69,7 @@ class Card
               chunk_class = const_get chunkname
               chunk_class.config[:prefix_re]
             end
-          /(?:#{ prefix_res * '|' })/m
+          /(?:#{prefix_res * '|'})/m
         end
 
         def validate_chunk_list_key chunk_list_key

data/lib/card/content/clean.rb

@@ -46,7 +46,7 @@ class Card
         # $LAST_MATCH_INFO is nil if string is a SafeBuffer
         string.to_str.gsub(%r{<(/*)(\w+)([^>]*)>}) do |_raw|
           clean_tag $LAST_MATCH_INFO, ok_tags
-        end.gsub(/<\!--.*?-->/, "")
+        end.gsub(/<!--.*?-->/, "")
       end
 
       def clean_spaces string
@@ -56,6 +56,7 @@ class Card
       def clean_tag match, ok_tags
         tag = match[2].downcase
         return " " unless (ok_attrs = ok_tags[tag])
+
         "<#{match[1]}#{html_attribs tag, match[3], ok_attrs}>"
       end
 
@@ -70,7 +71,7 @@ class Card
         return ['"', nil] unless all_attributes =~ /\b#{attrib}\s*=\s*(?=(.))/i
 
         q = '"'
-        rest_value = $'
+        rest_value = Regexp.last_match.post_match
         if (idx = %w[' "].index Regexp.last_match(1))
           q = Regexp.last_match(1)
         end
@@ -79,7 +80,7 @@ class Card
         [q, rest_value]
       end
 
-      # NOTE allows classes beginning with "w-" (deprecated)
+      # NOTE: allows classes beginning with "w-" (deprecated)
       def process_attribute_match rest_value, reg_exp, attrib
         return rest_value unless (match = rest_value.match reg_exp)
 

data/lib/card/content/diff.rb

@@ -22,6 +22,7 @@ class Card
       end
 
       attr_reader :result
+
       delegate :summary, :complete, :summary_omits_content?, to: :result
 
       # diff options
@@ -41,11 +42,11 @@ class Card
       end
 
       def red?
-        @result.dels_cnt > 0
+        @result.dels_cnt.positive?
       end
 
       def green?
-        @result.adds_cnt > 0
+        @result.adds_cnt.positive?
       end
 
       private