card 1.101.0 → 1.101.5

data/lib/card/rule/cache.rb

@@ -39,12 +39,14 @@ class Card
         def lookup_hash
           rows.each_with_object({}) do |row, hash|
             next unless (key = lookup_key row)
+
             hash[key] = row["rule_id"].to_i
           end
         end
 
         def lookup_key row
           return false unless (setting_code = setting_code(row))
+
           anchor_id = row["anchor_id"]
           return false unless (pattern_code = pattern_code(anchor_id, row))
 

data/lib/card/set/advanced_api.rb

@@ -10,17 +10,21 @@ class Card
       def ensure_set &block
         set_module = yield
         set_module = card_set_module_const_get(set_module) unless set_module.is_a?(Module)
-        set_module
       rescue NameError => e
-        if e.message =~ /uninitialized constant (?:Card::Set::)?(.+)$/
-          define_set Regexp.last_match(1)
-        end
+        define_set_from_error e
         # try again - there might be another submodule that doesn't exist
         ensure_set(&block)
       else
         set_module.extend Card::Set
       end
 
+      def define_set_from_error error
+        match = error.message.match(/uninitialized constant (?:Card::Set::)?(.+)$/)
+        return unless match
+
+        define_set match[1]
+      end
+
       def attachment name, args
         include_set Abstract::Attachment
         add_attributes name, "remote_#{name}_url".to_sym,

data/lib/card/set/event.rb

@@ -156,8 +156,8 @@ class Card
     end
   end
 
-  def rescuing_if_integration is_integration
-    is_integration ? rescuing_integration { yield } : yield
+  def rescuing_if_integration is_integration, &block
+    is_integration ? rescuing_integration(&block) : yield
   end
 
   # one failed integration event should not harm others.

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

@@ -0,0 +1,101 @@
+class Card
+  module Set
+    class Event
+      # card methods for testing event applicability
+      module All
+        include SkipAndTrigger
+
+        def event_applies? event
+          return unless set_condition_applies? event.set_module, event.opts[:changing]
+
+          CONDITIONS.all? { |c| send "#{c}_condition_applies?", event, event.opts[c] }
+        end
+
+        private
+
+        def set_condition_applies? set_module, old_sets
+          return true if set_module == Card
+
+          set_condition_card(old_sets).singleton_class.include? set_module
+        end
+
+        def on_condition_applies? _event, actions
+          actions = Array(actions).compact
+          actions.empty? ? true : actions.include?(action)
+        end
+
+        # if changing name/type, the old card has no-longer-applicable set modules,
+        # so we create a new card to determine whether events apply.
+        # (note: cached condition card would ideally be cleared after all
+        # conditions are reviewed)
+        # @param old_sets [True/False] whether to use the old_sets
+        def set_condition_card old_sets
+          return self if old_sets || no_current_action?
+
+          @set_condition_card ||=
+            updating_sets? ? set_condition_card_with_new_set_modules : self
+        end
+
+        # existing card is being changed in a way that alters its sets
+        def updating_sets?
+          action == :update && real? && (type_id_is_changing? || name_is_changing?)
+        end
+
+        # prevents locking in set_condition_card
+        def no_current_action?
+          return false if @current_action
+
+          @set_condition_card = nil
+          true
+        end
+
+        def set_condition_card_with_new_set_modules
+          cc = Card.find id
+          cc.name = name
+          cc.type_id = type_id
+          cc.include_set_modules
+        end
+
+        def changed_condition_applies? _event, db_columns
+          return true unless action == :update
+
+          db_columns = Array(db_columns).compact
+          return true if db_columns.empty?
+
+          db_columns.any? { |col| single_changed_condition_applies? col }
+        end
+        alias_method :changing_condition_applies?, :changed_condition_applies?
+
+        def when_condition_applies? _event, block
+          case block
+          when Proc then block.call(self)
+          when Symbol then send block
+          else true
+          end
+        end
+
+        def single_changed_condition_applies? db_column
+          return true unless db_column
+
+          send "#{db_column}_is_changing?"
+        end
+
+        def wrong_stage opts
+          return false if director.stage_ok? opts
+
+          if !stage
+            "phase method #{method} called outside of event phases"
+          else
+            "#{opts.inspect} method #{method} called in stage #{stage}"
+          end
+        end
+
+        def wrong_action actn
+          return false if on_condition_applies?(nil, actn)
+
+          "on: #{actn} method #{method} called on #{action}"
+        end
+      end
+    end
+  end
+end

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

@@ -23,13 +23,21 @@ class Card
           if condition == :when
             validate_when_value val
           else
-            invalid = Array.wrap(val) - Api::OPTIONS[condition]
-            return if invalid.empty?
+            validate_standard_condition_value condition, val
+          end
+        end
 
-            raise ArgumentError,
-                  "invalid option#{'s' if invalid.size > 1} '#{invalid}' "\
+        def validate_standard_condition_value condition, val
+          invalid = invalid_condition_values condition, val
+          return if invalid.empty?
+
+          raise ArgumentError,
+                "invalid option#{'s' if invalid.size > 1} '#{invalid}' "\
                   "for condition '#{condition}' in event '#{@event}'"
-          end
+        end
+
+        def invalid_condition_values condition, val
+          Array.wrap(val) - Api::OPTIONS[condition]
         end
 
         def validate_when_value val
@@ -65,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.rb

@@ -106,20 +106,27 @@ class Card
 
       def register_set_format format_class, mod
         if all_set?
-          all_set_format_mod! format_class, mod
+          register_all_set_format format_class, mod
         else
-          format_type = abstract_set? ? :abstract_format : :nonbase_format
-          # ready to include dynamically in set members' format singletons
-          format_hash = modules[format_type][format_class] ||= {}
-          format_hash[shortname] ||= []
-          format_hash[shortname] << mod
+          register_standard_set_format format_class, mod
         end
       end
 
       # make mod ready to include in base (non-set-specific) format classes
-      def all_set_format_mod! format_class, mod
-        modules[:base_format][format_class] ||= []
-        modules[:base_format][format_class] << mod
+      def register_all_set_format format_class, mod
+        add_to_array_val modules[:base_format], format_class, mod
+      end
+
+      def register_standard_set_format format_class, mod
+        format_type = abstract_set? ? :abstract_format : :nonbase_format
+        # ready to include dynamically in set members' format singletons
+        format_hash = modules[format_type][format_class] ||= {}
+        add_to_array_val format_hash, shortname, mod
+      end
+
+      def add_to_array_val hash, key, val
+        hash[key] ||= []
+        hash[key] << val
       end
 
       class << self

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)