card 1.101.3 → 1.101.4

data/db/migrate_core_cards/20150202143810_import_bootstrap_layout.rb

@@ -66,7 +66,7 @@ class ImportBootstrapLayout < Cardio::Migration::Core
     # update layouts to have explicit views in nests
     Card.search(type_id: Card::LayoutTypeID) do |lcard|
       lcontent = Card::Content.new lcard.db_content, lcard
-      lcontent.find_chunks(Card::Content::Chunk::Nest).each do |nest|
+      lcontent.find_chunks(:Nest).each do |nest|
         nest.explicit_view =
           nest.options[:nest_name] == "_main" ? "open" : "core"
       end

data/lib/card.rb

@@ -113,12 +113,24 @@ ActiveSupport.run_load_hooks(:before_card, self)
 class Card < ApplicationRecord
   extend Mark
   extend Dirty::MethodFactory
-  extend Name::All::ClassMethods
+  extend Name::CardClass
+  extend Cache::CardClass
+  extend Director::CardClass
+  extend Fetch::CardClass
 
   include Dirty
   include DirtyNames
   include Director::CardMethods
   include Name::All
+  include Content::All
+  include Set::Event::All
+  include Set::Pattern::All
+  include Cache::All
+  include Director::All
+  include Reference::All
+  include Rule::All
+  include Fetch::All
+  include Subcards::All
 
   Card::Cache # trigger autoload
 
@@ -146,7 +158,6 @@ class Card < ApplicationRecord
     :skip_in_action,              # skip event for just this card
     :trigger,                     # trigger event(s) for all cards in act
     :trigger_in_action,           # trigger event for just this card
-
     :comment,                     # obviated soon
 
     # TODO: refactor following to use skip/trigger
@@ -156,6 +167,8 @@ class Card < ApplicationRecord
   ]
 
   attr_accessor(*action_specific_attributes)
+  self.action_specific_attributes +=
+    %i[skip_hash full_skip_hash trigger_hash full_trigger_hash]
 
   define_callbacks :select_action, :show_page, :act
 

data/lib/card/auth.rb

@@ -10,8 +10,7 @@ class Card
     extend Proxy
     extend Setup
     extend Current
-
-    @as_card = @as_id = @current_id = @current = nil
+    extend Token
 
     class << self
       # authenticate a user by their login name and unencrypted password.
@@ -40,6 +39,10 @@ class Card
       def encrypt password, salt
         Digest::SHA1.hexdigest "#{salt}--#{password}--"
       end
+
+      def serialize
+        { as_id: as_id, current_id: current_id }
+      end
     end
   end
 end

data/lib/card/auth/current.rb

@@ -2,114 +2,66 @@ class Card
   module Auth
     # methods for setting current account
     module Current
-      # set current user in process and session
-      def signin cardish
-        signin_id = Card.id(cardish) || Card::AnonymousID
-        self.current_id = signin_id
-        set_session_user signin_id
-      end
-
-      # current user is not anonymous
-      # @return [true/false]
-      def signed_in?
-        current_id != Card::AnonymousID
-      end
-
       # id of current user card.
       # @return [Integer]
       def current_id
         @current_id ||= Card::AnonymousID
       end
 
+      # set the id of the current user.
+      # @return [Integer]
+      def current_id= card_id
+        reset
+        card_id = card_id.to_i if card_id.present?
+        @current_id = card_id
+      end
+
       # current accounted card (must have +\*account)
       # @return [Card]
-      def current
-        if @current && @current.id == current_id
-          @current
-        else
-          @current = Card[current_id]
-        end
+      def current_card
+        return @current_card if @current_card&.id == current_id
+
+        @current_card = Card[current_id]
       end
+      alias_method :current, :current_card
 
       def current_roles
         @current_roles ||= [Card.fetch_name(:anyone_signed_in),
                             current.fetch(:roles)&.item_names].flatten.compact
       end
 
-      def serialize
-        { as_id: as_id, current_id: current_id }
-      end
-
-      # @param auth_data [Integer|Hash] user id, user name, or a hash
-      # @option auth_data [Integer] current_id
-      # @option auth_data [Integer] as_id
-      def with auth_data
-        if auth_data.is_a?(Integer) || auth_data.is_a?(String)
-          auth_data = { current_id: Card.id(auth_data) }
-        end
-
-        tmp_current_id = current_id
-        tmp_as_id = as_id
-        tmp_current = @current
-        tmp_as_card = @as_card
-        tmp_current_roles = @current_roles
-
-        # resets @as and @as_card
-        self.current_id = auth_data[:current_id]
-        @as_id = auth_data[:as_id] if auth_data[:as_id]
-        yield
-      ensure
-        @current_id = tmp_current_id
-        @as_id = tmp_as_id
-        @current = tmp_current
-        @as_card = tmp_as_card
-        @current_roles = tmp_current_roles
+      # set current user in process and session
+      def signin cardish
+        session[session_user_key] =
+          self.current_id = Card.id(cardish) || Card::AnonymousID
       end
 
