card 1.101.0 → 1.101.5

data/lib/card/set/loader.rb

@@ -24,9 +24,7 @@ class Card
           modules[:base] << set_module
         else
           set_type = set_module.abstract_set? ? :abstract : :nonbase
-          # made ready for dynamic loading via #include_set_modules
-          modules[set_type][set_module.shortname] ||= []
-          modules[set_type][set_module.shortname] << set_module
+          register_set_of_type set_module, set_type
         end
       end
 
@@ -35,8 +33,6 @@ class Card
       #  tmp files that add module names (Card::Set::PATTERN::ANCHOR) and
       #  extend the module with Card::Set.
 
-      #
-
       # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # Organization Phase
 
@@ -44,19 +40,17 @@ class Card
       # Format class
       # 'nonbase modules' are included dynamically on singleton_classes
       def process_base_modules
-        return unless modules[:base].present?
+        base_modules = modules[:base]
+        return unless base_modules.present?
 
-        Card.add_set_modules modules[:base]
-        modules[:base_format].each do |format_class, modules_list|
-          format_class.add_set_modules modules_list
-        end
-        modules[:base].clear
-        modules[:base_format].clear
+        Card.add_set_modules base_modules
+        process_base_format_modules modules[:base_format]
+        base_modules.clear
       end
 
       def clean_empty_modules
         clean_empty_module_from_hash modules[:nonbase]
-        modules[:nonbase_format].values.each do |hash|
+        modules[:nonbase_format].each_value do |hash|
           clean_empty_module_from_hash hash
         end
       end
@@ -67,6 +61,23 @@ class Card
           hash.delete mod_name if modlist.empty?
         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]
+        key = set_module.shortname
+        mods[key] ||= []
+        mods[key] << set_module
+      end
+
+      def process_base_format_modules base_format_modules
+        base_format_modules.each do |format_class, modules_list|
+          format_class.add_set_modules modules_list
+        end
+        base_format_modules.clear
+      end
     end
   end
 end

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

@@ -0,0 +1,63 @@
+class Card
+  module Set
+    class 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
+        end
+
+        # new cards do not
+        def patterns
+          @patterns ||= (new_card? ? all_patterns[1..-1] : all_patterns)
+        end
+
+        def reset_patterns
+          # Rails.logger.info "resetting patterns: #{name}"
+          @patterns = @all_patterns = nil
+          @template = @virtual = nil
+          @set_mods_loaded = @set_modules = @set_names = @rule_set_keys = nil
+          @junction_only = nil # only applies to set cards
+          true
+        end
+
+        def safe_set_keys
+          patterns.map(&:safe_key).reverse * " "
+        end
+
+        def set_modules
+          @set_modules ||= all_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|
+              pattern.format_module_list klass
+            end.flatten.compact
+        end
+
+        def set_names
+          @set_names = patterns.map(&:to_s) if @set_names.nil?
+          @set_names
+        end
+
+        def in_set? set_module
+          patterns.map(&:module_key).include? set_module.shortname
+        end
+
+        def rule_set_keys
+          @rule_set_keys ||= patterns.map(&:rule_set_key).compact
+        end
+
+        def include_module? set
+          singleton_class&.include? set
+        end
+      end
+    end
+  end
+end

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

@@ -3,63 +3,11 @@ class Card
     class Pattern
       # class from which set patterns inherit
       class Base
-        class << self
-          attr_accessor :pattern_code, :pattern_id, :junction_only,
-                        :assigns_type, :anchorless
-          attr_writer :anchor_parts_count
-
-          def new card
-            super if pattern_applies? 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
-          end
-
-          def junction_only?
-            junction_only == true
-          end
-
-          def anchorless?
-            anchorless
-          end
-
-          def pattern
-            Card.fetch(pattern_id, skip_modules: true).name
-          end
-
-          def pattern_applies? card
-            junction_only? ? card.name.junction? : true
-          end
-
-          def anchor_parts_count
-            @anchor_parts_count ||= (anchorless? ? 0 : 1)
-          end
-
-          def module_key anchor_codes
-            return pattern_code.to_s.camelize if anchorless?
-            return unless anchor_codes # is this not an error?
-
-            ([pattern_code] + anchor_codes).map { |code| code.to_s.camelize }.join "::"
-          end
-
-          # label for set pattern if no anchor is given
-          def generic_label
-            label nil
-          end
-        end
-
-        # Instance methods
+        extend ClassMethods
 
         def initialize card
           return if self.class.anchorless?
+
           @anchor_name = self.class.anchor_name(card).to_name
           @anchor_id = find_anchor_id card
         end
@@ -70,6 +18,7 @@ class Card
 
         def module_key
           return @module_key if defined? @module_key
+
           @module_key = self.class.module_key anchor_codenames
         end
 
@@ -88,8 +37,7 @@ class Card
 
         def anchor_codenames
           anchor_parts.map do |part|
-            part_id = Card.fetch_id part
-            Card::Codename[part_id] || break
+            part.cardname&.code || break
           end
         end
 
@@ -134,24 +82,6 @@ class Card
           end
         end
       end
-
-      module Helper
-        private
-
-        def left_type card
-          card.superleft&.type_name || quick_type(card.name.left_name)
-        end
-
-        def quick_type name
-          if name.present?
-            card = Card.fetch name, skip_modules: true, new: {}
-            card.include_set_modules if card.new? && name.to_name.junction?
-            card&.type_name
-          else
-            "RichText"
-          end
-        end
-      end
     end
   end
 end

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

