Module: AfterCommit::ConnectionAdapters

Defined in:
lib/after_commit/connection_adapters.rb

Class Method Summary collapse

Class Method Details

.included(base) ⇒ Object 



3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/after_commit/connection_adapters.rb', line 3

def self.included(base)
  base.class_eval do
    # The commit_db_transaction method gets called when the outermost
    # transaction finishes and everything inside commits. We want to
    # override it so that after this happens, any records that were saved
    # or destroyed within this transaction now get their after_commit
    # callback fired.
    def commit_db_transaction_with_callback          
      begin
        trigger_before_commit_callbacks
        trigger_before_commit_on_create_callbacks
        trigger_before_commit_on_update_callbacks
        trigger_before_commit_on_destroy_callbacks
        
        commit_db_transaction_without_callback
        
        trigger_after_commit_callbacks
        trigger_after_commit_on_create_callbacks
        trigger_after_commit_on_update_callbacks
        trigger_after_commit_on_destroy_callbacks
      ensure
        AfterCommit.cleanup(self)
      end
    end 
    alias_method_chain :commit_db_transaction, :callback

    # In the event the transaction fails and rolls back, nothing inside
    # should recieve the after_commit callback, but do fire the after_rollback
    # callback for each record that failed to be committed.
    def rollback_db_transaction_with_callback
      begin
        trigger_before_rollback_callbacks
        rollback_db_transaction_without_callback
        trigger_after_rollback_callbacks
      ensure
        AfterCommit.cleanup(self)
      end
    end
    alias_method_chain :rollback_db_transaction, :callback
    
    protected
    
    def trigger_before_commit_callbacks
      AfterCommit.records(self).each do |record|
        record.send :callback, :before_commit
      end 
    end

    def trigger_before_commit_on_create_callbacks
      AfterCommit.created_records(self).each do |record|
        record.send :callback, :before_commit_on_create
      end 
    end
  
    def trigger_before_commit_on_update_callbacks
      AfterCommit.updated_records(self).each do |record|
        record.send :callback, :before_commit_on_update
      end 
    end
  
    def trigger_before_commit_on_destroy_callbacks
      AfterCommit.destroyed_records(self).each do |record|
        record.send :callback, :before_commit_on_destroy
      end 
    end

    def trigger_before_rollback_callbacks
      AfterCommit.records(self).each do |record|
        begin
          record.send :callback, :before_rollback
        rescue
          #
        end
      end 
    end

    def trigger_after_commit_callbacks
      # Trigger the after_commit callback for each of the committed
      # records.
      AfterCommit.records(self).each do |record|
        begin
          record.send :callback, :after_commit
        rescue
          #
        end
      end
    end
  
    def trigger_after_commit_on_create_callbacks
      # Trigger the after_commit_on_create callback for each of the committed
      # records.
      AfterCommit.created_records(self).each do |record|
        begin
          record.send :callback, :after_commit_on_create
        rescue
          #
        end
      end
    end
  
    def trigger_after_commit_on_update_callbacks
      # Trigger the after_commit_on_update callback for each of the committed
      # records.
      AfterCommit.updated_records(self).each do |record|
        begin
          record.send :callback, :after_commit_on_update
        rescue
          #
        end
      end
    end
  
    def trigger_after_commit_on_destroy_callbacks
      # Trigger the after_commit_on_destroy callback for each of the committed
      # records.
      AfterCommit.destroyed_records(self).each do |record|
        begin
          record.send :callback, :after_commit_on_destroy
        rescue
          #
        end
      end
    end

    def trigger_after_rollback_callbacks
      # Trigger the after_rollback callback for each of the committed
      # records.
      AfterCommit.records(self).each do |record|
        begin
          record.send :callback, :after_rollback
        rescue
        end
      end 
    end
  end 
end