card 1.19.1 → 1.19.2

data/lib/card/director_register.rb

@@ -1,101 +0,0 @@
-class Card
-  def act opts={}
-    if DirectorRegister.act_card
-      if DirectorRegister.act_card != self && !only_storage_phase
-        director.reset_stage
-        if opts && opts[:trash]
-          @action = :delete
-        else
-          identify_action
-        end
-        director.update_card self
-        self.only_storage_phase = true
-      end
-      main_act_block = false
-    else
-      DirectorRegister.clear
-      self.director = nil
-      DirectorRegister.act_card = self
-      main_act_block = true
-      if opts && opts[:success]
-        Env[:success] = Env::Success.new(cardname, Env.params[:success])
-      end
-    end
-    yield
-  ensure
-    DirectorRegister.clear if main_act_block
-  end
-
-  def self.new_director card, opts={}
-    if opts[:parent]
-      StageSubdirector.new card, opts
-    elsif DirectorRegister.act_card &&
-          DirectorRegister.act_card != card &&
-          DirectorRegister.act_card.director.running?
-      DirectorRegister.act_card.director.subdirectors.add(card)
-    else
-      StageDirector.new card
-    end
-  end
-
-  class DirectorRegister
-    cattr_accessor :act_card
-
-    class << self
-      def act_director
-        return unless DirectorRegister.act_card
-        DirectorRegister.act_card.director
-      end
-
-      def directors
-        @directors ||= {}
-      end
-
-      def clear
-        DirectorRegister.act_card = nil
-        directors.each_pair do |card, _dir|
-          card.director = nil
-        end
-        @directors = nil
-      end
-
-      def fetch card, opts={}
-        return directors[card] if directors[card]
-        directors.each_key do |dir_card|
-          return dir_card.director if dir_card.name == card.name
-        end
-        directors[card] = Card.new_director card, opts
-      end
-
-      def add director
-        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?
-        (dir = DirectorRegister.act_director) && dir.running?
-      end
-
-      def to_s
-        directors.values.map(&:to_s).join "\n"
-      end
-    end
-  end
-end

data/lib/card/stage.rb

@@ -1,106 +0,0 @@
-class Card
-  # The process of writing a card change to the database is divided into
-  # 8 stages that are grouped in 3 phases.
-  #
-  # 'validation phase'
-  #   * initialize stage (I)
-  #   * prepare_to_validate stage (P2V)
-  #   * validate stage (V)
-  #
-  # 'storage phase'
-  #   * prepare_to_store stage (P2S)
-  #   * store stage (S)
-  #   * finalize stage (F)
-  #
-  # 'integration phase'
-  #   * integrate stage (IG)
-  #   * integrate_with_delay stage (IGwD)
-  #
-  #
-  # Explanation:
-  #  yes!  the recommended stage to do that
-  #  yes   ok to do it here if necessary
-  #  no    not recommended; chance to mess things up
-  #        but if something forces you to do it here you can try
-  #  no!   never do it here. it won't work or will break things
-  #
-  # if there is only a single entry in a phase column it counts for all stages
-  # of that phase
-  #
-  #                                  validation    |    storage    | integrate
-  #                                 I    P2V  V    |  P2S  S    F  | IG   IGwD
-  #-------------------------------------------------------------------------
-  # 1  attach subcard               yes! yes! yes  | yes  yes  yes |    yes
-  # 2  detach subcard               yes! yes! yes  | yes  no   no! |    no!
-  # 3  validate                     yes  yes  yes! |      no       |    no
-  # 4  insecure change              yes  yes! no   |      no!      |    no!
-  # 5  secure change                     yes       | yes! no!  no! |    no!
-  # 6  abort                             yes!      |      yes      |    yes?
-  # 7  fail
-  # 8  create other cards
-  # 9  has id                            no        | no   no?  yes |    yes
-  # 10 within transaction                yes       |      yes      |    no
-  # 11 within web request                yes       |      yes      | yes  no
-
-  #    available values:
-  #    dirty attributes                  yes       |      yes      |    yes
-  #    success                           yes       |      yes      | yes  no
-  #    session                           yes       |      yes      | yes  no
-  #    params                            yes       |      yes      |    yes
-  #
-  # 4) 'insecure' means a change of a card attribute that can possibly make
-  #    the card invalid to save
-  # 5) 'secure' means you are sure that the change doesn't affect the validation
-  module Stage
-    STAGES = [:initialize, :prepare_to_validate, :validate, :prepare_to_store,
-              :store, :finalize, :integrate, :integrate_with_delay].freeze
-    STAGE_INDEX = {}
-    STAGES.each_with_index do |stage, i|
-      STAGE_INDEX[stage] = i
-    end
-    STAGE_INDEX.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
-        return STAGE_INDEX[stage]
-      when Integer then
-        return stage
-      else
-        raise Card::Error, "not a valid stage: #{stage}"
-      end
-    end
-
-    def stage_ok? opts
-      stage && (
-      (opts[:during] && in?(opts[:during])) ||
-        (opts[:before] && before?(opts[:before])) ||
-        (opts[:after] && after?(opts[:after])) ||
-        true # no phase restriction in opts
-      )
-    end
-
-    def before? allowed_phase
-      STAGE_INDEX[allowed_phase] > STAGE_INDEX[stage]
-    end
-
-    def after? allowed_phase
-      STAGE_INDEX[allowed_phase] < STAGE_INDEX[stage]
-    end
-
-    def in? allowed_phase
-      (allowed_phase.is_a?(Array) && allowed_phase.include?(stage)) ||
-        allowed_phase == stage
-    end
-  end
-end

