card 1.103.3 → 1.104.2

data/lib/card/name/card_class.rb

@@ -7,6 +7,7 @@ class Card
       end
 
       def uniquify_name name, rename=:new
+        name = name.to_name
         return name unless Card.exists? name
 
         uniq_name = generate_alternative_name name

data/lib/card/name/fields_and_traits.rb

@@ -12,14 +12,9 @@ class Card
       end
 
       # @return [Card::Name]
-      def field_name tag_name
-        case tag_name
-        when Symbol
-          trait_name tag_name
-        else
-          tag_name = tag_name.to_s[1..-1] if tag_name.to_s[0] == "+"
-          [self, tag_name].to_name
-        end
+      def field_name tag
+        tag = tag.to_s[1..-1] if !tag.is_a?(Symbol) && tag.to_s[0] == "+"
+        [self, tag].to_name
       end
 
       # @return [True/False]
@@ -29,10 +24,12 @@ class Card
         if context.present?
           absolute_name(context).left_name.key == context.to_name.key
         else
-          s.match(/^\s*\+[^+]+$/).present?
+          s.match?(/^\s*\+[^+]+$/)
         end
       end
 
+      # name is relative name containing only the rightmost part
+      # @return [True/False]
       def field_only?
         relative? && stripped.to_name.parts.reject(&:blank?).first == parts.last
       end
@@ -40,27 +37,6 @@ class Card
       def relative_field_name tag_name
         field_name(tag_name).name_from self
       end
-
-      # @return [String]
-      def trait tag_code
-        name = trait_name tag_code
-        name.s
-      end
-
-      # @return [Card::Name]
-      def trait_name tag_code
-        Card::Name[self, tag_code.to_sym]
-      end
-
-      # @return [True/False]
-      def trait_name? *traitlist
-        return false unless compound?
-
-        right_key = right_name.key
-        traitlist.any? do |codename|
-          Card::Codename.name(codename)&.key == right_key
-        end
-      end
     end
   end
 end

data/lib/card/name/name_variants.rb

@@ -23,13 +23,17 @@ class Card
       end
 
       def card_id
-        Card.fetch_id self
+        Lexicon.id self
       end
 
       # @return [Symbol] codename of card with name
       def codename
         Codename[card_id]
       end
+
+      def codename_or_string
+        codename || s
+      end
     end
   end
 end

data/lib/card/name.rb

@@ -76,13 +76,5 @@ class Card
     def code
       Card::Codename[card_id]
     end
-
-    def setting?
-      Set::Type::Setting.member_names[key]
-    end
-
-    def set?
-      Set::Pattern.card_keys[tag_name.key]
-    end
   end
 end

data/lib/card/query/abstract_query/tie.rb

@@ -93,9 +93,8 @@ class Card
 
         def id_from_val val
           case val
-          when Integer then val
-          when String  then Card.fetch_id(val) || -999
-          when Symbol  then Card::Codename.id(val) || -999
+          when Integer         then val
+          when String, Symbol  then val.card_id || -999
           end
         end
       end

data/lib/card/query/card_query/normalization.rb

@@ -28,7 +28,7 @@ class Card
 
         def normalize_value val
           case val
-          when Integer, Float, Hash, Symbol, NilClass then val
+          when Integer, Float, Hash, Symbol, NilClass, ActiveRecord::Relation then val
           when String                                 then normalize_string_value val
           when Array                                  then normalize_array_value val
           else raise Error::BadQuery, "Invalid value type: #{val.class} (#{val.inspect})"

data/lib/card/query/sql_statement/order.rb

@@ -18,12 +18,15 @@ class Card
       module Order
         def order
           full_syntax do
-            "ORDER BY #{order_directives.join ', '}"
+            dirs = order_directives
+            "ORDER BY #{dirs.join ', '}" if dirs.present?
           end
         end
 
         def order_directives
-          Array.wrap(order_config).map do |order_key|
+          return if @mods[:sort].blank?
+
+          Array.wrap(@mods[:sort]).map do |order_key|
             order_directive order_key
           end
         end
@@ -58,10 +61,6 @@ class Card
             safe_sql @mods[:dir]
           end
         end
-
-        def order_config
-          @mods[:sort].blank? ? "update" : @mods[:sort]
-        end
       end
     end
   end

data/lib/card/query/value.rb

@@ -32,9 +32,10 @@ class Card
 
       def parse_value value
         case value
-        when Array           then parse_array_value value.clone
-        when nil             then ["is", nil]
-        else                      ["=", parse_simple_value(value)]
+        when Array                  then parse_array_value value.clone
+        when ActiveRecord::Relation then ["in", value]
+        when nil                    then ["is", nil]
+        else                             ["=", parse_simple_value(value)]
         end
       end
 
@@ -48,7 +49,8 @@ class Card
         when String, Integer then value
         when Symbol          then value.to_s
         when nil             then nil
-        else raise Error::BadQuery, "Invalid property value: #{value.inspect}"
+        else
+          raise Error::BadQuery, "Invalid property value: #{value.inspect}"
         end
       end
 
@@ -66,9 +68,10 @@ class Card
 
       def sqlize v
         case v
-        when Query then v.to_sql
-        when Array then sqlize_array v
-        when nil   then "NULL"
+        when Query                  then v.to_sql
+        when ActiveRecord::Relation then "(#{v.to_sql})"
+        when Array                  then sqlize_array v
+        when nil                    then "NULL"
         else quote(v.to_s)
         end
       end

data/lib/card/reference/all.rb

@@ -21,7 +21,7 @@ class Card
       end
 
       def referer_cards_from_references references
-        references.map(&:referer_id).uniq.map(&Card.method(:fetch)).compact
+        references.map(&:referer_id).uniq.map(&:card).compact
       end
 
       # cards that self refers to
@@ -62,11 +62,13 @@ class Card
         Reference.mass_insert reference_values_array(ref_hash)
       end
 
-      # delete references from this card
-      def delete_references_out
-        return unless id.present?
-
-        Reference.where(referer_id: id).delete_all
+      # replace references in card content
+      def swap_names old_name, new_name
+        cont = content_object
+        cont.find_chunks(:Reference).each do |chunk|
+          chunk.swap_name old_name, new_name
+        end
+        cont.to_s
       end
 
       private
@@ -122,7 +124,7 @@ class Card
       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,
+      # For example a link to virtual 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?

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