card 1.99.6 → 1.100.0

data/lib/card/director/act_direction.rb

@@ -0,0 +1,111 @@
+class Card
+  class Director
+    module ActDirection
+      attr_accessor :act, :act_card
+
+      def act_director
+        return unless act_card
+
+        act_card.director
+      end
+
+      def directors
+        @directors ||= {}
+      end
+
+      def run_act card
+        self.act_card = card
+        # add new_director(card)
+        yield
+      ensure
+        clear
+      end
+
+      def need_act
+        self.act ||= Card::Act.create ip_address: Env.ip
+      end
+
+      def clear
+        self.act_card = nil
+        self.act = nil
+        directors.each_pair do |card, _dir|
+          card.expire
+          card.director = nil
+          card.action = nil
+          card.clear_action_specific_attributes
+        end
+        expire
+        @directors = nil
+      end
+
+      def expire
+        expirees.each { |expiree| Card.expire expiree }
+        @expirees = []
+      end
+
+      def expirees
+        @expirees ||= []
+      end
+
+      def fetch card, parent=nil
+        return directors[card] if directors[card]
+
+        directors.each_key do |dir_card|
+          return dir_card.director if dir_card.name == card.name && dir_card.director
+        end
+        add new_director(card, parent)
+      end
+
+      def include? name
+        directors.keys.any? { |card| card.key == name.to_name.key }
+      end
+
+      def new_director card, parent
+        if !parent && act_card && act_card != card && running_act?
+          act_card.director.subdirectors.add card
+        else
+          Director.new card, parent
+        end
+      end
+
+      def card name
+        directors.values.find do |dir|
+          dir.card.name == name
+        end&.card
+      end
+
+      def add director
+        # Rails.logger.debug "added: #{director.card.name}".green
+        directors[director.card] = director
+      end
+
+      def card_changed old_card
+        return unless (director = @directors.delete old_card)
+
+        add director
+      end
+
+      def delete director
+        return unless @directors
+
+        @directors.delete director.card
+        director.delete
+      end
+
+      def deep_delete director
+        director.subdirectors.each do |subdir|
+          deep_delete subdir
+        end
+        delete director
+      end
+
+      def running_act?
+        act_director&.running?
+      end
+
+      def to_s
+        act_director.to_s
+      end
+    end
+  end
+end

data/lib/card/director/card_methods.rb

@@ -0,0 +1,45 @@
+class Card
+  class Director
+    module CardMethods
+      attr_writer :director
+      delegate :validation_phase, :storage_phase, :integration_phase,
+               :validation_phase_callback?, :integration_phase_callback?, to: :director
+
+      def director
+        @director ||= Director.fetch self
+      end
+
+      def prepare_for_phases
+        reset_patterns
+        identify_action
+        include_set_modules
+      end
+
+      def identify_action
+        @action =
+          if trash && trash_changed?
+            :delete
+          elsif new_card?
+            :create
+          else
+            :update
+          end
+      end
+
+      def restore_changes_information
+        # restores changes for integration phase
+        # (rails cleared them in an after_create/after_update hook which is
+        #  executed before the integration phase)
+        return unless saved_changes.present?
+
+        @mutations_from_database = mutations_before_last_save
+      end
+
+      def clear_action_specific_attributes
+        self.class.action_specific_attributes.each do |attr|
+          instance_variable_set "@#{attr}", nil
+        end
+      end
+    end
+  end
+end

data/lib/card/{act_manager → director}/event_delay.rb

@@ -1,5 +1,5 @@
 class Card
-  class ActManager
+  class Director
     # methods for handling delayed events
     module EventDelay
       # If active jobs (and hence the integrate_with_delay events) don't run
@@ -9,10 +9,10 @@ class Card
       # (a crucial example are success params that are processed in
       # CardController#soft_redirect)
       def contextualize_delayed_event act_id, card, env, auth
