card 1.103.4 → 1.104.0

data/lib/card/reference.rb

@@ -4,17 +4,21 @@ class Card
   # a Reference is a directional relationship from one card (the referer)
   # to another (the referee).
   class Reference < Cardio::Record
+    # card that refers
+    def referer
+      Card[referer_id]
+    end
+
+    # card that is referred to
+    def referee
+      Card[referee_id]
+    end
+
     class << self
       # bulk insert improves performance considerably
       # array takes form [ [referer_id, referee_id, referee_key, ref_type], ...]
       def mass_insert array
-        return if array.empty?
-
-        value_statements = array.map { |values| "\n(#{values.join ', '})" }
-        sql = "INSERT into card_references "\
-              "(referer_id, referee_id, referee_key, ref_type) "\
-              "VALUES #{value_statements.join ', '}"
-        Card.connection.execute sql
+        Card.connection.execute mass_insert_sql(array) if array.present?
       end
 
       # map existing reference to name to card via id
@@ -27,22 +31,10 @@ class Card
         where(referee_id: referee_id).update_all referee_id: nil
       end
 
-      # find all references to missing (eg deleted) cards and reset them
-      def unmap_if_referee_missing
-        joins(
-          "LEFT JOIN cards ON card_references.referee_id = cards.id"
-        ).where(
-          "(cards.id IS NULL OR cards.trash IS TRUE) AND referee_id IS NOT NULL"
-        ).update_all referee_id: nil
-      end
-
-      # remove all references from missing (eg deleted) cards
-      def delete_if_referer_missing
-        joins(
-          "LEFT JOIN cards ON card_references.referer_id = cards.id"
-        ).where(
-          "cards.id IS NULL"
-        ).pluck_in_batches(:id) do |group_ids|
+      # remove reference to and from missing cards
+      def clean
+        missing(:referee_id).where("referee_id IS NOT NULL").update_all referee_id: nil
+        missing(:referer_id).pluck_in_batches(:id) do |group_ids|
           # used to be .delete_all here, but that was failing on large dbs
           Rails.logger.info "deleting batch of references"
           where("id in (#{group_ids.join ','})").delete_all
@@ -52,34 +44,37 @@ class Card
       # repair references one by one (delete, create, delete, create...)
       # slower, but better than #recreate_all for use on running sites
       def repair_all
-        delete_if_referer_missing
-        Card.where(trash: false).find_each do |card|
-          Rails.logger.info "updating references from #{card}"
-          card.include_set_modules
-          card.update_references_out
-        end
+        clean
+        each_card(&:update_references_out)
       end
 
       # delete all references, then recreate them one by one
       # faster than #repair_all, but not recommended for use on running sites
       def recreate_all
         delete_all
+        each_card(&:create_references_out)
+      end
+
+      private
+
+      # find all references to or from missing (eg deleted) cards
+      def missing field
+        joins("LEFT JOIN cards ON card_references.#{field} = cards.id")
+          .where("(cards.id IS NULL OR cards.trash IS TRUE)")
+      end
+
+      def each_card
         Card.where(trash: false).find_each do |card|
-          Rails.logger.info "updating references from #{card}"
-          card.include_set_modules
-          card.create_references_out
+          Rails.logger.debug "references from #{card.name}"
+          yield card.include_set_modules
         end
       end
-    end
-
-    # card that refers
-    def referer
-      Card[referer_id]
-    end
 
-    # card that is referred to
-    def referee
-      Card[referee_id]
+      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/all.rb

@@ -64,9 +64,9 @@ class Card
       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}"]
+        rule_lookup_keys.each do |lookup_key|
+          rule_id = lookup_hash["#{lookup_key}+#{cache_suffix}"]
+          rule_id ||= fallback_suffix && lookup_hash["#{lookup_key}+#{fallback_suffix}"]
           return rule_id if rule_id
         end
         nil

data/lib/card/set/advanced_api.rb

@@ -2,6 +2,11 @@ class Card
   module Set
     # advanced set module API
     module AdvancedApi
