card 1.99.1 → 1.99.6

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,11 +34,15 @@ 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
-            [module_comment, module_chain, "cattr_accessor :options", "class << self"]
+            [module_comment,
+             module_chain,
+             "extend Card::Set::Pattern::Helper",
+             "cattr_accessor :options",
+             "class << self"]
           end
 
           def postamble

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

@@ -70,10 +70,14 @@ class Card
       # The derived codename is all lower case with underscores; "*" and ":" are removed
       def ensure_code_card name_or_args, content_or_args=nil
         name, args = standardize_ensure_args name_or_args, content_or_args
-        args[:codename] = name.downcase.tr(" ", "_").tr(":*", "") unless args[:codename]
+        args[:codename] = codename_from_name(name) unless args[:codename]
         ensure_card_simplified name, args
       end
 
+      def codename_from_name name
+        name.downcase.tr(" ", "_").tr(":*", "")
+      end
+
       # create if card doesn't exist
       # updates existing card only if given attributes are different including
       # the name
@@ -199,7 +203,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 +211,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 ...}
@@ -60,8 +62,8 @@ class Card
                           refer_to referred_to_by
                           member_of member
 
-                          found_by not sort match name_match complete
-                          extension_type],
+                          found_by
+                          not sort match name_match complete],
 
       plus_relational: %i[plus left_plus right_plus],
       conjunction:     %i[and or all any],

data/lib/card/query/abstract_query.rb

@@ -19,7 +19,7 @@ class Card
 
       attr_reader :statement, :mods, :conditions, :vars,
                   :subqueries, :superquery, :comment, :negate
-      attr_accessor :joins, :conditions_on_join, :table_seq
+      attr_accessor :joins, :conditions_on_join
 
       def initialize statement, _comment=nil
         @subqueries = []

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/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,12 +1,27 @@
+require "application_job"
+
 class Card
+  # attributes that ActiveJob can handle
+  def serializable_attributes
+    self.class.action_specific_attributes + set_specific.keys
+  end
+
   module Set
     class Event
       module DelayedEvent
         DELAY_STAGES = ::Set.new(%i[integrate_with_delay_stage
                                     integrate_with_delay_final_stage]).freeze
 
+        def priority
+          @priority || 10
+        end
+
         private
 
+        def process_delayed_job_opts opts
+          @priority = opts.delete :priority
+        end
+
         def with_delay? opts
           DELAY_STAGES.include?(opts[:after]) || DELAY_STAGES.include?(opts[:before])
         end
@@ -25,25 +40,37 @@ class Card
         def define_event_delaying_method
           @set_module.class_exec(self) do |event|
             define_method(event.delaying_method_name, proc do
-              IntegrateWithDelayJob.set(queue: event.name).perform_later(
-                Card::ActManager.act&.id, self, serialize_for_active_job,
-                Card::Env.serialize, Card::Auth.serialize,
-                event.simple_method_name
-              )
+              IntegrateWithDelayJob
+                .set(set_delayed_job_args(event))
+                .perform_later(*perform_delayed_job_args(event))
             end)
           end
         end
 
         class IntegrateWithDelayJob < ApplicationJob
           def perform act_id, card, card_attribs, env, auth, method_name
-            Card::Cache.renew
-            card.deserialize_for_active_job! card_attribs
-            ActManager.contextualize_delayed_event act_id, card, env, auth do
-              card.send method_name
+            handle_perform do
+              load_card card, card_attribs
+              ActManager.contextualize_delayed_event act_id, card, env, auth do
+                card.send method_name
+              end
             end
+          end
+
+          def handle_perform
+            yield
+          rescue StandardError => error
+            Card::Error.report error, @card
+            raise error
           ensure
             ActManager.expire
           end
+
+          def load_card card, card_attribs
+            @card = card
+            Card::Cache.renew
+            card.deserialize_for_active_job! card_attribs
+          end
         end
       end
     end
@@ -56,6 +83,21 @@ class Card
     include_set_modules
   end
 
+  private
+
+  def set_delayed_job_args event
+    { queue: event.name, priority: event.priority }
+  end
+
+  def perform_delayed_job_args event
+    [Card::ActManager.act&.id,
+     self,
+     serialize_for_active_job,
+     Card::Env.serialize,
+     Card::Auth.serialize,
+     event.simple_method_name]
+  end
+
   def serialize_for_active_job
     serializable_attributes.each_with_object({}) do |name, hash|
       hash[name] = instance_variable_get("@#{name}")

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

@@ -48,6 +48,7 @@ class Card
           opts = normalize_opts stage_or_opts, opts
           process_stage_opts opts
           process_action_opts opts
+          process_delayed_job_opts opts
           opts
         end
 

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