card 1.101.3 → 1.101.4

data/lib/card/fetch/card_class.rb

@@ -0,0 +1,147 @@
+class Card
+  class Fetch
+    # = Card#fetch
+    #
+    # A multipurpose retrieval operator that integrates caching, database lookups,
+    # and "virtual" card construction
+    module CardClass
+      # Look for cards in
+      # * cache
+      # * database
+      # * virtual cards
+      #
+      # @param args [Integer, String, Card::Name, Symbol, Array]
+      #    one or more of the three unique identifiers
+      #      1. a numeric id (Integer)
+      #      2. a name/key (String or Card::Name)
+      #      3. a codename (Symbol)
+      #    If you pass more then one mark or an array of marks they get joined with a '+'.
+      #    The final argument can be a hash to set the following options
+      #      :skip_virtual               Real cards only
+      #      :skip_modules               Don't load Set modules
+      #      :look_in_trash              Return trashed card objects
+      #      :local_only                 Use only local cache for lookup and storing
+      #      new: { opts for Card#new }  Return a new card when not found
+      # @return [Card]
+      def fetch *args
+        Card::Fetch.new(*args)&.retrieve_or_new
+      rescue ActiveModel::RangeError => _e
+        return Card.new name: "card id out of range: #{f.mark}"
+      end
+
+      # fetch only real (no virtual) cards
+      #
+      # @param mark - see #fetch
+      # @return [Card]
+      def [] *mark
+        fetch(*mark, skip_virtual: true)
+      end
+
+      # fetch real cards without set modules loaded. Should only be used for
+      # simple attributes
+      #
+      # @example
+      #   quick_fetch "A", :self, :structure
+      #
+      # @param mark - see #fetch
+      # @return [Card]
+      def quick_fetch *mark
+        fetch(*mark, skip_virtual: true, skip_modules: true)
+      end
+
+      # @return [Card]
+      def fetch_from_cast cast
+        fetch_args = cast[:id] ? [cast[:id].to_i] : [cast[:name], { new: cast }]
+        fetch(*fetch_args)
+      end
+
+      #----------------------------------------------------------------------
+      # ATTRIBUTE FETCHING
+      # The following methods optimize fetching of specific attributes
+
+      def id cardish
+        case cardish
+        when Integer then cardish
+        when Card then cardish.id
+        when Symbol then Card::Codename.id cardish
+        else fetch_id cardish
+        end
+      end
+
+      # @param mark_parts - see #fetch
+      # @return [Integer]
+      def fetch_id *mark_parts
+        mark = Card::Fetch.new(*mark_parts)&.mark
+        mark.is_a?(Integer) ? mark : quick_fetch(mark.to_s)&.id
+      end
+
+      # @param mark - see #fetch
+      # @return [Card::Name]
+      def fetch_name *mark, &block
+        if (card = quick_fetch(*mark))
+          card.name
+        elsif block_given?
+          yield.to_name
+        end
+      rescue => error
+        rescue_fetch_name error, &block
+      end
+
+      # @param mark - see #fetch
+      # @return [Integer]
+      def fetch_type_id *mark
+        fetch(*mark, skip_modules: true)&.type_id
+      end
+
+      # a fetch method to support the needs of the card controller.
+      # should be in Decko?
+      def controller_fetch args
+        card_opts = controller_fetch_opts args
+        if args[:action] == "create"
+          # FIXME: we currently need a "new" card to catch duplicates
+          # (otherwise save will just act like a normal update)
+          # We may need a "#create" instance method to handle this checking?
+          Card.new card_opts
+        else
+          standard_controller_fetch args, card_opts
+        end
+      end
+
+      private
+
+      def standard_controller_fetch args, card_opts
+        mark = args[:mark] || card_opts[:name]
+        card = Card.fetch mark, skip_modules: true,
+                                look_in_trash: args[:look_in_trash],
+                                new: card_opts
+        card.assign_attributes card_opts if args[:assign] && card&.real?
+        card&.include_set_modules
+        card
+      end
+
+      def controller_fetch_opts args
+        opts = Env.hash args[:card]
+        opts[:type] ||= args[:type] if args[:type]
+        # for /new/:type shortcut.  we should handle in routing and deprecate this
+        opts[:name] ||= Name.url_key_to_standard args[:mark]
+        opts
+      end
+
+      def rescue_fetch_name error, &block
+        if rescued_fetch_name_to_name? error, &block
+          yield.to_name
+        elsif error.is_a? ActiveModel::RangeError
+          nil
+        else
+          raise error
+        end
+      end
+
+      def rescued_fetch_name_to_name? error
+        return unless block_given?
+
+        error.is_a?(ActiveModel::RangeError) || error.is_a?(Error::CodenameNotFound)
+      end
+    end
+  end
+end

data/lib/card/format.rb

@@ -47,7 +47,7 @@ class Card
     def require_card_to_initialize!
       return if @card
 
-      raise Card::Error, Cardio.t(:exception_init_without_card)
+      raise Card::Error, Cardio.t(:lib_exception_init_without_card)
     end
 
     def include_set_format_modules