+      def assign_type type, module_key=nil
+        module_key ||= shortname
+        Type.assignment[module_key] = type.card_id
+      end
+
       def setting_opts opts
         extend Card::Setting
         register_setting opts

data/lib/card/set/event/delayed_event.rb

@@ -1,7 +1,14 @@
 class Card
   # attributes that ActiveJob can handle
+  #
+  # supercard and superleft are excluded, because it caused issues to have them in
+  # delayed job but not fully restored (set modules not included, attributes not retained,
+  # etc.) Since we're supposed to have an actual _left_ by the integrate_with_delay
+  # stage, it's not clear that they're needed. But if we revisit and find they _are_
+  # needed, then we clearly need to make sure that they are fully restored. At a bare
+  # minimum they would need to include set modules.
   def serializable_attributes
-    self.class.action_specific_attributes + set_specific.keys
+    self.class.action_specific_attributes + set_specific.keys - %i[supercard superleft]
   end
 
   module Set

data/lib/card/set/event.rb

@@ -168,6 +168,7 @@ class Card
   def rescuing_integration
     yield
   rescue StandardError => e
+    # puts "integration error: #{e.message}".red
     Card::Error.report e, self
   ensure
     true

data/lib/card/set/helpers.rb

@@ -20,7 +20,7 @@ class Card
       end
 
       def set_format_type_key
-        :"#{set_type_key}_format"
+        @set_format_type_key ||= :"#{set_type_key}_format"
       end
 
       def set_type_key
@@ -64,22 +64,6 @@ class Card
         end
       end
 
-      def format_modules format_sym
-        type_key = set_format_type_key
-        if !type_key || type_key == :base_format
-          [format_module(format_sym)]
-        elsif abstract_set?
-          [test_set.format_module(format_sym)]
-        else
-          format_class = Card::Format.format_class format: format_sym
-          Card::Set.modules[type_key][format_class][shortname] || []
-        end
-      end
-
-      def format_module format_sym
-        const_get Card::Format.format_class_name(format_sym)
-      end
-
       def test_set
         # rubocop:disable Lint/Eval
         ::Card::Set::Self.const_remove_if_defined :TestSet
@@ -94,6 +78,35 @@ class Card
         ::Card::Set::Self::TestSet
         # rubocop:enable Lint/Eval
       end
+
+      def format_modules format_sym, test: true
+        if base_format_modules?
+          [format_module(format_sym)]
+        elsif abstract_set?
+          abstract_format_modules format_sym, test
+        else
+          nonbase_format_modules format_sym
+        end
+      end
+
+      def format_module format_sym
+        const_get Card::Format.format_class_name(format_sym)
+      end
+
+      private
+
+      def base_format_modules?
+        !set_format_type_key || set_format_type_key == :base_format
+      end
+
+      def abstract_format_modules format_sym, test
+        [(test ? test_set : self).format_module(format_sym)]
+      end
+
+      def nonbase_format_modules format_sym
+        format_class = Card::Format.format_class format: format_sym
+        Card::Set.modules[set_format_type_key][format_class][shortname] || []
+      end
     end
   end
 end

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

@@ -1,6 +1,6 @@
 class Card
   module Set
-    class Pattern
+    module Pattern
       # pattern-related Card instance methods
       module All
         def patterns?
@@ -20,7 +20,7 @@ class Card
           # Rails.logger.info "resetting patterns: #{name}"
           @patterns = @concrete_patterns = nil
           @template = @virtual = nil
-          @set_mods_loaded = @set_modules = @set_names = @rule_set_keys = nil
+          @set_mods_loaded = @set_modules = @set_names = @rule_lookup_keys = nil
           @junction_only = nil # only applies to set cards
           true
         end
@@ -51,13 +51,22 @@ class Card
           patterns.map(&:module_key).include? set_module.shortname
         end
 
-        def rule_set_keys
-          @rule_set_keys ||= patterns.map(&:rule_set_key).compact
+        def rule_lookup_keys
+          @rule_lookup_keys ||= patterns.map(&:rule_lookup_key).compact
         end
 
         def include_module? set
           singleton_class&.include? set
         end
