card 1.101.2 → 1.102.0

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

@@ -1,5 +1,3 @@
-require "application_job"
-
 class Card
   # attributes that ActiveJob can handle
   def serializable_attributes
@@ -47,7 +45,7 @@ class Card
           end
         end
 
-        class IntegrateWithDelayJob < ApplicationJob
+        class IntegrateWithDelayJob < Cardio::Job
           def perform act_id, card, card_attribs, env, auth, method_name
             handle_perform do
               load_card card, card_attribs
@@ -59,9 +57,9 @@ class Card
 
           def handle_perform
             yield
-          rescue StandardError => error
-            Card::Error.report error, @card
-            raise error
+          rescue StandardError => e
+            Card::Error.report e, @card
+            raise e
           ensure
             Director.expire
           end
@@ -121,7 +119,7 @@ class Card
   end
 
   def serialize_hash_value value
-    value.each_with_object({}) { |(k, v), h| h[k] = serialize_value(v) }
+    value.transform_values { |v| serialize_value(v) }
   end
 
   def deserialize_value val, type
@@ -138,8 +136,8 @@ class Card
   end
 
   def deserialize_hash_value value
-    value.each_with_object({}) do |(k, v), h|
-      h[k] = deserialize_value v[:value], v[:type]
+    value.transform_values do |v|
+      deserialize_value v[:value], v[:type]
     end
   end
 end

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

@@ -73,6 +73,7 @@ class Card
           stage = opts.delete :stage
           after_subcards = opts.delete :after_subcards
           return if opts[:after] || opts[:before] || opts[:around] || !(@stage = stage)
+
           # after, before, or around will override stage configuration
 
           opts[:after] = callback_name stage, after_subcards

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

@@ -0,0 +1,89 @@
+class Card
+  module Set
+    class Event
+      # opt into (trigger) or out of (skip) events
+      module SkipAndTrigger
+        # force skipping this event for all cards in act
+        def skip_event! *events
+          @full_skip_hash = nil
+          force_events events, act_skip_hash
+        end
+
+        # force skipping this event for this card only
+        def skip_event_in_action! *events
+          force_events events, full_skip_hash
+        end
+
+        # force triggering this event (when it comes up) for all cards in act
+        def trigger_event! *events
+          @full_trigger_hash = nil
+          force_events events, act_trigger_hash
+        end
+
+        # force triggering this event (when it comes up) for this card only
+        def trigger_event_in_action! *events
+          force_events events, full_trigger_hash
+        end
+
+        # hash form of raw skip setting, eg { "my_event" => true }
+        def skip_hash
+          @skip_hash ||= hash_with_value skip, true
+        end
+
+        def trigger_hash
+          @trigger_hash ||= hash_with_value trigger, true
+        end
+
+        private
+
+        # "applies always means event can run
+        # so if skip_condition_applies?, we do NOT skip
+        def skip_condition_applies? event, allowed
+          return true unless (val = full_skip_hash[event.name.to_s])
+
+          allowed ? val.blank? : (val != :force)
+        end
+
+        def trigger_condition_applies? event, required
+          return true unless required
+
+          full_trigger_hash[event.name.to_s].present?
+        end
+
+        def full_skip_hash
+          @full_skip_hash ||= act_skip_hash.merge skip_in_action_hash
+        end
+
+        def act_skip_hash
+          (act_card || self).skip_hash
+        end
+
+        def skip_in_action_hash
+          hash_with_value skip_in_action, true
+        end
+
+        def full_trigger_hash
+          @full_trigger_hash ||= act_trigger_hash.merge trigger_in_action_hash
+        end
+
+        def trigger_in_action_hash
+          hash_with_value trigger_in_action, true
+        end
+
+        def act_trigger_hash
+          (act_card || self).trigger_hash
+        end
+
+        def hash_with_value array, value
+          Array.wrap(array).each_with_object({}) do |event, hash|
+            hash[event.to_s] = value
+          end
+        end
+
+        def force_events events, hash
+          events.each { |e| hash[e.to_s] = :force }
+        end
+      end
+    end
+  end
+end

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

@@ -55,6 +55,7 @@ class Card
             if block_given?
               raise Card::Error::ServerError, "no blocks allowed in aliased views"
             end
