card 1.103.2 → 1.104.1

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

@@ -6,24 +6,26 @@ class Card
         # NOTE: for all these helpers, method returns *all* fields/children/descendants.
         # (Not just those current user has permission to read.)
 
-        def fields
-          field_ids.map { |id| Card[id] }
+        def field_cards
+          field_ids.map(&:card)
         end
 
         def field_names
-          field_ids.map { |id| Card::Name[id] }
+          field_ids.map(&:cardname)
         end
 
         def field_ids
           child_ids :left
         end
 
-        def each_child &block
+        def each_child
           return unless id
 
-          Card.where(
-            "(left_id = #{id} or right_id = #{id}) and trash is false"
-          ).each(&block)
+          sql = "(left_id = #{id} or right_id = #{id}) and trash is false"
+          Card.where(sql).find_each do |card|
+            card.include_set_modules
+            yield card
+          end
         end
 
         # eg, A+B is a child of A and B

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

@@ -58,7 +58,7 @@ class Card
         # after_store forces it to save the subcard first
         # and callback afterwards
         def with_id_after_store subcard
-          add_subcard subcard
+          subcard subcard
           subcard.director.after_store { |card| yield card.id }
         end
       end

data/lib/card/name/all.rb

@@ -7,7 +7,7 @@ class Card
 
       # TODO: use delegations and include more name functions
       delegate :simple?, :compound?, :junction?, to: :name
-
+      attr_reader :supercard
       def name
         @name ||= left_id ? Lexicon.lex_to_name([left_id, right_id]) : super.to_name
       end
@@ -47,8 +47,9 @@ class Card
         end
       end
 
-      def update_superleft cardname
-        @superleft = @supercard if cardname.field_of? @supercard.name
+      def update_superleft newname=nil
+        newname ||= name
+        @superleft = @supercard if newname.field_of? @supercard.name
       end
 
       def update_subcard_names new_name, name_to_replace=nil

data/lib/card/name/card_class.rb

@@ -3,10 +3,11 @@ class Card
     # Name-related Card class methods
     module CardClass
       def rename! oldname, newname
-        Card[oldname].update! name: newname, update_referers: true
+        Card[oldname].update! name: newname
       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

@@ -19,7 +19,7 @@ class Card
         case cardish
         when Card             then cardish.name
         when Symbol, Integer  then Card.fetch_name(cardish)
-        when Array            then smart_compose cardish
+        when Array            then compose cardish
         when String, NilClass then new cardish
         else
           raise ArgumentError, "#{cardish.class} not supported as name identifier"
@@ -40,7 +40,7 @@ class Card
         str = str.to_s
 
         if !validated_parts && str.include?(joint)
-          compose Cardname.split_parts(str)
+          string_compose Cardname.split_parts(str)
         elsif (id = Card.id_from_string str)  # handles ~[id] and :[codename]
           Card.name_from_id_from_string id, str
         else
@@ -49,16 +49,16 @@ class Card
       end
 
       # interprets symbols/integers as codenames/ids
-      def smart_compose parts
+      def compose parts
         new_from_parts(parts) { |part| self[part] }
       end
 
-      def compose parts
+      private
+
+      def string_compose parts
         new_from_parts(parts) { |part| new part }
       end
 
-      private
-
       def new_from_parts parts, &block
         name_parts = parts.flatten.map(&block)
         new name_parts.join(joint), true
@@ -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/card_methods.rb

@@ -0,0 +1,13 @@
+class Card
+  module Set
+    # Set-related methods included in card class
+    # (note: Card::Set::All would follow our naming convention but is in use by the
+    # "all" set)
+    module CardMethods
+      include Event::All
+      include Pattern::All
+
+      delegate :basket, to: Set
+    end
+  end
+end

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/skip_and_trigger.rb

@@ -34,6 +34,14 @@ class Card
           @trigger_hash ||= hash_with_value trigger, true
         end
 
+        def skip_event? event
+          full_skip_hash.key? event.to_s
+        end
+
+        def trigger_event? event
+          full_trigger_hash.key? event.to_s
+        end
+
         private
 
         # "applies always means event can run

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/format/abstract_format/wrapper.rb

@@ -75,7 +75,7 @@ class Card
           def define_wrap_with_method wrapper_name, wrapper_method_name
             class_exec(self) do |_format|
               define_method "wrap_with_#{wrapper_name}" do |*args, &interior|
-                @interior, opts = interior ? [interior.call, args.first] : args
+                voo.interior, opts = interior ? [interior.call, args.first] : args
                 send_wrapper_method wrapper_method_name, opts
               end
             end

data/lib/card/set/format/abstract_format.rb

@@ -7,12 +7,13 @@ class Card
       # Whenever you create a format block in a set module in a {Cardio::Mod mod}, you
       # create a format module that is extended with AbstractFormat.
       module AbstractFormat
-        include Set::Basket
         include ViewOpts
         include ViewDefinition
         include HamlViews
         include Wrapper
 
+        delegate :basket, to: Set
+
         # _Views_ are the primary way that both sharks and monkeys interact with cards.
         # Sharks select views to use in _nests_.  Monkeys can define and tweak those
         # views. These docs will introduce the basics of view definition.

data/lib/card/set/format.rb

@@ -114,13 +114,12 @@ class Card
 
       # make mod ready to include in base (non-set-specific) format classes
       def register_all_set_format format_class, mod
-        add_to_array_val modules[:base_format], format_class, mod
+        add_to_array_val Set.modules[:base_format], format_class, mod
       end
 
       def register_standard_set_format format_class, mod
-        format_type = abstract_set? ? :abstract_format : :nonbase_format
         # ready to include dynamically in set members' format singletons
-        format_hash = modules[format_type][format_class] ||= {}
+        format_hash = Set.modules[set_format_type_key][format_class] ||= {}
         add_to_array_val format_hash, shortname, mod
       end
 

data/lib/card/set/helpers.rb

@@ -19,6 +19,20 @@ class Card
         Pattern.find(pattern_code).anchor_parts_count
       end
 
+      def set_format_type_key
+        @set_format_type_key ||= :"#{set_type_key}_format"
+      end
+
+      def set_type_key
+        if all_set?
+          :base
+        elsif abstract_set?
+          :abstract
+        else
+          :nonbase
+        end
+      end
+
       def set_name_parts
         @set_name_parts ||= name.split "::"
       end
@@ -39,6 +53,60 @@ class Card
       def respond_to_missing? method_name, _include_private=false
         method_name.match? SET_PATTERN_TEST_REGEXP
       end
+
+      def modules
+        if all_set?
+          [self]
+        elsif abstract_set?
+          [test_set]
+        else
+          Set.modules[:nonbase][shortname] || []
+        end
+      end
+
+      def test_set
+        # rubocop:disable Lint/Eval
+        ::Card::Set::Self.const_remove_if_defined :TestSet
+        eval <<-RUBY, binding, __FILE__, __LINE__ + 1
+          class ::Card::Set::Self
+            module TestSet
+              extend Card::Set
+              include_set #{name}
+            end
+          end
+        RUBY
+        ::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/inheritance.rb

@@ -74,7 +74,7 @@ class Card
       def each_format_with_mods set
         set_type = set.abstract_set? ? :abstract : :nonbase
         format_type = "#{set_type}_format".to_sym
-        modules[format_type].each_pair { |*args| yield(*args) }
+        Set.modules[format_type].each_pair { |*args| yield(*args) }
       end
 
       def applicable_format? format, except, only