-      # get session object from Env
-      # return [Session]
-      def session
-        Card::Env.session
+      # current user is not anonymous
+      # @return [true/false]
+      def signed_in?
+        current_id != Card::AnonymousID
       end
 
       # set current from token, api_key, or session
-      def signin_with opts={}
+      def signin_with _opts={}
         if opts[:token]
           signin_with_token opts[:token]
-        elsif opts[:api_key]
-          signin_with_api_key opts[:api_key]
         else
           signin_with_session
         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
-
-      # set the current user based on api_key
-      def signin_with_api_key api_key
-        account = find_account_by_api_key api_key
-        unless account&.validate_api_key! api_key
-          raise Card::Error::PermissionDenied, "API key authentication failed"
-        end
-
-        signin account.left_id
-      end
-
       # get :user id from session and set Auth.current_id
       def signin_with_session
-        card_id = session_user
-        signin(card_id && Card.exists?(card_id) ? card_id : nil)
+        card_id = session[session_user_key]
+        card_id = nil unless Card.exists? card_id
+        signin card_id
       end
 
-      # find +\*account card by +\*api card
-      # @param api_key [String]
-      # @return [+*account card, nil]
-      def find_account_by_api_key api_key
-        find_account_by :api_key, api_key.strip
+      # get session object from Env
+      # return [Session]
+      def session
+        Card::Env.session
       end
 
       # find +\*account card by +\*email card
@@ -119,6 +71,16 @@ class Card
         find_account_by :email, email.strip.downcase
       end
 
+      def reset
+        @as_id = @as_card = @current_id = @current_card = @current_roles = nil
+      end
+
+      def session_user_key
+        "user_#{Cardio.database_name.underscore}".to_sym
+      end
+
+      private
+
       # general pattern for finding +\*account card based on field cards
       # @param fieldcode [Symbol] code of account field
       # @param value [String] content of field
@@ -130,29 +92,6 @@ class Card
                       "find +:account with +#{fieldcode} (#{value})").first
         end
       end
-
-      def session_user
-        session[session_user_key]
-      end
-
-      def set_session_user card_id
-        session[session_user_key] = card_id
-      end
-
-      def session_user_key
-        "user_#{database.underscore}".to_sym
-      end
-
-      def database
-        Rails.configuration.database_configuration.dig Rails.env, "database"
-      end
-
-      # set the id of the current user.
-      def current_id= card_id
-        @current = @as_id = @as_card = @current_roles = nil
-        card_id = card_id.to_i if card_id.present?
-        @current_id = card_id
-      end
     end
   end
 end

data/lib/card/auth/proxy.rb

@@ -4,10 +4,10 @@ class Card
     module Proxy
       # operate with the permissions of another "proxy" user
       def as given_user
-        tmp_id   = @as_id
+        tmp_id = @as_id
         tmp_card = @as_card
 
-        @as_id   = get_user_id(given_user)
+        @as_id = Card.id given_user
         @as_card = nil
         # we could go ahead and set as_card if given a card...
 
@@ -18,7 +18,7 @@ class Card
         yield
       ensure
         if block_given?
-          @as_id   = tmp_id
+          @as_id = tmp_id
           @as_card = tmp_card
         end
       end
@@ -37,22 +37,42 @@ class Card
       # proxy user card
       # @return [Card]
       def as_card
-        if @as_card && @as_card.id == as_id
-          @as_card
-        else
-          @as_card = Card[as_id]
-        end
+        return @as_card if @as_card&.id == as_id
+
+        @as_card = Card[as_id]
       end
 
-      # get card id from args of unknown type
-      # @todo replace with general mechanism, eg #quick_fetch
-      def get_user_id user
-        case user
-        when NilClass then nil
-        when Card     then user.id
-        when Integer   then user
-        else Card.fetch_id(user)
+      # @param auth_data [Integer|Hash] user id, user name, or a hash
+      # @option auth_data [Integer] current_id
+      # @option auth_data [Integer] as_id
+      def with auth_data
+        if auth_data.is_a?(Integer) || auth_data.is_a?(String)
+          auth_data = { current_id: Card.id(auth_data) }
         end
+
+        temporarily do
+          # resets @as and @as_card
+          self.current_id = auth_data[:current_id]
+          @as_id = auth_data[:as_id] if auth_data[:as_id]
+          yield
+        end
+      end
+
+      private
+
+      def temporarily
+        tmp_current_id = current_id
+        tmp_as_id = as_id
+        tmp_current_card = @current_card
+        tmp_as_card = @as_card
+        tmp_current_roles = @current_roles
+        yield
+      ensure
+        @current_id = tmp_current_id
+        @as_id = tmp_as_id
+        @current = tmp_current_card
+        @as_card = tmp_as_card
+        @current_roles = tmp_current_roles
       end
     end
   end

data/lib/card/auth/token.rb

@@ -33,6 +33,12 @@ class Card
           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/all.rb

@@ -0,0 +1,83 @@
+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,41 @@
+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