+
             views[mod][alias_to] || begin
               raise "cannot find #{alias_to} view in #{mod}; " \
                       "failed to alias #{view} from #{self}"

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

@@ -48,6 +48,7 @@ class Card
 
           def interpret_view_settings view, opts
             return unless opts.present?
+
             unknown_ok[view] = true if opts[:unknown] == true
 
             VIEW_SETTINGS.each do |setting_name|

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

@@ -1,6 +1,7 @@
 class Card
   module Set
     module Format
+      # AbstractFormat extends all format classes
       module AbstractFormat
         # The Wrapper module provides an API to define wrap methods.
         # It is available in all formats.
@@ -75,12 +76,7 @@ class Card
             class_exec(self) do |_format|
               define_method "wrap_with_#{wrapper_name}" do |*args, &interior|
                 @interior, opts = interior ? [interior.call, args.first] : args
-
-                if method(wrapper_method_name).arity.zero?
-                  send wrapper_method_name
-                else
-                  send wrapper_method_name, (opts || {})
-                end
+                send_wrapper_method wrapper_method_name, opts
               end
             end
           end

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

@@ -60,8 +60,11 @@ class Card
         end
 
         def source_mod_dir modname, carddir
-          prefix = "#{carddir}/mod" unless modname.match?(/^card-mod-/)
-          "#{prefix}/#{modname}/set/"
+          if (m = modname.match(/^card-mod-(?<shortname>.*)/))
+            "/mod/#{m[:shortname]}/set/"
+          else
+            "#{carddir}/mod/#{modname}/set/"
+          end
         end
 
         def try_haml_template_path template_path, view, source_dir, ext="haml"

data/lib/card/set/i18n_scope.rb

@@ -6,6 +6,7 @@ class Card
       # return scope for I18n
       def scope backtrace
         return "lib" unless (parts = path_parts backtrace)
+
         index = path_set_index parts
         mod = mod_from_parts parts, index
         mod || "lib"
@@ -33,15 +34,16 @@ class Card
       end
 
       def mod_without_version_suffix mod
-        mod.gsub(/-[\d\.]+$/, "")
+        mod.gsub(/-[\d.]+$/, "")
       end
 
       def mod_without_tmp_prefix mod
-        mod.gsub(/^[^-]*\-/, "")
+        mod.gsub(/^[^-]*-/, "")
       end
 
       def path_parts backtrace
         return unless (path = find_set_path backtrace)
+
         parts = path.split File::SEPARATOR
         parts[-1] = parts.last.split(".").first
         parts
@@ -80,7 +82,7 @@ class Card
 
       def find_set_path backtrace
         re = %r{(?<!card)/set/}
-        backtrace.find { |line| line =~ re }.tap do |path|
+        backtrace.find { |line| line.match?(re) }.tap do |path|
           return nil unless path
         end
       end

data/lib/card/set/inheritance.rb

@@ -1,9 +1,7 @@
 class Card
   module Set
     # API to inherit other sets and their formats
-
     module Inheritance
-
       # include a set module and all its format modules
       # @param [Module] set
       # @param [Hash] opts choose the formats you want to include. You can also
@@ -66,15 +64,19 @@ class Card
 
       # iterate through each format associated with a set
       def each_format set
-        set_type = set.abstract_set? ? :abstract : :nonbase
-        format_type = "#{set_type}_format".to_sym
-        modules[format_type].each_pair do |format, set_format_mod_hash|
-          next unless (format_mods = set_format_mod_hash[set.shortname])
+        each_format_with_mods set do |format, mods_for_set|
+          next unless (format_mods = mods_for_set[set.shortname])
 
           yield format, format_mods
         end
       end
 
+      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) }
+      end
+
       def applicable_format? format, except, only
         format_sym = Card::Format.format_sym format
         return false if except && Array(except).include?(format_sym)

data/lib/card/set/pattern.rb

@@ -32,13 +32,11 @@ class Card
             end
         end
 
-        def nonbase_loadable_codes
-          l = loadable_codes
-          l.delete :all
-          l
+        def nonbase_codes
+          codes.tap { |list| list.delete :all }
         end
 
-        def loadable_codes
+        def codes
           Card.set_patterns.map(&:pattern_code).push(:abstract).reverse
         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