-        if delaying?
-          contextualize_for_delay(act_id, card, env, auth) { yield }
-        else
-          yield
+        return yield unless delaying?
+
+        with_env_and_auth env, auth do
+          with_delay_act(act_id, card) { yield }
         end
       end
 
@@ -22,21 +22,14 @@ class Card
           Card.config.active_job.queue_adapter == :delayed_job
       end
 
-      # The whole ActManager setup is gone once we reach a integrate with delay
-      # event processed by ActiveJob.
-      # This is the improvised resetup to get subcards working.
-      def contextualize_for_delay act_id, card, env, auth, &block
-        with_env_and_auth env, auth do
-          if act_id && (self.act = Act.find act_id)
-            run_job_with_act act, card, &block
-          else
-            yield
-          end
-        end
+      def with_delay_act act_id, card, &block
+        return yield unless act_id && (self.act = Act.find act_id)
+
+        run_job_with_act act, card, &block
       end
 
       def run_job_with_act act, card, &block
-        run_act(act.card || card) do
+        run_act card do
           act_card.director.run_delayed_event act, &block
         end
       end

data/lib/card/director/phases.rb

@@ -0,0 +1,55 @@
+class Card
+  before_validation :validation_phase, if: -> { validation_phase_callback? }
+  around_save :storage_phase
+  after_commit :integration_phase, if: -> { integration_phase_callback? }
+
+  class Director
+    # Validation, Storage, and Integration phase handling
+    module Phases
+      def validation_phase_callback?
+        !@only_storage_phase && head?
+      end
+
+      def integration_phase_callback?
+        !@only_storage_phase && main?
+      end
+
+      def prepare_for_phases
+        @card.prepare_for_phases unless running?
+        @running = true
+        @subdirectors.each(&:prepare_for_phases)
+      end
+
+      def validation_phase
+        run_stage :initialize
+        run_stage :prepare_to_validate
+        run_stage :validate
+      ensure
+        # @card.expire_pieces if @card.errors.any?
+        @card.errors.empty?
+      end
+
+      # Unlike other phases, the storage phase takes a block,
+      # because it is called by an "around" callback
+      def storage_phase &block
+        catch_up_to_stage :prepare_to_store
+        run_stage :store, &block
+        run_stage :finalize
+        raise ActiveRecord::RecordInvalid, @card if @card.errors.any?
+      ensure
+        @from_trash = nil
+      end
+
+      def integration_phase
+        return if @abort
+
+        @card.restore_changes_information
+        run_stage :integrate
+        run_stage :after_integrate
+        run_stage :integrate_with_delay
+      ensure
+        @card.clear_changes_information unless @abort
+      end
+    end
+  end
+end

data/lib/card/director/run.rb

