card 1.101.1 → 1.101.6

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

@@ -59,9 +59,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 +121,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 +138,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/i18n_scope.rb

@@ -5,11 +5,11 @@ class Card
 
       # return scope for I18n
       def scope backtrace
-        parts = path_parts backtrace
+        return "lib" unless (parts = path_parts backtrace)
+
         index = path_set_index parts
         mod = mod_from_parts parts, index
-        set = set_from_parts parts, index
-        "mod.#{mod}.set.#{set}"
+        mod || "lib"
       end
 
       # extract the mod name from the path of a set's tmp file
@@ -27,18 +27,24 @@ class Card
 
       def mod_from_parts parts, set_index
         if tmp_files?
-          mod_from_tmp_parts parts, set_index
+          mod_without_tmp_prefix parts[set_index + 1]
         else
-          parts[set_index - 1]
+          mod_without_version_suffix parts[set_index - 1]
         end
       end
 
-      def mod_from_tmp_parts parts, set_index
-        parts[set_index + 1].gsub(/^[^-]*\-/, "")
+      def mod_without_version_suffix mod
+        mod.gsub(/-[\d.]+$/, "")
+      end
+
+      def mod_without_tmp_prefix mod
+        mod.gsub(/^[^-]*-/, "")
       end
 
       def path_parts backtrace
-        parts = find_set_path(backtrace).split(File::SEPARATOR)
+        return unless (path = find_set_path backtrace)
+
+        parts = path.split File::SEPARATOR
         parts[-1] = parts.last.split(".").first
         parts
       end
@@ -76,9 +82,9 @@ class Card
 
       def find_set_path backtrace
         re = %r{(?<!card)/set/}
-        path = backtrace.find { |line| line =~ re }
-        raise Error, "couldn't find set path in backtrace: #{backtrace}" unless path
-        path
+        backtrace.find { |line| line.match?(re) }.tap do |path|
+          return nil unless path
+        end
       end
 
       # # index of the mod part in the tmp path
@@ -98,8 +104,7 @@ class Card
 
       # index of the mod part in the path
       def path_set_index parts
-        unless (set_index = parts.index("set")) &&
-               parts.size >= set_index + 2
+        unless (set_index = parts.index("set")) && parts.size >= set_index + 2
           raise Error, "not a valid set path: #{path}"
         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/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