+
+        def each_type_assigning_module_key
+          patterns.each do |p|
+            next unless p.assigns_type
+
+            module_key = p.module_key
+            yield module_key if module_key
+          end
+        end
       end
     end
   end

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

@@ -1,19 +1,21 @@
 class Card
   module Set
-    class Pattern
+    module Pattern
       # class from which set patterns inherit
       class Base
         extend ClassMethods
+        delegate :pattern_code, :pattern, :anchorless?, :anchor_parts_count,
+                 :assigns_type, to: :class
 
         def initialize card
-          return if self.class.anchorless?
+          return if anchorless?
 
           @anchor_name = self.class.anchor_name(card).to_name
           @anchor_id = find_anchor_id card
         end
 
         def find_anchor_id card
-          self.class.try(:anchor_id, card) || Card.fetch_id(@anchor_name)
+          self.class.try(:anchor_id, card) || @anchor_name.card_id
         end
 
         def module_key
@@ -53,16 +55,8 @@ class Card
           end
         end
 
-        def anchor_parts_count
-          self.class.anchor_parts_count
-        end
-
-        def pattern
-          @pattern ||= self.class.pattern
-        end
-
         def to_s
-          self.class.anchorless? ? pattern.s : "#{@anchor_name}+#{pattern}"
+          anchorless? ? pattern.s : "#{@anchor_name}+#{pattern}"
         end
 
         def inspect
@@ -70,15 +64,15 @@ class Card
         end
 
         def safe_key
-          caps_part = self.class.pattern_code.to_s.tr(" ", "_").upcase
-          self.class.anchorless? ? caps_part : "#{caps_part}-#{@anchor_name.safe_key}"
+          caps_part = pattern_code.to_s.tr(" ", "_").upcase
+          anchorless? ? caps_part : "#{caps_part}-#{@anchor_name.safe_key}"
         end
 
-        def rule_set_key
-          if self.class.anchorless?
-            self.class.pattern_code.to_s
+        def rule_lookup_key
+          if anchorless?
+            pattern_code.to_s
           elsif @anchor_id
-            "#{@anchor_id}+#{self.class.pattern_code}"
+            "#{@anchor_id}+#{pattern_code}"
           end
         end
       end

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

@@ -1,10 +1,9 @@
 class Card
   module Set
-    class Pattern
+    module Pattern
       # methods for Set::Pattern classes
       module ClassMethods
-        attr_accessor :pattern_code, :pattern_id, :junction_only,
-                      :assigns_type, :anchorless
+        attr_accessor :pattern_code, :junction_only, :assigns_type, :anchorless
         attr_writer :anchor_parts_count
 
         def new card
@@ -12,14 +11,10 @@ class Card
         end
 
         def register pattern_code, opts={}
-          if (self.pattern_id = Card::Codename.id(pattern_code))
-            self.pattern_code = pattern_code
-            Pattern.concrete.insert opts.delete(:index).to_i, self
-            self.anchorless = !respond_to?(:anchor_name)
-            opts.each { |key, val| send "#{key}=", val }
-          else
-            warn "no codename for pattern code: #{pattern_code}"
-          end
+          self.pattern_code = pattern_code
+          Pattern.concrete.insert opts.delete(:index).to_i, self
+          self.anchorless = !respond_to?(:anchor_name)
+          opts.each { |key, val| send "#{key}=", val }
         end
 
         def junction_only?
@@ -30,8 +25,13 @@ class Card
           anchorless
         end
 
+        def pattern_id
+          pattern_code.card_id
+        end
+
+        # TODO: change to #name or #pattern_name
         def pattern
-          Card.fetch(pattern_id, skip_modules: true).name
+          pattern_id.cardname
         end
 
         def pattern_applies? card
@@ -44,7 +44,7 @@ class Card
 
         def module_key anchor_codes
           return pattern_code.to_s.camelize if anchorless?
