card 1.101.3 → 1.101.4

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

@@ -0,0 +1,95 @@
+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/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/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/subcards/all.rb

@@ -0,0 +1,103 @@
+class Card
+  class Subcards
+    # subcard-related Card instance methods
+    module All
+      def subcard card_name
+        subcards.card card_name
+      end
+
+      def subfield field_name
+        subcards.field field_name
+      end
+
+      def field? tag
+        field(tag) || subfield(tag)
+      end
+
+      def subcards
+        @subcards ||= Card::Subcards.new self
+      end
+
+      def subcards?
+        subcards.present?
+      end
+
+      def expire_subcards
+        subcards.clear
+      end
+
+      # phase_method :attach_subcard, before: :store do |name_or_card, args=nil|
+      # TODO: handle differently in different stages
+      def add_subcard name_or_card, args={}
+        subcards.add name_or_card, args
+      end
+      alias_method :attach_subcard, :add_subcard
+
+      def add_subcard! name_or_card, args={}
+        subcard = subcards.add name_or_card, args
+        subcard.director.reset_stage
+        subcard
+      end
+      alias_method :attach_subcard!, :add_subcard!
+
+      # phase_method :attach_subfield, before: :approve do |name_or_card, args=nil|
+      def attach_subfield name_or_card, args={}
+        subcards.add_field name_or_card, args
+      end
+      alias_method :add_subfield, :attach_subfield
+
+      def attach_subfield! name_or_card, args={}
+        subcard = subcards.add_field name_or_card, args
+        subcard.director.reset_stage
+        subcard
+      end
+
+      def detach_subcard name_or_card
+        subcards.remove name_or_card
+      end
+      alias_method :remove_subcard, :detach_subcard
+
+      def detach_subfield name_or_card
+        subcards.remove_field name_or_card
+      end
+      alias_method :remove_subfield, :detach_subfield
+
+      def clear_subcards
+        subcards.clear
+      end
+
+      # ensures subfield is present
+      # does NOT override subfield content if already present
+      def ensure_subfield field_name, args={}
+        if subfield_present? field_name
+          subfield field_name
+        else
+          add_subfield field_name, args
+        end
+      end
+
+      def subfield_present? field_name
+        subfield(field_name)&.content&.present?
+      end
+
+      def deep_clear_subcards
+        subcards.deep_clear
+      end
+
+      def handle_subcard_errors
+        subcards.each do |subcard|
+          subcard.errors.each do |error|
+            subcard_error subcard, error
+          end
+          subcard.errors.clear
+        end
+      end
+
+      def subcard_error subcard, error
+        msg = error.message
+        msg = "#{error.attribute} #{msg}" unless %i[content abort].member? error.attribute
+        errors.add subcard.name.from(name), msg
+      end
+    end
+  end
+end

data/lib/cardio/migration/import.rb

@@ -99,7 +99,7 @@ module Cardio
       def fetch_remote_data name, view, url
         json_url = "#{url}/#{name}.json"
         json_url += "?view=#{view}" if view
-        json = ::File.open(json_url).read
+        json = open(json_url).read
         parse_and_symbolize json
       end
 

data/lib/cardio/utils.rb

@@ -1,9 +1,7 @@
 module Cardio
   # Utilities that may need to be run even when mods are not loaded.
   module Utils
-    def tr key, args={}
-      kaller = args.delete(:caller) || caller
-      args[:scope] ||= Card::Set.scope kaller
+    def t key, args={}
       ::I18n.t key, args
     end
 
@@ -11,6 +9,10 @@ module Cardio
       system "env RAILS_ENV=test bundle exec rake db:fixtures:load"
     end
 
+    def database_name
+      @database_name ||= config.database_configuration.dig Rails.env, "database"
+    end
+
     # deletes tmp directory within files directory
     # It's here because it gets called as part of cache clearing, which sometimes gets
     # called in a context where card mods are not loaded.

data/mod/admin/set/self/admin_info.rb

@@ -27,19 +27,17 @@ format :html do
   def warning_alert warnings
     # 'ADMINISTRATOR WARNING'
     alert :warning, true do
-      "<h5>#{tr :admin_warn}</h5>" + list_tag(warnings)
+      "<h5>#{t :admin_warn}</h5>" + list_tag(warnings)
     end
   end
 
   def no_email_delivery_message
     # "Email delivery is turned off."
     # "Change settings in config/application.rb to send sign up notifications."
-    tr :email_off, path: "config/application.rb"
+    t :admin_email_off, path: "config/application.rb"
   end
 
   def warning_list_with_auto_scope warnings
-    # 'ADMINISTRATOR WARNING'
-    admin_warn = tr(:admin_warn)
-    "<h5>#{admin_warn}</h5>" + warnings.join("\n")
+    "<h5>#{t :admin_warn}</h5>" + warnings.join("\n")
   end
 end

data/mod/admin/set/self/trash.rb

@@ -35,7 +35,7 @@ format :html do
       button_link("empty trash",
                   btn_type: :default,
                   path: { mark: :admin, action: :update, task: :empty_trash,
-                          success: { id: "~#{card.id}" } },
+                          success: { mark: "~#{card.id}" } },
                   "data-confirm" => "Are you sure you want to delete "\
                                     "all cards in the trash?")
     )
@@ -58,6 +58,6 @@ format :html do
                                action: :update,
                                restore: trashed_card.id,
                                action_ids: [before_delete],
-                               success: { id: "~#{card.id}" } }
+                               success: { mark: "~#{card.id}" } }
   end
 end

data/mod/core/set/all/autoname.rb

@@ -0,0 +1,17 @@
+event :set_autoname, :prepare_to_store, on: :create, when: :autoname? do
+  self.name = autoname rule(:autoname)
+  autoname_card = rule_card :autoname
+  autoname_card.update_column :db_content, name
+  autoname_card.expire
+  pull_from_trash!
+  Card.write_to_soft_cache self
+end
+
+def no_autoname?
+  !autoname?
+end
+
+def autoname?
+  name.blank? &&
+    (@autoname_rule.nil? ? (@autoname_rule = rule(:autoname).present?) : @autoname_rule)
+end