data/lib/card/format/error.rb

@@ -29,7 +29,7 @@ class Card
       end
 
       def monitor_depth
-        raise Card::Error::UserError, tr(:too_deep) if depth >= Card.config.max_depth
+        raise Card::Error::UserError, t(:format_too_deep) if depth >= Card.config.max_depth
         yield
       end
 
@@ -42,7 +42,7 @@ class Card
         if card&.name.present?
           safe_name
         else
-          Cardio.tr :no_cardname
+          Cardio.t :lib_no_cardname
         end
       end
 
@@ -71,7 +71,7 @@ class Card
         if exception.is_a? Card::Error::UserError
           exception.message
         else
-          tr :error_rendering, cardname: error_cardname(exception), view: view
+          t :lib_error_rendering, cardname: error_cardname(exception), view: view
         end
       end
     end

data/lib/card/format/nest.rb

@@ -2,7 +2,7 @@ class Card
   class Format
     # processing nests
     class Nest
-      include Fetch
+      include Nest::Fetch
 
       attr_accessor :format, :card, :view, :view_opts, :format_opts
       def initialize format, cardish, view_opts={}, format_opts={}

data/lib/card/format/nest/fetch.rb

@@ -24,7 +24,7 @@ class Card
         end
 
         def not_found_codename_error codename
-          Cardio.tr :exception_unknown_codename, codename: codename
+          Cardio.t :lib_exception_unknown_codename, codename: codename
         end
 
         def new_card cardish

data/lib/card/lexicon.rb

@@ -36,12 +36,12 @@ class Card
 
       def update card
         add card
-        cache.delete cache_key(card.old_lex)
+        cache.delete cache_key(card.lex_before_act)
       end
 
       # def delete card
       #   cache.delete card.id.to_s
-      #   cache.delete cache_key(card.old_lex)
+      #   cache.delete cache_key(card.lex_before_act)
       # end
 
       def lex_to_name lex

data/lib/card/name/all.rb

@@ -35,6 +35,10 @@ class Card
         end
       end
 
+      def lex
+        simple? ? name : [left_id, right_id]
+      end
+
       def autoname name
         if Card.exists?(name) || Director.include?(name)
           autoname name.next
@@ -64,6 +68,10 @@ class Card
         @key
       end
 
+      def field tag, opts={}
+        Card.fetch name.field(tag), opts
+      end
+
       private
 
       def assign_side_ids

data/lib/card/name/all/descendants.rb

@@ -19,9 +19,12 @@ class Card
         end
 
         def each_child
-          child_ids.each do |id|
-            (child = Card[id]) && yield(child)
-            # check should not be needed (remove after fixing data problems)
+          return unless id
+
+          Card.where(
+            "(left_id = #{id} or right_id = #{id}) and trash is false"
+          ).each do |child|
+            yield child
           end
         end
 

data/lib/card/name/card_class.rb

@@ -0,0 +1,26 @@
+class Card
+  class Name
+    # Name-related Card class methods
+    module CardClass
+      def rename! oldname, newname
+        Card[oldname].update! name: newname, update_referers: true
+      end
+
+      def uniquify_name name, rename=:new
+        return name unless Card.exists? name
+        uniq_name = generate_alternative_name name
+        return uniq_name unless rename == :old
+        rename!(name, uniq_name)
+        name
+      end
+
+      private
+
+      def generate_alternative_name name
+        uniq_name = "#{name} 1"
+        uniq_name.next! while Card.exists?(uniq_name)
+        uniq_name
+      end
+    end
+  end
+end

data/lib/card/reference/all.rb

