card 1.18.6 → 1.19.0

data/lib/card/stage.rb

@@ -27,21 +27,30 @@ class Card
   # 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
-  #----------------------------------------------------------------------
-  # add subcard                  yes! yes! yes  | yes  yes  yes |    yes
-  # remove subcard               yes! yes! yes  | yes  no   no! |    no!
-  # validate                     yes  yes  yes! |      no       |    no
-  # unsecure change              yes  yes! no   |      no!      |    no!
-  # secure change                     yes       | yes! no!  no! |    no!
-  # abort                             yes!      |      yes      |    yes?
-  # fail
-  # create other cards
-  # has id                            no        | no   no?  yes |    yes
-  # dirty attributes                  yes       |      yes      |    no
-  #
+  #                                  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

data/lib/card/stage_director.rb

@@ -1,5 +1,18 @@
 
 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
@@ -34,10 +47,10 @@ class Card
     include Stage
 
     attr_accessor :prior_store, :act, :card, :stage, :parent, :main,
-                  :subdirectors
+                  :subdirectors, :transact_in_stage
     attr_reader :running
-    alias running? running
-    alias main? main
+    alias_method :running?, :running
+    alias_method :main?, :main
 
     def initialize card, opts={}, main=true
       @card = card
@@ -52,6 +65,7 @@ class Card
       @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
@@ -86,10 +100,7 @@ class Card
       @card.errors.empty?
     end
 
-    # everything in here can use dirty marks
     def storage_phase &block
-      # for a subcard :prepare_to_store was already executed
-      # don't execute it twice
       catch_up_to_stage :prepare_to_store
       run_single_stage :store, &block
       run_single_stage :finalize
@@ -97,32 +108,46 @@ class Card
       @from_trash = nil
     end
 
-    # dirty marks are gone in this phase
     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
-      @stage ||= -1
-      (@stage + 1).upto(stage_index(next_stage)) do |i|
-        run_single_stage stage_symbol(i)
+      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 ||= []
       @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'
+        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
@@ -140,18 +165,43 @@ class Card
       str = @card.name.to_s.clone
       if @subdirectors
         subs = subdirectors.map(&:card)
-                 .map { |card| "  #{card.name}" }.join "\n"
+                           .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
-      return if @card.errors.any? && @stage <= stage_index(:validate)
       if stage == :initialize
         @running ||= true
         prepare_for_phases
@@ -162,13 +212,15 @@ class Card
         store(&block)
       else
         run_stage_callbacks stage
-        run_subdirector_stages stage unless stage == :finalize
+        run_subdirector_stages stage
       end
     rescue => e
-      @card.rescue_event 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
@@ -190,14 +242,14 @@ class Card
     # 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 :finlaize callbacks on
-    # the subcards as  we do in the other phases.
+    # 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'
+        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
@@ -205,33 +257,29 @@ class Card
         run_stage_callbacks :store
         store_with_subcards(&save_block)
       else
-        store_and_finalize_as_subcard
+        trigger_storage_phase_callback
       end
     end
 
     def store_with_subcards
-      store_prior_subcards
+      store_pre_subcards
       yield
-      if @call_after_store
-        @call_after_store.each do |handle_id|
-          handle_id.call(@card.id)
-        end
-      end
-      store_subcards
-      @virtual = false # TODO: find a better place for this
+      @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_prior_subcards
+    def store_pre_subcards
       @subdirectors.each do |subdir|
         next unless subdir.prior_store
         subdir.catch_up_to_stage :store
       end
     end
 
-    def store_subcards
+    def store_post_subcards
       @subdirectors.each do |subdir|
         next if subdir.prior_store
         subdir.catch_up_to_stage :store
@@ -242,8 +290,9 @@ class Card
     # 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 store_and_finalize_as_subcard
-      @card.skip_phases = true
+    def trigger_storage_phase_callback
+      @stage = stage_index :prepare_to_store
+      @card.only_storage_phase = true
       @card.save! validate: false
     end
   end

data/lib/card/subcards.rb

@@ -3,11 +3,12 @@
 # API to create/update/delete additional cards together with the main card.
 # The most common case is for fields but subcards don't have to be descendants.
 #
-# Example toghether with "my address" you want to create the subcards
-# "my address+name", "my address+street", etc.
-#
 # Subcards can be added as card objects or attribute hashes.
-
+#
+# Use the methods defined in core/set/all/subcards.rb
+# Example
+# Together with "my address" you want to create the subcards
+# "my address+name", "my address+street", etc.
 class Card
   def subcards
     @subcards ||= Subcards.new(self)
@@ -25,6 +26,59 @@ class Card
       @keys = ::Set.new
     end
 