data/lib/card/stage_director.rb

@@ -1,310 +0,0 @@
-
-class Card
-  def restore_changes_information
-    return unless @previously_changed
-    @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-    @previously_changed.each do |k, (old, _new)|
-      @changed_attributes[k] = old
-    end
-  end
-
-  def clean_after_stage_fail
-    @action = nil
-    expire_pieces
-    subcards.each(&:expire_pieces)
-  end
-  # A 'StageDirector' executes the stages of a card when the card gets created,
-  # updated or deleted.
-  # For subcards, i.e. other cards that are changed in the same act, a
-  # StageDirector has StageSubdirectors that take care of the stages for
-  # those cards
-  #
-  # In general a stage is executed for all involved cards before the
-  # StageDirector proceeds with the next stage.
-  # Only exception is the finalize stage.
-  # The finalize stage of a subcard is executed immediately after its store
-  # stage. When all subcards are finalized the supercard's finalize stage is
-  # executed.
-  #
-  # If a subcard is added in a stage then it catches up at the end of the stage
-  # to the current stage.
-  # For example if you add a subcard in a card's :prepare_to_store stage then
-  # after that stage the stages :initialize, :prepare_to_validate,
-  # :validate and :prepare_to_store are executed for the subcard.
-  #
-  # Stages are executed with pre-order depth-first search.
-  # That means if A has subcards AA and AB; AAA is subcard of AA and ABA
-  # subcard of AB then the order of execution is
-  # A -> AA -> AAA -> AB -> ABA
-  #
-  # A special case can happen in the store phase.
-  # If the id of a subcard is needed for a supercard
-  # (for example as left_id or as type_id) and the subcard doesn't
-  # have an id yet (because it gets created in the same act)
-  # then the subcard's store stage is executed before the supercard's store
-  # stage
-  class StageDirector
-    include Stage
-
-    attr_accessor :prior_store, :act, :card, :stage, :parent, :main,
-                  :subdirectors, :transact_in_stage
-    attr_reader :running
-    alias_method :running?, :running
-    alias_method :main?, :main
-
-    def initialize card, opts={}, main=true
-      @card = card
-      @card.director = self
-      # for read actions there is no validation phase
-      # so we have to set the action here
-      @card.identify_action
-
-      @stage = nil
-      @running = false
-      @prepared = false
-      @parent = opts[:parent]
-      # has card to be stored before the supercard?
-      @prior_store = opts[:priority]
-      @call_after_store = []
-      @main = main
-      @subdirectors = SubdirectorArray.initialize_with_subcards(self)
-      register
-    end
-
-    def register
-      Card::DirectorRegister.add self
-    end
-
-    def unregister
-      Card::DirectorRegister.delete self
-    end
-
-    def delete
-      @card.director = nil
-      @subdirectors.clear
-      @stage = nil
-      @action = nil
-    end
-
-    def prepare_for_phases
-      @card.prepare_for_phases unless @prepared
-      @prepared = true
-      @subdirectors.each(&:prepare_for_phases)
-    end
-
-    def validation_phase
-      run_single_stage :initialize
-      run_single_stage :prepare_to_validate
-      run_single_stage :validate
-      @card.expire_pieces if @card.errors.any?
-      @card.errors.empty?
-    end
-
-    def storage_phase &block
-      catch_up_to_stage :prepare_to_store
-      run_single_stage :store, &block
-      run_single_stage :finalize
-    ensure
-      @from_trash = nil
-    end
-
-    def integration_phase
-      return if @abort
-      @card.restore_changes_information
-      run_single_stage :integrate
-      run_single_stage :integrate_with_delay
-    rescue => e  # don't rollback
-      Card::Error.current = e
-      @card.notable_exception_raised
-      return false
-    ensure
-      @card.changes_applied unless @abort
-      DirectorRegister.clear if main? && !@card.only_storage_phase
-    end
-
-    def catch_up_to_stage next_stage
-      if @transact_in_stage
-        return if @transact_in_stage != next_stage
-        next_stage = :integrate_with_delay
-      end
-      upto_stage(next_stage) do |stage|
-        run_single_stage stage
-      end
-    end
-
-    def reset_stage
-      @stage = -1
-    end
-
-    def abort
-      @abort = true
-    end
-
-    def call_after_store &block
-      @call_after_store << block
-    end
-
-    def need_act
-      act_director = main_director
-      unless act_director
-        raise Card::Error, "act requested without a main stage director"
-      end
-      act_director.act ||= Card::Act.create(ip_address: Env.ip)
-      @card.current_act = @act = act_director.act
-    end
-
-    def main_director
-      if main?
-        self
-      else
-        DirectorRegister.act_director || (@parent && @parent.main_director)
-      end
-    end
-
-    def to_s
-      str = @card.name.to_s.clone
-      if @subdirectors
-        subs = subdirectors.map(&:card)
-                           .map { |card| "  #{card.name}" }.join "\n"
-        str << "\n#{subs}"
-      end
-      str
-    end
-
-    def update_card card
-      old_card = @card
-      @card = card
-      DirectorRegister.card_changed old_card
-    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? stage
-      new_stage = stage_index(stage)
-      @stage ||= -1
-      return if @stage >= new_stage
-      if @stage < new_stage - 1
-        raise Card::Error, "stage #{stage_symbol(new_stage - 1)} was skipped " \
-                           "for card #{@card}"
-      end
-      @card.errors.empty? || new_stage > stage_index(:validate)
-    end
-
-    def run_single_stage stage, &block
-      return true unless valid_next_stage? stage
-      # puts "#{@card.name}: #{stage} stage".red
-
-      @stage = stage_index stage
-      if stage == :initialize
-        @running ||= true
-        prepare_for_phases
-      end
-      # in the store stage it can be necessary that
-      # other subcards must be saved before we save this card
-      if stage == :store
-        store(&block)
-      else
-        run_stage_callbacks stage
-        run_subdirector_stages stage
-      end
-    rescue => e
-      @card.clean_after_stage_fail
-      raise e
-    end
-
-    def run_stage_callbacks stage
-      Rails.logger.debug "#{stage}: #{@card.name}"
-      # we use abort :success in the :store stage for :save_draft
-      if stage_index(stage) <= stage_index(:store) && !main?
-        @card.abortable do
-          @card.run_callbacks :"#{stage}_stage"
-        end
-      else
-        @card.run_callbacks :"#{stage}_stage"
-      end
-    end
-
-    def run_subdirector_stages stage
-      @subdirectors.each do |subdir|
-        subdir.catch_up_to_stage stage
-      end
-    ensure
-      @card.handle_subcard_errors
-    end
-
-    # handle the store stage
-    # The tricky part here is to preserve the dirty marks on the subcards'
-    # attributes for the finalize stage.
-    # To achieve this we can't just call the :store and :finalize callbacks on
-    # the subcards as we do in the other phases.
-    # Instead we have to call `save` on the subcards
-    # and use the ActiveRecord :around_save callback to run the :store and
-    # :finalize stages
-    def store &save_block
-      if main? && !block_given?
-        raise Card::Error, "need block to store main card"
-      end
-      # the block is the ActiveRecord block from the around save callback that
-      # saves the card
-      if block_given?
-        run_stage_callbacks :store
-        store_with_subcards(&save_block)
-      else
-        trigger_storage_phase_callback
-      end
-    end
-
-    def store_with_subcards
-      store_pre_subcards
-      yield
-      @call_after_store.each { |handle_id| handle_id.call(@card.id) }
-      store_post_subcards
-      true.tap { @virtual = false } # TODO: find a better place for this
-    ensure
-      @card.handle_subcard_errors
-    end
-
-    # store subcards whose ids we need for this card
-    def store_pre_subcards
-      @subdirectors.each do |subdir|
-        next unless subdir.prior_store
-        subdir.catch_up_to_stage :store
-      end
-    end
-
-    def store_post_subcards
-      @subdirectors.each do |subdir|
-        next if subdir.prior_store
-        subdir.catch_up_to_stage :store
-      end
-    end
-
-    # trigger the storage_phase, skip the other phases
-    # At this point the :prepare_to_store stage was already executed
-    # by the parent director. So the storage phase will only run
-    # the :store stage and the :finalize stage
-    def trigger_storage_phase_callback
-      @stage = stage_index :prepare_to_store
-      @card.only_storage_phase = true
-      @card.save! validate: false
-    end
-  end
-
-  class StageSubdirector < StageDirector
-    def initialize card, opts={}
-      super card, opts, false
-    end
-
-    def delete
-      @parent.subdirectors.delete self if @parent
-      super
-    end
-  end
-end