-          return unless anchor_codes # is this not an error?
+          return unless anchor_codes # not all anchors have codenames
 
           ([pattern_code] + anchor_codes).map { |code| code.to_s.camelize }.join "::"
         end

data/lib/card/set/pattern.rb

@@ -1,54 +1,65 @@
 class Card
   module Set
-    class Pattern
+    # Each deck can have countless sets of cards, each of which follows one of a small
+    # list of patterns. This module provides methods for managing those patterns.
+    module Pattern
       class << self
+        # Pattern classes all the patterns except for Abstract.
+        # They are concrete because they are defined on a set of cards
+        # (while abstract sets must be included on them explicitly).
+        #
+        # @return [Array <Class>]
         def concrete
           @concrete ||= []
         end
 
+        # Pattern classes that can be reloaded without reloading Card
+        # (everything but all)
+        # @return [Array <Class>]
+        def reloadables
+          concrete - [Set::All] + Abstract
+        end
+
+        # remove reloadable sets and prepare for reloading
         def reset
           reloadables.each do |set_pattern|
             Set.const_remove_if_defined set_pattern.to_s.split("::").last
           end
-          @concrete = []
-          @card_keys = @codes = @nonbase_codes = @ids = nil
-        end
-
-        def reloadables
-          r = concrete.push(Abstract)
-          r.delete Set::All
-          r
+          @concrete = @codes = @type_assigner_codes = @nonbase_codes = @ids = nil
         end
 
+        # finds pattern class associated with codename
+        # e.g. find(:type) returns `Card::Set::Type`
+        #
+        # @return [Class] pattern class
         def find pattern_code
           concrete.find { |sub| sub.pattern_code == pattern_code }
         end
 
-        def card_keys
-          @card_keys ||=
-            concrete.each_with_object({}) do |set_pattern, hash|
-              hash[set_pattern.pattern_id.cardname.key] = true
-            end
+        # list of codenames of pattern cards
+        # @return [Array <Symbol>]
+        def codes
+          @codes ||= concrete.map(&:pattern_code).to_set
         end
 
+        # list of lists of codenames in pattern load order
+        # @return [Array <Array <Symbol>>]
         def grouped_codes with_all: true
           g = [[:abstract], nonbase_codes.reverse]
           g.unshift [:all] if with_all
           g
         end
 
+        # list of ids of pattern cards
+        # @return [Array <Integer>]
         def ids
           @ids ||= concrete.map(&:pattern_id)
         end
 
         private
 
-        def codes
-          @codes ||= concrete.map(&:pattern_code)
-        end
-
         def nonbase_codes
-          @nonbase_codes ||= codes.tap { |list| list.delete :all }
+          @nonbase_codes ||= codes.to_a - [:all]
         end
       end
     end

data/lib/card/set/trait.rb

@@ -1,6 +1,6 @@
 class Card
   module Set
-    # ActiveCard support: accessing plus cards as attributes
+    # accessing plus cards as attributes
     module Trait
       def card_accessor *args
         options = args.extract_options!
@@ -45,11 +45,25 @@ class Card
           define_trait_card trait, new_opts
           define_trait_reader trait if options[:reader]
           define_trait_writer trait if options[:writer]
+          assign_trait_type trait, options[:type]
 
           mod_traits[trait.to_sym] = options
         end
       end
 
+      def assign_trait_type trait, type
+        return unless type && (parts = trait_module_key_parts trait)
+        assign_type type, normalize_const(parts)
+      end
+
+      def trait_module_key_parts trait
+        if all_set?
+          [:right, trait]
+        elsif type_set?
+          [:type_plus_right, set_name_parts.last, trait]
+        end
+      end
+
       def new_trait_opts options
         %i[type default_content].each_with_object({}).each do |key, hash|
           hash[key] = options[key] if options[key]
@@ -58,6 +72,7 @@ class Card
 
       def define_trait_card trait, opts
         define_method "#{trait}_card" do
+          # opts = opts.clone.merge supercard: card
           fetch trait.to_sym, new: opts.clone, eager_cache: true
         end
       end

