card 1.99.1 → 1.99.2

data/lib/card/mod/loader/set_loader.rb

@@ -6,6 +6,12 @@ class Card
       # SetLoader can use three different strategies to load the set modules.
       class SetLoader < Loader
         @module_type = :set
+        attr_accessor :patterns
+
+        def initialize args={}
+          @patterns = args.delete(:patterns) || Card::Set::Pattern.loadable_codes
+          super
+        end
 
         def load_strategy_class load_strategy
           case load_strategy
@@ -20,7 +26,7 @@ class Card
 
         def load
           super
-          Card::Set.process_base_modules
+          # Card::Set.process_base_modules
           Card::Set.clean_empty_modules
         end
 

data/lib/card/mod/loader/set_pattern_loader.rb

@@ -18,7 +18,7 @@ class Card
             return Object if simple_load?
 
             Card::Set.const_get_or_set(@pattern.camelize) do
-              Class.new(Card::Set::Pattern::Abstract)
+              Class.new(Card::Set::Pattern::Base)
             end
           end
 
@@ -34,7 +34,7 @@ class Card
           end
 
           def module_chain
-            "class Card::Set::#{@pattern.camelize} < Card::Set::Pattern::Abstract"
+            "class Card::Set::#{@pattern.camelize} < Card::Set::Pattern::Base"
           end
 
           def preamble_bits

data/lib/card/mod/module_template.rb

@@ -21,11 +21,7 @@ class Card
 
       # @return [String] the ruby code to build the modal
       def to_s
-        if simple_load?
-          @content
-        else
-          processed_content
-        end
+        simple_load? ? @content : processed_content
       end
 
       def processed_content

data/lib/card/mod_inflector.rb

@@ -0,0 +1,16 @@
+class ModInflector < Zeitwerk::Inflector
+  def camelize basename, abspath
+    ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector.camelize(basename, abspath)
+
+    # if basename =~ /\Ahtml_(.*)/
+    #   ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector.camelize(basename, abspath)
+    #   # "HTML" + super($1, abspath)
+    # else
+    #   super
+    # end
+  end
+
+  def inflect overrides
+    ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector.inflect(overrides)
+  end
+end

data/lib/card/model/save_helper.rb

@@ -199,7 +199,7 @@ class Card
 
       def validate_setting setting
         unless Card::Codename.exist?(setting) &&
-               Card.fetch_type_id(setting) == SettingID
+               Card.fetch_type_id(setting) == Card::SettingID
           raise ArgumentError, "not a valid setting: #{setting}"
         end
       end
@@ -207,7 +207,7 @@ class Card
       def normalize_trait_rule_args setting, value
         return value if value.is_a? Hash
 
-        if Card.fetch_type_id([setting, :right, :default]) == PointerID
+        if Card.fetch_type_id([setting, :right, :default]) == Card::PointerID
           value = Array(value).to_pointer_content
         end
         { content: value }

data/lib/card/name.rb

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-require_dependency "card/env"
+# require "card/env"
 
 require "cardname"
 
@@ -11,7 +11,7 @@ class Card
   # Card::Name adds support for deeper card integration
   class Name < Cardname
     include FieldsAndTraits
-    include ::Card::Name::NameVariants
+    include NameVariants
 
     self.params  = Card::Env # yuck!
     self.session = proc { Card::Auth.current.name } # also_yuck

data/lib/card/name/name_variants.rb

@@ -12,6 +12,25 @@ class Card
           @@variant_methods.include?(variant) ? name.send(variant) : name
         end
       end
+
+      # @return [Card::Name] standardized based on card names
+      def standard
+        self.class.compose(parts.map { |part| Card.fetch_name(part) || part })
+      end
+
+      def card
+        Card.fetch self
+      end
+
+      # @return [Integer] id of card with name
+      def card_id
+        Card.fetch_id self
+      end
+
+      # @return [Symbol] codename of card with name
+      def codename
+        Codename[card_id]
+      end
     end
   end
 end

data/lib/card/query.rb

@@ -34,8 +34,10 @@ class Card
   # Each condition is either a SQL-ready string (boo) or an Array in this form:
   #    [ field_string_or_sym, Card::Value::Query object ]
   module Query
-    require_dependency "card/query/card_query"
-
+    require "card/query/clause"
+    require "card/query/card_query"
+    require "card/query/sql_statement"
+    # Card::Query::CardQuery
     # After conversion, ATTRIBUTES is a Hash where the key is the attribute
     # and the value is the attribute type:
     # { id: :basic, name: :basic, key: :basic ...}

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

@@ -33,11 +33,11 @@ class Card
         # DEPRECATE?
 
         def member_of val
-          interpret right_plus: [RolesID, refer_to: val]
+          interpret right_plus: [Card::RolesID, refer_to: val]
         end
 
         def member val
-          interpret referred_to_by: { left: val, right: RolesID }
+          interpret referred_to_by: { left: val, right: Card::RolesID }
         end
       end
     end

data/lib/card/query/sql_statement.rb