@@ -0,0 +1,131 @@
+class Card
+  class Reference < ApplicationRecord
+    module All
+      # frozen_string_literal: true
+
+      # Cards can refer to other cards in their content, eg via links and nests.
+      # The card that refers is the "referer", the card that is referred to is
+      # the "referee". The reference itself has its own class (Card::Reference),
+      # which handles id-based reference tracking.
+
+      PARTIAL_REF_CODE = "P".freeze
+
+      # cards that refer to self
+      def referers
+        referer_cards_from_references references_in
+      end
+
+      # cards that include self
+      def nesters
+        referer_cards_from_references references_in.where(ref_type: "I")
+      end
+
+      def referer_cards_from_references references
+        references.map(&:referer_id).uniq.map(&Card.method(:fetch)).compact
+      end
+
+      # cards that self refers to
+      def referees
+        referees_from_references references_out
+      end
+
+      # cards that self includes
+      def nestees
+        referees_from_references references_out.where(ref_type: "I")
+      end
+
+      def referees_from_references references
+        references.map(&:referee_key).uniq.map { |key| Card.fetch key, new: {} }
+      end
+
+      # cards that refer to self by name
+      # (finds cards not yet linked by id)
+      def name_referers
+        Card.joins(:references_out).where card_references: { referee_key: key }
+      end
+
+      # delete old references from this card's content, create new ones
+      def update_references_out
+        delete_references_out
+        create_references_out
+      end
+
+      # interpret references from this card's content and
+      # insert entries in reference table
+      def create_references_out
+        ref_hash = {}
+        each_reference_out do |referee_name, ref_type|
+          interpret_reference ref_hash, referee_name, ref_type
+        end
+        return if ref_hash.empty?
+        Reference.mass_insert reference_values_array(ref_hash)
+      end
+
+      # delete references from this card
+      def delete_references_out
+        raise "id required to delete references" if id.nil?
+        Reference.where(referer_id: id).delete_all
+      end
+
+      private
+
+      def with_normalized_referee referee_name
+        return unless referee_name # eg commented nest has no referee_name
+        referee_name = referee_name.to_name
+        referee_key = referee_name.key
+        return if referee_key == key # don't create self reference
+        yield referee_name, referee_key, Lexicon.id(referee_name)
+      end
+
+      # interpretation phase helps to prevent duplicate references
+      # results in hash like:
+      # { referee1_key: [referee1_id, referee1_type2],
+      #   referee2_key...
+      # }
+      def interpret_reference ref_hash, raw_referee_name, ref_type
+        with_normalized_referee raw_referee_name do |name, key, id|
+          ref_hash[key] ||= [id]
+          ref_hash[key] << ref_type
+          interpret_partial_references ref_hash, name unless id
+        end
+      end
+
+      # translate interpreted reference hash into values array,
+      # removing duplicate and unnecessary ref_types
+      def reference_values_array ref_hash
+        [].tap do |values|
+          ref_hash.each do |referee_key, hash_val|
+            referee_id = hash_val.shift || "null"
+            each_reference_type hash_val.uniq do |ref_type|
+              values << [id, referee_id, "'#{referee_key}'", "'#{ref_type}'"]
+            end
+          end
+        end
+      end
+
+      def each_reference_type ref_types
+        ref_types.delete PARTIAL_REF_CODE if ref_types.size > 1
+        # partial references are not necessary if there are explicit references
+        ref_types.each { |ref_type| yield ref_type }
+      end
+
+      # invokes the given block for each reference in content with
+      # the reference name and reference type
+      def each_reference_out
+        content_object.find_chunks(:Reference).each do |chunk|
+          yield chunk.referee_name, chunk.reference_code
+        end
+      end
+
+      # Partial references are needed to track references to virtual cards.
+      # For example a link to virual card [[A+*self]] won't have a referee_id,
+      # but when A's name is changed we have to find and update that link.
+      def interpret_partial_references ref_hash, referee_name
+        return if referee_name.simple?
+        [referee_name.left, referee_name.right].each do |sidename|
+          interpret_reference ref_hash, sidename, PARTIAL_REF_CODE
+        end
+      end
+    end
+  end
+end

data/lib/card/rule/all.rb

@@ -0,0 +1,75 @@
+class Card
+  module Rule
+    # rule-related Card instance methods
+    module All
+      def rule setting_code
+        rule_card(setting_code, skip_modules: true)&.db_content
+      end
+
+      def rule_card setting_code, options={}
+        Card.fetch rule_card_id(setting_code), options
+      end
+
+      def rule_card_id setting_code
+        rule_id_lookup Card::Rule.rule_cache, setting_code
+      end
+
+      def preference setting_code, user=nil
+        preference_card(setting_code, user, skip_modules: true)&.db_content
+      end
+
+      def preference_card setting_code, user=nil, options={}
+        Card.fetch preference_card_id(setting_code, user), options
+      end
+
+      def preference_card_id setting_code, user=nil
+        return unless (user_id = preference_user_id user)
+        rule_id_lookup Card::Rule.preference_cache,
+                       "#{setting_code}+#{user_id}",
+                       "#{setting_code}+#{AllID}"
+      end
+
+      def rule?
+        standard_rule? || preference?
+      end
+
+      def standard_rule?
+        (Card.fetch_type_id(name.right) == SettingID) &&
+          (Card.fetch_type_id(name.left) == SetID)
+      end
+
+      def preference?
+        name.parts.length > 2 &&
+          (Card.fetch_type_id(name.right) == SettingID) &&
+          (Card.fetch_type_id(name[0..-3]) == SetID) &&
+          valid_preferer?
+      end
+
+      private
+
+      def valid_preferer?
+        preferer = self[-2, skip_modules: true]
+        (preferer.type_id == UserID) || (preferer.codename == :all)
+      end
+
+      def preference_user_id user
+        case user
+        when Integer then user
+        when Card    then user.id
+        when nil     then Auth.current_id
+        else
+          raise Card::ServerError, "invalid preference user"
+        end
+      end
+
+      def rule_id_lookup lookup_hash, cache_suffix, fallback_suffix=nil
+        rule_set_keys.each do |rule_set_key|
+          rule_id = lookup_hash["#{rule_set_key}+#{cache_suffix}"]
+          rule_id ||= fallback_suffix && lookup_hash["#{rule_set_key}+#{fallback_suffix}"]
+          return rule_id if rule_id
+        end
+        nil
+      end
+    end
+  end
+end