@@ -0,0 +1,107 @@
+class Card
+  class Director
+    # methods for running stages
+    module Run
+      def catch_up_to_stage next_stage
+        return if @delay && before?(:integrate_with_delay, next_stage)
+
+        upto_stage(next_stage) do |stage|
+          run_stage stage
+        end
+      end
+
+      def run_delayed_event act
+        @running = true
+        @act = act
+        @stage = stage_index :integrate_with_delay
+        yield
+        run_subcard_stages :integrate_with_delay
+      end
+
+      def delay!
+        @delay = true
+      end
+
+      def restart
+        @running = false
+        @stage = nil
+      end
+
+      private
+
+      def upto_stage stage
+        @stage ||= -1
+        (@stage + 1).upto(stage_index(stage)) do |i|
+          yield stage_symbol(i)
+        end
+      end
+
+      def valid_next_stage? next_stage
+        @stage ||= -1
+        return false if in_or_after? next_stage
+
+        skipped_stage! next_stage if before?(previous_stage_index(next_stage))
+        @card.errors.empty? || after?(:validate, next_stage)
+      end
+
+      def skipped_stage! stage
+        raise Card::Error, "stage #{previous_stage_symbol stage} was " \
+                           "skipped for card #{@card}"
+      end
+
+      def run_stage stage, &block
+        return true unless valid_next_stage? stage
+
+        # puts "#{@card.name}: #{stage} stage".red
+        prepare_stage_run stage
+        execute_stage_run stage, &block
+      end
+
+      def prepare_stage_run stage
+        @stage = stage_index stage
+        prepare_for_phases if stage == :initialize
+      end
+
+      def execute_stage_run stage, &block
+        # in the store stage it can be necessary that
+        # other subcards must be saved before we save this card
+        return store(&block) if stage == :store
+
+        run_stage_callbacks stage
+        run_subcard_stages stage
+        run_final_stage_callbacks stage
+      end
+
+      def run_stage_callbacks stage, callback_postfix=""
+        Rails.logger.debug "#{stage}: #{@card.name}"
+        # we use abort :success in the :store stage for :save_draft
+
+        callbacks = :"#{stage}#{callback_postfix}_stage"
+        if in_or_before?(:store, stage) && !main?
+          @card.abortable { @card.run_callbacks callbacks }
+        else
+          @card.run_callbacks callbacks
+        end
+      end
+
+      def run_subcard_stages stage
+        each_subcard_director stage do |subdir|
+          condition = block_given? ? yield(subdir) : true
+          subdir.catch_up_to_stage stage if condition
+        end
+      end
+
+      def each_subcard_director stage
+        subdirectors.each do |subdir|
+          yield subdir unless subdir.head? && before?(:integrate, stage)
+        end
+      ensure
+        @card.handle_subcard_errors
+      end
+
+      def run_final_stage_callbacks stage
+        run_stage_callbacks stage, "_final"
+      end
+    end
+  end
+end

data/lib/card/director/stages.rb

@@ -0,0 +1,85 @@
+class Card
+  class Director
+    # Methods for intepreting stages of an action
+    module Stages
+      STAGES = %i[initialize prepare_to_validate validate
+                  prepare_to_store store finalize integrate
+                  after_integrate integrate_with_delay].freeze
+      STAGE_INDEX = STAGES.each_with_index.with_object({}) do |(stage, index), hash|
+        Card.define_callbacks "#{stage}_stage", "#{stage}_final_stage"
+        hash[stage] = index
+      end.freeze
+
+      def stage_symbol index
+        case index
+        when Symbol
+          return index if STAGE_INDEX[index]
+        when Integer
+          return STAGES[index] if index < STAGES.size
+        end
+        raise Card::Error, "not a valid stage index: #{index}"
+      end
+
+      def stage_index stage
+        case stage
+        when Symbol then
+          STAGE_INDEX[stage]
+        when Integer then
+          stage
+        else
+          raise Card::Error, "not a valid stage: #{stage}"
+        end
+      end
+
+      def stage_ok? opts
+        return false unless stage
+        test = %i[during before after].find { |t| opts[t] }
+        test ? send("#{test}?", opts[t]) : true
+      end
+
+      def finished_stage? stage
+        @stage > stage_index(stage)
+      end
+
+      def reset_stage
+        @stage = -1
+      end
+
+      private
+
+      def previous_stage_index from_stage=nil
+        from_stage ||= @stage
+        stage_index(from_stage) - 1
+      end
+
+      def previous_stage_symbol from_stage=nil
+        stage_symbol previous_stage_index(from_stage)
+      end
+
+      def before? *args
+        stage_test(*args) { |r, t| r > t }
+      end
+
+      def in_or_before? *args
+        stage_test(*args) { |r, t| r >= t }
+      end
+
+      def after? *args
+        stage_test(*args) { |r, t| r < t }
+      end
+
+      def in_or_after? *args
+        stage_test(*args) { |r, t| r <= t }
+      end
+
+      def during? *args
+        stage_test(*args) { |r, t| r == t }
+      end
+
+      def stage_test reference_stage, test_stage=nil
+        test_stage ||= @stage
+        yield stage_index(reference_stage), stage_index(test_stage)
+      end
+    end
+  end
+end