card 1.103.1 → 1.104.0

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

@@ -1,26 +1,26 @@
 class Card
   module Set
-    class Pattern
+    module Pattern
       # pattern-related Card instance methods
       module All
         def patterns?
           defined? @patterns
         end
 
-        def all_patterns
-          @all_patterns ||= set_patterns.map { |sub| sub.new self }.compact
+        def concrete_patterns
+          @concrete_patterns ||= Pattern.concrete.map { |sub| sub.new self }.compact
         end
 
         # new cards do not
         def patterns
-          @patterns ||= (new_card? ? all_patterns[1..-1] : all_patterns)
+          @patterns ||= (new_card? ? concrete_patterns[1..-1] : concrete_patterns)
         end
 
         def reset_patterns
           # Rails.logger.info "resetting patterns: #{name}"
-          @patterns = @all_patterns = nil
+          @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
@@ -30,13 +30,14 @@ class Card
         end
 
         def set_modules
-          @set_modules ||= all_patterns[0..-2].reverse.map(&:module_list).flatten.compact
+          @set_modules ||=
+            concrete_patterns[0..-2].reverse.map(&:module_list).flatten.compact
         end
 
         def set_format_modules klass
           @set_format_modules ||= {}
           @set_format_modules[klass] =
-            all_patterns[0..-2].reverse.map do |pattern|
+            concrete_patterns[0..-2].reverse.map do |pattern|
               pattern.format_module_list klass
             end.flatten.compact
         end
@@ -50,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
-            Card.set_patterns.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,43 +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
-        def reset
-          nonbase_loadables.each do |set_pattern|
-            Card::Set.const_remove_if_defined set_pattern.to_s.split("::").last
-          end
-          Card.set_patterns = []
-          @card_keys = nil
+        # 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
 
-        def loadables
-          Card.set_patterns.push(Card::Set::Abstract).reverse
+        # Pattern classes that can be reloaded without reloading Card
+        # (everything but all)
+        # @return [Array <Class>]
+        def reloadables
+          concrete - [Set::All] + Abstract
         end
 
-        def nonbase_loadables
-          l = loadables
-          l.delete Card::Set::All
-          l
+        # 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 = @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
-          Card.set_patterns.find { |sub| sub.pattern_code == pattern_code }
+          concrete.find { |sub| sub.pattern_code == pattern_code }
         end
 
-        def card_keys
-          @card_keys ||=
-            Card.set_patterns.each_with_object({}) do |set_pattern, hash|
-              card_key = Card.quick_fetch(set_pattern.pattern_code).key
-              hash[card_key] = true
-            end
+        # list of codenames of pattern cards
+        # @return [Array <Symbol>]
+        def codes
+          @codes ||= concrete.map(&:pattern_code).to_set
         end
 
-        def nonbase_codes
-          codes.tap { |list| list.delete :all }
+        # 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
 
-        def codes
-          Card.set_patterns.map(&:pattern_code).push(:abstract).reverse
+        # list of ids of pattern cards
+        # @return [Array <Integer>]
+        def ids
+          @ids ||= concrete.map(&:pattern_id)
+        end
+
+        private
+
+        def nonbase_codes
+          @nonbase_codes ||= codes.to_a - [:all]
         end
       end
     end

data/lib/card/set/registrar.rb

@@ -48,6 +48,14 @@ class Card
         base_modules.clear
       end
 
+      def finalize_load
+        # basket.freeze
+        # basket.each_value(&:freeze)
+        clean_empty_modules
+      end
+
+      private
+
       def clean_empty_modules
         clean_empty_module_from_hash modules[:nonbase]
         modules[:nonbase_format].each_value do |hash|
@@ -62,8 +70,6 @@ class Card
         end
       end
 
-      private
-
       # makes sets ready for dynamic loading via #include_set_modules
       def register_set_of_type set_module, set_type
         mods = modules[set_type]

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

@@ -48,7 +48,6 @@ class Card
   module Set
     include Event::Api
     include Trait
-    include Basket
     include Inheritance
 
     include Format
@@ -58,15 +57,23 @@ class Card
     extend I18nScope
     extend Registrar
 
-    mattr_accessor :modules, :traits
+    class << self
+      attr_accessor :modules, :traits, :basket
 
-    def self.reset_modules
-      self.modules = { base: [], base_format: {},
-                       nonbase: {}, nonbase_format: {},
-                       abstract: {}, abstract_format: {} }
+      def reset
+        self.modules = {
+          base: [],     base_format: {},
+          nonbase: {},  nonbase_format: {},
+          abstract: {}, abstract_format: {}
+        }
+
+        self.basket = {}
+      end
     end
 