@@ -0,0 +1,75 @@
+class Card
+  module Set
+    class Pattern
+      # methods for Set::Pattern classes
+      module ClassMethods
+        attr_accessor :pattern_code, :pattern_id, :junction_only,
+                      :assigns_type, :anchorless
+        attr_writer :anchor_parts_count
+
+        def new card
+          super if pattern_applies? 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
+        end
+
+        def junction_only?
+          junction_only == true
+        end
+
+        def anchorless?
+          anchorless
+        end
+
+        def pattern
+          Card.fetch(pattern_id, skip_modules: true).name
+        end
+
+        def pattern_applies? card
+          junction_only? ? card.name.compound? : true
+        end
+
+        def anchor_parts_count
+          @anchor_parts_count ||= (anchorless? ? 0 : 1)
+        end
+
+        def module_key anchor_codes
+          return pattern_code.to_s.camelize if anchorless?
+          return unless anchor_codes # is this not an error?
+
+          ([pattern_code] + anchor_codes).map { |code| code.to_s.camelize }.join "::"
+        end
+
+        # label for set pattern if no anchor is given
+        def generic_label
+          label nil
+        end
+
+        private
+
+        def left_type card
+          card.superleft&.type_name || quick_type(card.name.left_name)
+        end
+
+        def quick_type name
+          if name.present?
+            card = Card.fetch name, skip_modules: true, new: {}
+            card.include_set_modules if card.new? && name.to_name.compound?
+            card&.type_name
+          else
+            "RichText"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/set/required_field.rb

@@ -29,6 +29,7 @@ class Card
 
       def define_field_test
         return unless (test = event_test)
+
         method_name = field_test_name
         field_set.class_exec do
           define_method method_name do
@@ -39,13 +40,15 @@ class Card
 
       def field_test_name
         return unless event_test
+
         "_when_left_#{event_test}".to_sym
       end
 
       def event_test
         return @event_test unless @event_test.nil?
+
         test = options[:when]
-        @event_test = test&.is_a?(Symbol) ? test : false
+        @event_test = test.is_a?(Symbol) ? test : false
       end
 
       def field_set

data/lib/card/set/trait.rb

@@ -28,7 +28,7 @@ class Card
 
       def add_attributes *args
         Card.set_specific_attributes ||= []
-        Card.set_specific_attributes += args.map(&:to_s)
+        Card.set_specific_attributes += args.map(&:to_sym)
         Card.set_specific_attributes.uniq!
       end
 
@@ -37,14 +37,11 @@ class Card
         Card::Set.traits[mod] || Card::Set.traits[mod] = {}
       end
 
-      def add_traits args, options
-        mod = self
-        mod_traits = get_traits mod
+      def add_traits traits, options
+        mod_traits = get_traits self
+        new_opts = new_trait_opts options
 
-        new_opts = options[:type] ? { type: options[:type] } : {}
-        new_opts[:default_content] = options[:default] if options[:default]
-
-        args.each do |trait|
+        traits.each do |trait|
           define_trait_card trait, new_opts
           define_trait_reader trait if options[:reader]
           define_trait_writer trait if options[:writer]
@@ -53,6 +50,12 @@ class Card
         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]
+        end
+      end
+
       def define_trait_card trait, opts
         define_method "#{trait}_card" do
           fetch trait.to_sym, new: opts.clone, eager_cache: true

data/lib/card/setting.rb

@@ -9,8 +9,9 @@ class Card
     #     O = Card['*create']         (object)
     # accessible in E
     attr_accessor :codename
+
     # accessible in E and M
-    mattr_accessor :groups, :group_names, :preferences
+    mattr_accessor :groups, :preferences
 
     SETTING_OPTIONS = %i[
       restricted_to_type
@@ -41,17 +42,15 @@ class Card
       end
     end
 
-    self.group_names = {
-      templating: "Templating",
-      permission: "Permissions",
-      webpage:    "Webpage",
-      editing:    "Editing",
-      event:      "Events",
-      other:      "Other",
-      config:     "Config"
-    }
-
-    self.groups = group_names.keys.each_with_object({}) do |key, groups|
+    self.groups = %i[
+      templating
+      permission
+      webpage
+      editing
+      event
+      other
+      config
+    ].each_with_object({}) do |key, groups|
       groups[key] = []
     end
 
@@ -80,6 +79,7 @@ class Card
 
     def applies_to_prototype? prototype
       return true unless applies
+
       applies.call(prototype)
     end
 
@@ -116,6 +116,7 @@ class Card
 
     def permitted_type_ids types
       return unless types
+
       type_ids = Array.wrap(types).flatten.map do |cardtype|
         Card::Codename.id cardtype
       end

data/lib/card/subcards.rb

@@ -16,6 +16,7 @@ class Card
     include Relate
 
     attr_accessor :context_card, :keys
+
     def initialize context_card
       @context_card = context_card
       @keys = ::Set.new
@@ -73,10 +74,8 @@ class Card
       end.compact
     end
 
-    def each_card
-      cards.each do |card|
-        yield card
-      end
+    def each_card &block
+      cards.each(&block)
     end
 
     alias_method :each, :each_card