data/lib/card/set/type.rb

@@ -1,6 +1,9 @@
 class Card
   module Set
     class Type < Pattern::Base
+      cattr_accessor :assignment
+      self.assignment = {}
+
       def initialize card
         super
         # support type inheritance

data/lib/card/subcards/add.rb

@@ -53,9 +53,7 @@ class Card
 
       def new_by_card card
         card.supercard = @context_card
-        if !card.name.simple? && card.name.field_of?(@context_card.name)
-          card.superleft = @context_card
-        end
+        card.update_superleft card.name
         @keys << card.key
         Card.write_to_soft_cache card
         card.director = @context_card.director.subdirectors.add card

data/lib/card/subcards/all.rb

@@ -2,18 +2,6 @@ class Card
   class Subcards
     # subcard-related Card instance methods
     module All
-      def subcard card_name
-        subcards.card card_name
-      end
-
-      def subfield field_name
-        subcards.field field_name
-      end
-
-      def field? tag
-        field(tag) || subfield(tag)
-      end
-
       def subcards
         @subcards ||= Card::Subcards.new self
       end
@@ -22,66 +10,50 @@ class Card
         subcards.present?
       end
 
-      def expire_subcards
-        subcards.clear
-      end
-
-      # phase_method :attach_subcard, before: :store do |name_or_card, args=nil|
-      # TODO: handle differently in different stages
-      def add_subcard name_or_card, args={}
-        subcards.add name_or_card, args
-      end
-      alias_method :attach_subcard, :add_subcard
-
-      def add_subcard! name_or_card, args={}
-        subcard = subcards.add name_or_card, args
-        subcard.director.reset_stage
-        subcard
+      def subcard card_name, args={}
+        if (sc = subcards.card card_name)
+          sc.assign_attributes args
+          sc
+        else
+          subcards.add card_name, args
+        end
       end
-      alias_method :attach_subcard!, :add_subcard!
 
-      # phase_method :attach_subfield, before: :approve do |name_or_card, args=nil|
-      def attach_subfield name_or_card, args={}
-        subcards.add_field name_or_card, args
+      def subcard_content card_name
+        subcards.card(card_name)&.content
       end
-      alias_method :add_subfield, :attach_subfield
 
-      def attach_subfield! name_or_card, args={}
-        subcard = subcards.add_field name_or_card, args
-        subcard.director.reset_stage
-        subcard
+      def subcard? card_name
+        subcards.card(card_name).present?
       end
 
-      def detach_subcard name_or_card
-        subcards.remove name_or_card
+      def subfield field_name, args={}
+        if (sf = subcards.field field_name)
+          sf.assign_attributes args
+          sf
+        else
+          subcards.add_field field_name, args
+        end
       end
-      alias_method :remove_subcard, :detach_subcard
 
-      def detach_subfield name_or_card
-        subcards.remove_field name_or_card
+      def subfield_content field_name
+        subcards.field(field_name)&.content
       end
-      alias_method :remove_subfield, :detach_subfield
 
-      def clear_subcards
-        subcards.clear
+      def subfield? field_name
+        subcards.field(field_name).present?
       end
 
-      # ensures subfield is present
-      # does NOT override subfield content if already present
-      def ensure_subfield field_name, args={}
-        if subfield_present? field_name
-          subfield field_name
-        else
-          add_subfield field_name, args
-        end
+      def field? tag
+        field(tag) || subfield?(tag)
       end
 
-      def subfield_present? field_name
-        subfield(field_name)&.content&.present?
+      def drop_subcard name_or_card
+        subcards.remove name_or_card
       end
 
-      def deep_clear_subcards
-        subcards.deep_clear
+      def drop_subfield name_or_card
+        subcards.remove_field name_or_card
       end
 
       def handle_subcard_errors
@@ -93,6 +65,8 @@ class Card
         end
       end
 
+      private
+
       def subcard_error subcard, error
         msg = error.message
         msg = "#{error.attribute} #{msg}" unless %i[content abort].member? error.attribute