-    reset_modules
+    delegate :basket, to: Set
+
+    reset
 
     # SET MODULE API
     #

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

data/lib/card/view/classy.rb

@@ -24,9 +24,7 @@ class Card
       #    :single_use  the same as :nests but is removed after the first use
       #    :global      always everywhere
       def class_up klass, classier, scope=:subviews
-        klass = klass.to_s
-
-        storage_voo(scope).add_extra_classes klass, classier, scope
+        storage_voo(scope).add_extra_classes klass.to_s, classier, scope
       end
 
       def class_down klass, classier
@@ -55,10 +53,8 @@ class Card
       end
 
       def add_extra_classes key, classier, scope
-        type = class_list_type scope
-
-        class_list(type)[key] =
-          [class_list(type)[key], classier].flatten.compact.join(" ")
+        list = class_list class_list_type(scope)
+        list[key] = [list[key], classier].flatten.compact.join " "
       end
 
       # remove classes everywhere where they are visible for the given scope
@@ -83,9 +79,7 @@ class Card
 
       def extra_classes klass
         klass = klass.first if klass.is_a?(Array)
-        klass = klass.to_s
-
-        deep_extra_classes klass, :self
+        deep_extra_classes klass.to_s, :self
       end
 
       # recurse through voos and formats to find all extra classes
@@ -135,33 +129,27 @@ class Card
       end
 
       def class_list type=:private
-        case type
-        when :private, :format_private, :public, :single_use
-          @class_list ||= {}
-          @class_list[type] ||= {}
-        else
+        unless type.in? %i[private format_private public single_use]
           raise ArgumentError, "#{type} not a valid class list"
         end
+        @class_list ||= {}
+        @class_list[type] ||= {}
       end
 
+      CLASS_LIST_TYPE = { view: :private,
+                          format: :format_private,
+                          subviews: :format_private,
+                          nests: :public,
+                          global: :public,
+                          single_use: :single_use }.freeze
+
       # Translates scopes to the privacy types used to manage the class lists.
       # A #classy calls looks in the following class_lists:
       #    private - only in the same voo
       #    format_private - the same voo and all parent voos in the same format
       #    public - in all voos in all parent formats
       def class_list_type scope
-        case scope
-        when :view
-          :private
-        when :format, :subviews
-          :format_private
-        when :nests, :global
-          :public
-        when :single_use
-          :single_use
-        else
-          raise ArgumentError, "invalid class_up scope: #{scope}"
-        end
+        CLASS_LIST_TYPE[scope] || raise(ArgumentError, "invalid class_up scope: #{scope}")
       end
     end
   end

data/lib/card/view/options/voo_api.rb

@@ -49,7 +49,9 @@ class Card
         # because they can get changed after.  current solution is a compromise.
         # @return [Hash]
         def slot_options
-          normalized_options.merge(view: requested_view).slice(*Options.slot_keys)
+          normalized_options.merge(view: requested_view)
+                            .merge(normalized_visibility_options)
+                            .slice(*Options.slot_keys)
         end
 
         # ACCESSOR_HELPERS

data/lib/card/view/options.rb

@@ -40,6 +40,7 @@ class Card
         heir: [
           :main,           # format object is page's "main" object (Boolean)
           :home_view,      # view for slot to return to when no view specified
+          :buttons_view,
           :edit_structure, # use a different structure for editing (Array)
           :cql,            # contextual cql alterations for search cards (Hash)
           :action_id,      # a Card::Action id (Integer)
@@ -50,20 +51,21 @@ class Card
           :help,           # cue text when editing
           :structure,      # overrides the content of the card
           :title,          # overrides the name of the card
-          :variant,        # override the canonical version of the name with a different
-          # variant
+          :variant,        # override the standard name with a different variant
           :input_type,     # inline_nests makes a form within standard content (Symbol)
           :type,           # set the default type of new cards
           :size,           # set an image size
-          # (also used for character limit in one_line_content)
-          :params,         # parameters for add button.  deprecated!
+          #                    (also used for character limit in one_line_content)
           :items,          # options for items (Hash)
           :cache,          # change view cache behaviour
           #                    (Symbol<:always, :standard, :never>)
           :edit,           # edit mode
           #                    (Symbol<:inline, :standard, :full>)
           :separator,      # item separator in certain lists
-          :filter
+          :filter,
+
+          # DEPRECATED
+          :params          # parameters for add button
         ],
         none: [
           :skip_perms,     # do not check permissions for this view (Boolean)

data/lib/card/view.rb

@@ -27,6 +27,7 @@ class Card
     extend View::Cache::ClassMethods
 
     attr_reader :format, :parent, :card
+    attr_accessor :interior
 
     class << self
       # @return [Symbol] viewname as Symbol