@@ -11,6 +11,10 @@ class Card
     # hierarchy and do little more than run "to_sql" on its parts, and in so doing
     # construct a valid SQL statement.
     class SqlStatement
+      require "card/query/sql_statement/joins"
+      require "card/query/sql_statement/where"
+      require "card/query/sql_statement/order"
+
       include Joins
       include Where
       include Order

data/lib/card/set.rb

@@ -46,12 +46,22 @@ class Card
   #        b) Card::Set to provide API for the most common set methods.
   #
   module Set
+    require "card/set/event"
+    require "card/set/trait"
+    require "card/set/basket"
+    require "card/set/inheritance"
+    require "card/set/format"
+    require "card/set/advanced_api"
+    require "card/set/helpers"
+    require "card/set/i18n_scope"
+    require "card/set/loader"
+
     include Event::Api
     include Trait
     include Basket
     include Inheritance
 
-    include Set::Format
+    include Format
     include AdvancedApi
     include Helpers
 
@@ -59,8 +69,13 @@ class Card
     extend Loader
 
     mattr_accessor :modules, :traits
-    self.modules = { base: [], base_format: {}, nonbase: {}, nonbase_format: {},
-                     abstract: {}, abstract_format: {} }
+
+    def self.reset_modules
+      self.modules = { base: [], base_format: {}, nonbase: {}, nonbase_format: {},
+                       abstract: {}, abstract_format: {} }
+    end
+
+    reset_modules
 
     # SET MODULE API
     #

data/lib/card/set/abstract.rb

@@ -0,0 +1,6 @@
+class Card
+  module Set
+    class Abstract < Pattern::Base
+    end
+  end
+end

data/lib/card/set/event.rb

@@ -96,10 +96,10 @@ class Card
       end
 
       def define_standard_event_method method_name=simple_method_name
-        stage = @stage
+        is_integration = @stage.to_s.match?(/integrate/)
         @set_module.class_exec(@event) do |event_name|
           define_method event_name do
-            rescuing_integration stage do
+            rescuing_if_integration is_integration do
               log_event_call event_name
               run_callbacks event_name do
                 send method_name
@@ -111,15 +111,17 @@ class Card
     end
   end
 
-  def rescuing_integration stage
-    return yield unless stage.to_s.match?(/integrate/)
-    begin
-      yield
-    rescue StandardError => e # one failed integration event should not harm others.
-      Card::Error.report e, self
-    ensure
-      true
-    end
+  def rescuing_if_integration is_integration
+    is_integration ? rescuing_integration { yield } : yield
+  end
+
+  # one failed integration event should not harm others.
+  def rescuing_integration
+    yield
+  rescue StandardError => e
+    Card::Error.report e, self
+  ensure
+    true
   end
 
   def log_event_call event

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

@@ -1,3 +1,5 @@
+require "application_job"
+
 class Card
   module Set
     class Event

data/lib/card/set/format.rb

@@ -58,8 +58,8 @@ class Card
     # {AbstractFormat#before before}) are defined in {AbstractFormat}. These methods are
     # always available in format blocks.
     module Format
-      require_dependency "card/set/format/haml_paths"
-      require_dependency "card/set/format/abstract_format"
+      require "card/set/format/haml_paths"
+      require "card/set/format/abstract_format"
 
       # define format behavior within a set module
       def format *format_names, &block
@@ -98,7 +98,7 @@ class Card
           # yielding set format module, eg Card::Set::Type::Pointer::HtmlFormat
           m = Module.new
           register_set_format Card::Format.class_from_name(klass), m
-          m.extend Card::Set::AbstractFormat
+          m.extend Card::Set::Format::AbstractFormat
           m
         end
         mod.class_eval(&block)

data/lib/card/set/helpers.rb

@@ -1,31 +1,43 @@
 class Card
   module Set
     module Helpers
+      SET_PATTERN_TEST_REGEXP = /^(?<pattern>\w+)_set\?$/
+
       def shortname
-        parts = name.split "::"
         first = 2 # shortname eliminates Card::Set
-        pattern_code = parts[first].underscore.to_sym
         last = first + num_set_parts(pattern_code)
-        parts[first..last].join "::"
+        set_name_parts[first..last].join "::"
       end
 
       def underscore
         shortname.tr(":", "_").underscore
       end
 
-      # move to Set::Pattern?
       def num_set_parts pattern_code
         return 1 if pattern_code == :abstract
 
         Pattern.find(pattern_code).anchor_parts_count
       end
 
-      def abstract_set?
-        name =~ /^Card::Set::Abstract::/
+      def set_name_parts
+        @set_name_parts ||= name.split "::"
+      end
+
+      def pattern_code
+        @pattern_code ||= set_name_parts[2].underscore.to_sym
+      end
+
+      # handles all_set?, abstract_set?, type_set?, etc.
+      def method_missing method_name, *args
+        if (matches = method_name.match SET_PATTERN_TEST_REGEXP)
+          pattern_code == matches[:pattern].to_sym
+        else
+          super
+        end
       end
 