+    # @example Add a subcard with name 'spoiler'
+    #   add 'spoiler', type: 'Phrase', content: 'John Snow is a Targaryen'
+    #   card_obj = Card.new name: 'spoiler', type: 'Phrase',
+    #                       content: 'John Snow is a Targaryen'
+    #   add card_obj
+    #   add name: 'spoiler', type: 'Phrase', content: 'John Snow is a Targaryen'
+    #
+    # @example Add a subcard that is added in the integration phase
+    #     (and hence doesn't hold up the transaction for the main card)
+    #   add 'spoiler', content: 'John Snow is a Targaryen',
+    #                  transact_in_stage: :integrate
+    #   add card_obj, delayed: true
+    def add name_or_card_or_attr, attr_or_opts={}
+      case name_or_card_or_attr
+      when Card
+        new_by_card name_or_card_or_attr, attr_or_opts
+      when Symbol, String
+        new_by_attributes name_or_card_or_attr, attr_or_opts
+      when Hash
+        args = name_or_card_or_attr
+        if args[:name]
+          new_by_attributes args.delete(:name), args
+        else
+          multi_add args
+        end
+      end
+    end
+
+    def add_child name, args
+      add prepend_plus(name), args
+    end
+    alias_method :add_field, :add_child
+
+    def remove_child name_or_card
+      if name_or_card.is_a? Card
+        remove name_or_card
+      else
+        absolute_name = @context_card.cardname.field_name(name_or_card)
+        if @keys.include? absolute_name.key
+          remove absolute_name
+        else
+          remove @context_card.cardname.relative_field_name(name_or_card)
+        end
+      end
+    end
+    alias_method :remove_field, :remove_child
+
+    def catch_up_to_stage stage_index
+      each_card do |subcard|
+        subcard.catch_up_to_stage stage_index
+      end
+    end
+
     def clear
       @keys.each do |key|
         if (subcard = fetch_subcard key)
@@ -49,51 +103,12 @@ class Card
       return unless @keys.include? key
       @keys.delete key
       removed_card = fetch_subcard key
-      if removed_card.current_action
-        removed_card.current_action.delete
-      end
+      removed_card.current_action.delete if removed_card.current_action
       Card::DirectorRegister.deep_delete removed_card.director
       Card.cache.soft.delete key
       removed_card
     end
 
-    def add name_or_card_or_attr, card_or_attr=nil
-      if card_or_attr
-        name = name_or_card_or_attr
-      else
-        card_or_attr = name_or_card_or_attr
-      end
-      case card_or_attr
-      when Hash
-        args = card_or_attr
-        if name
-          new_by_attributes name, args
-        elsif args[:name]
-          new_by_attributes args.delete(:name), args
-        else
-          args.each_pair do |key, val|
-            case val
-            when String then new_by_attributes key, content: val
-            when Card
-              val.name = absolutize_subcard_name key
-              new_by_card val
-            else new_by_attributes key, val
-            end
-          end
-        end
-      when Card
-        new_by_card card_or_attr
-      when Symbol, String
-        new_by_attributes card_or_attr, {}
-      end
-    end
-
-    def catch_up_to_stage stage_index
-      each_card do |subcard|
-        subcard.catch_up_to_stage stage_index
-      end
-    end
-
     def rename old_name, new_name
       return unless @keys.include? old_name.to_name.key
       @keys.delete old_name.to_name.key
@@ -122,7 +137,7 @@ class Card
       end
     end
 
-    alias each each_card
+    alias_method :each, :each_card
 
     def each_with_key
       @keys.each do |key|
@@ -154,32 +169,25 @@ class Card
       fetch_subcard name
     end
 
-    def add_child name, args
-      add prepend_plus(name), args
-    end
-
-    def remove_child name_or_card
-      if name_or_card.is_a? Card
-        remove name_or_card
-      else
-        absolute_name = @context_card.cardname.field_name(name_or_card)
-        if @keys.include? absolute_name.key
-          remove absolute_name
-        else
-          remove @context_card.cardname.relative_field_name(name_or_card)
-        end
-      end
-    end
-
-    alias add_field add_child
-    alias remove_field remove_child
-
     def present?
       @keys.present?
     end
 
     private
 
+    # Handles hash with several subcards
+    def multi_add args
+      args.each_pair do |key, val|
+        case val
+        when String then new_by_attributes key, content: val
+        when Card
+          val.name = absolutize_subcard_name key
+          new_by_card val
+        else new_by_attributes key, val
+        end
+      end
+    end
+
     def subcard_key name_or_card
       key = case name_or_card
             when Card
@@ -243,14 +251,14 @@ class Card
       if absolute_name.field_of?(@context_card.name) &&
          (absolute_name.parts.size - @context_card.cardname.parts.size) > 2
         left_card = new_by_attributes absolute_name.left
-        new_by_card left_card
+        new_by_card left_card, transact_in_stage: attributes[:transact_in_stage]
         left_card.new_by_attributes absolute_name, attributes
       else
-
         subcard_args = extract_subcard_args! attributes
+        t_i_s = attributes.delete(:transact_in_stage)
         card = Card.assign_or_initialize_by absolute_name.s, attributes,
                                             local_only: true
-        subcard = new_by_card card
+        subcard = new_by_card card, transact_in_stage: t_i_s
         card.subcards.add subcard_args
         subcard
       end
@@ -264,7 +272,7 @@ class Card
       end
     end
 
-    def new_by_card card
+    def new_by_card card, opts={}
       card.supercard = @context_card
       if !card.cardname.simple? &&
          card.cardname.field_of?(@context_card.cardname)
@@ -272,7 +280,7 @@ class Card
       end
       @keys << card.key
       Card.write_to_soft_cache card
-      card.director = @context_card.director.subdirectors.add(card)
+      card.director = @context_card.director.subdirectors.add(card, opts)
       card
     end
   end