-      def all_set?
-        name =~ /^Card::Set::All::/
+      def respond_to_missing? method_name, _include_private=false
+        method_name.match? SET_PATTERN_TEST_REGEXP
       end
     end
   end

data/lib/card/set/loader.rb

@@ -40,7 +40,7 @@ class Card
       # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # Organization Phase
 
-      # 'base modules' are modules that are permanently included on the Card or
+      # 'base modules' are modules that are always included on the Card or
       # Format class
       # 'nonbase modules' are included dynamically on singleton_classes
       def process_base_modules

data/lib/card/set/pattern.rb

@@ -0,0 +1,47 @@
+class Card
+  module Set
+    class 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
+        end
+
+        def loadables
+          Card.set_patterns.push(Card::Set::Abstract).reverse
+        end
+
+        def nonbase_loadables
+          l = loadables
+          l.delete Card::Set::All
+          l
+        end
+
+        def find pattern_code
+          Card.set_patterns.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
+        end
+
+        def nonbase_loadable_codes
+          l = loadable_codes
+          l.delete :all
+          l
+        end
+
+        def loadable_codes
+          Card.set_patterns.map(&:pattern_code).push(:abstract).reverse
+        end
+      end
+    end
+  end
+end

data/lib/card/{set_pattern.rb → set/pattern/base.rb}

@@ -1,31 +1,8 @@
 class Card
   module Set
     class Pattern
-      class << self
-        def reset
-          Card.set_patterns = []
-          @card_keys = @in_load_order = nil
-        end
-
-        def find pattern_code
-          Card.set_patterns.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
-        end
-
-        def in_load_order
-          @in_load_order ||=
-            Card.set_patterns.reverse.map(&:pattern_code).unshift :abstract
-        end
-      end
-
-      class Abstract
+      # class from which set patterns inherit
+      class Base
         class << self
           attr_accessor :pattern_code, :pattern_id, :junction_only,
                         :assigns_type, :anchorless
@@ -51,7 +28,7 @@ class Card
           end
 
           def anchorless?
-            !!anchorless
+            anchorless
           end
 
           def pattern
@@ -82,27 +59,18 @@ class Card
         # Instance methods
 
         def initialize card
-          unless self.class.anchorless?
-            @anchor_name = self.class.anchor_name(card).to_name
-            @anchor_id = find_anchor_id card
-          end
-          self
+          return if self.class.anchorless?
+          @anchor_name = self.class.anchor_name(card).to_name
+          @anchor_id = find_anchor_id card
         end
 
         def find_anchor_id card
-          if self.class.respond_to? :anchor_id
-            self.class.anchor_id card
-          else
-            Card.fetch_id @anchor_name
-          end
+          self.class.try(:anchor_id, card) || Card.fetch_id(@anchor_name)
         end
 
         def module_key
-          if defined? @module_key
-            @module_key
-          else
-            @module_key = self.class.module_key(anchor_codenames)
-          end
+          return @module_key if defined? @module_key
+          @module_key = self.class.module_key anchor_codenames
         end
 
         def lookup_module_list modules_hash
@@ -121,7 +89,7 @@ class Card
         def anchor_codenames
           anchor_parts.map do |part|
             part_id = Card.fetch_id part
-            Card::Codename[part_id] || return
+            Card::Codename[part_id] || break
           end
         end
 
@@ -155,11 +123,7 @@ class Card
 
         def safe_key
           caps_part = self.class.pattern_code.to_s.tr(" ", "_").upcase
-          if self.class.anchorless?
-            caps_part
-          else
-            "#{caps_part}-#{@anchor_name.safe_key}"
-          end
+          self.class.anchorless? ? caps_part : "#{caps_part}-#{@anchor_name.safe_key}"
         end
 
         def rule_set_key
@@ -171,50 +135,5 @@ class Card
         end
       end
     end
-
-    class Type < Pattern::Abstract
-      def initialize card
-        super
-        # support type inheritance
-        @inherit_card = card unless module_key
-      end
-
-      def lookup_module_list modules_hash
-        lookup_key = module_key || inherited_key
-        modules_hash[lookup_key] if lookup_key
-      end
-
-      private
-
-      def inherited_key
-        if defined?(@inherited_key)
-          @inherited_key
-        else
-          @inherited_key = lookup_inherited_key
-        end
-      end
-
-      def lookup_inherited_key
-        return unless @inherit_card
-
-        card = @inherit_card
-        @inherit_card = nil
-        return unless (type_code = default_type_code card)
-
-        mod_key = "Type::#{type_code.to_s.camelize}"
-        mod_key if mods_exist_for_key? mod_key
-      end
-
-      def default_type_code card
-        default_rule = card.rule_card :default
-        default_rule&.type_code
-      end
-
-      def mods_exist_for_key? mod_key
-        list_of_hashes = Card::Set.modules[:nonbase_format].values
-        list_of_hashes << Card::Set.modules[:nonbase]
-        list_of_hashes.any? { |h| h[mod_key] }
-      end
-    end
   end
 end