purgatory 6.0.3 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2af3c60d4f7b1c69ed124e020216752e1078b24eafeea8af633ec91ab25c1a14
-  data.tar.gz: f731d8381bc1430a47999a0dfbef2acba055620c0410cebd92a1585495a027d6
+  metadata.gz: bab67dfd79b8b77fbb64611e198b1790b83d836b6066e9aba0d689f7580b2e74
+  data.tar.gz: 824ce4ac4ac15b91a46ff5c3a9a7e7e3261f7214f8f9b2514c2e33448ec6d08b
 SHA512:
-  metadata.gz: 7e42df9ba9269376d816c414c4dce1f7f115ab66598d2bf98965d4d8c53098f636819def2be40cc394cbe7a4efd995746206a3256f21e6c4ac40e9d0840143a1
-  data.tar.gz: c6b61df8ad74d59bc3d86e2e8d64634f406edaa81c7c91d809316f45096361f101400f4518aded25fae3b5a220d015a683a2b77ad8aa288bad7dfeece02b2dfb
+  metadata.gz: 45f9078948e5c4aed80c6faa396aaf5966bffd59e0842d75b206d0d1541c9464e119602178c5100bdc971f594571488823eec135736f001bd62403c84b3cde2e
+  data.tar.gz: 973ce5cff553f34aec2fd6f87d893ea69664ca9e0d44359af83128feea27faa642e5d6477ac235cdc179a6f65c7af68b440d3e76aef2dc6190efb064c5f13ddf

data/Gemfile

@@ -4,7 +4,7 @@ source "http://rubygems.org"
 #   gem "activesupport", ">= 2.3.5"
 
 group :test do
-  gem "activerecord", "~> 4.1"
+  gem "activerecord"
   gem "rspec"
   gem "sqlite3"
   gem "pry"

data/VERSION

@@ -1 +1 @@
-6.0.3
+6.1.0

data/lib/generators/purgatory/purgatory_generator.rb

@@ -9,7 +9,7 @@ class PurgatoryGenerator < Rails::Generators::Base
   end
 
   def self.next_migration_number(dirname)
-    if ActiveRecord::Base.timestamped_migrations
+    if ActiveRecord.timestamped_migrations
       Time.new.utc.strftime("%Y%m%d%H%M%S")
     else
       "%.3d" % (current_migration_number(dirname) + 1)
@@ -19,11 +19,15 @@ class PurgatoryGenerator < Rails::Generators::Base
   def create_migration_file
     ['create_purgatories', 'add_performable_method_to_purgatories'].each do |filename|
       unless self.class.migration_exists?("db/migrate", "#{filename}").present?
-        migration_template "#{filename}.rb", "db/migrate/#{filename}.rb"
+        migration_template "#{filename}.rb.erb", "db/migrate/#{filename}.rb"
       end
     end
   end
 
+  def migration_version
+    format("[%d.%d]", ActiveRecord::VERSION::MAJOR, ActiveRecord::VERSION::MINOR)
+  end
+
   def create_initializer_file
     create_file 'config/initializers/purgatory.rb', <<-eos
 PurgatoryModule.configure do |config|
@@ -33,4 +37,4 @@ end
 require 'purgatory/purgatory'
     eos
   end
-end
+end

data/lib/generators/purgatory/templates/{add_performable_method_to_purgatories.rb → add_performable_method_to_purgatories.rb.erb}

@@ -1,4 +1,4 @@
-class AddPerformableMethodToPurgatories < ActiveRecord::Migration
+class AddPerformableMethodToPurgatories < ActiveRecord::Migration<%= migration_version %>
   def change
     add_column :purgatories, :performable_method, :text
   end

data/lib/generators/purgatory/templates/{create_purgatories.rb → create_purgatories.rb.erb}

@@ -1,4 +1,4 @@
-class CreatePurgatories < ActiveRecord::Migration
+class CreatePurgatories < ActiveRecord::Migration<%= migration_version %>
   def change
     create_table :purgatories do |t|
       t.integer :soul_id

data/lib/purgatory/purgatory.rb

@@ -34,7 +34,12 @@ class Purgatory < ActiveRecord::Base
   end
 
   def sti_class
-    requested_changes['type'].try(:last)
+    read_attribute(:requested_changes)['type'].try(:last)
+  end
+
+  # Deserialize encrypted attributes on read
+  def requested_changes
+    alter(super, :deserialize)
   end
 
   def soul_with_changes
@@ -74,7 +79,20 @@ class Purgatory < ActiveRecord::Base
   private
 
   def store_changes
-    self.requested_changes = soul.changes
+    # Store the ciphertext of encrypted attributes
+    self.requested_changes = alter(soul.changes, :serialize)
+  end
+
+  def alter(changes, serialization_method)
+    encrypted_attr_changes = changes.slice(*soul.class.encrypted_attributes)
+    return changes if encrypted_attr_changes.empty?
+
+    altered = encrypted_attr_changes.each_with_object({}) do |(attribute_name, attr_changes), hsh|
+      type = soul.class.type_for_attribute(attribute_name)
+      hsh[attribute_name] = attr_changes.map { |value| type.send(serialization_method, value) }
+    end
+
+    changes.merge(altered)
   end
 
   def destroy_pending_with_same_soul

data/purgatory.gemspec

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
-# stub: purgatory 6.0.1 ruby lib
+# stub: purgatory 6.1.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "purgatory"
-  s.version = "6.0.3"
+  s.version = "6.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
@@ -18,16 +18,14 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
     ".rspec",
-    ".travis.yml",
     "Gemfile",
-    "Gemfile.lock",
     "LICENSE.txt",
     "README.markdown",
     "VERSION",
     "init.rb",
     "lib/generators/purgatory/purgatory_generator.rb",
-    "lib/generators/purgatory/templates/add_performable_method_to_purgatories.rb",
-    "lib/generators/purgatory/templates/create_purgatories.rb",
+    "lib/generators/purgatory/templates/add_performable_method_to_purgatories.rb.erb",
+    "lib/generators/purgatory/templates/create_purgatories.rb.erb",
     "lib/purgatory.rb",
     "lib/purgatory/active_record_descendant_attribute_accessors.rb",
     "lib/purgatory/attribute_accessor_fields.rb",

data/spec/purgatory_spec.rb

@@ -14,37 +14,48 @@ describe Purgatory do
         before {create_object_change_purgatory}
         
         it "should create and return pending Purgatory object" do
-          @purgatory.should be_present
-          @purgatory.should_not be_approved
-          @purgatory.should be_pending            
-          Purgatory.pending.count.should == 1
-          Purgatory.pending.first.should == @purgatory
-          Purgatory.approved.count.should be_zero            
+          expect(@purgatory).to be_present
+          expect(@purgatory).not_to be_approved
+          expect(@purgatory).to be_pending
+          expect(Purgatory.pending.count).to eq(1)
+          expect(Purgatory.pending.first).to eq(@purgatory)
+          expect(Purgatory.approved.count).to be_zero
         end
     
         it "should store the soul, requester and requested changes" do
-          @purgatory.soul.should == @widget
-          @purgatory.requester.should == user1
-          @purgatory.requested_changes['name'].first.should == 'foo'
-          @purgatory.requested_changes['name'].last.should == 'bar'
-          @purgatory.requested_changes['price'].first.should == 100
-          @purgatory.requested_changes['price'].last.should == 200
+          expect(@purgatory.soul).to eq(@widget)
+          expect(@purgatory.requester).to eq(user1)
+          expect(@purgatory.requested_changes['name'].first).to eq('foo')
+          expect(@purgatory.requested_changes['name'].last).to eq('bar')
+          expect(@purgatory.requested_changes['price'].first).to eq(100)
+          expect(@purgatory.requested_changes['price'].last).to eq(200)
         end
 
         it "should return soul with changes if requested" do
           soul_with_changes = @purgatory.soul_with_changes
-          soul_with_changes.name.should == 'bar'
-          soul_with_changes.price.should == 200
+          expect(soul_with_changes.name).to eq('bar')
+          expect(soul_with_changes.price).to eq(200)
         end
     
+        it "should store attributes encrypted, but decrypt on access" do
+          raw_value = @purgatory.read_attribute(:requested_changes)
+          expect(raw_value['token']).to match([a_string_matching(/\A\{/), a_string_matching(/\A\{/)])
+
+          processed_value = @purgatory.requested_changes
+          expect(processed_value['token']).to eq(['tk_123', 'tk_456'])
+
+          soul_with_changes = @purgatory.soul_with_changes
+          expect(soul_with_changes.token).to eq('tk_456')
+        end
+
         it "should not change the widget" do
-          @widget.name.should == 'foo'
-          @widget.price.should == 100
+          expect(@widget.name).to eq('foo')
+          expect(@widget.price).to eq(100)
         end
     
         it "should allow the widget to access its purgatories" do
-          @widget.purgatories.count.should == 1
-          @widget.purgatories.first.should == @purgatory
+          expect(@widget.purgatories.count).to eq(1)
+          expect(@widget.purgatories.first).to eq(@purgatory)
         end
 
         it "should delete old pending purgatories with same soul" do
@@ -53,26 +64,26 @@ describe Purgatory do
           widget2_purgatory = @widget2.purgatory! user1
           @widget.name = 'baz'
           new_purgatory = @widget.purgatory! user1
-          Purgatory.find_by_id(@purgatory.id).should be_nil
-          Purgatory.find_by_id(widget2_purgatory.id).should be_present
-          Purgatory.pending.count.should == 2
-          Purgatory.last.requested_changes['name'].should == ['foo', 'baz'] 
+          expect(Purgatory.find_by_id(@purgatory.id)).to be_nil
+          expect(Purgatory.find_by_id(widget2_purgatory.id)).to be_present
+          expect(Purgatory.pending.count).to eq(2)
+          expect(Purgatory.last.requested_changes['name']).to eq(['foo', 'baz'])
         end
 
         it "should fail to create purgatory if matching pending Purgatory exists and fail_if_matching_soul is passed in" do
           @widget.name = 'baz'
           new_purgatory = @widget.purgatory! user1, fail_if_matching_soul: true
-          new_purgatory.should be_nil
-          Purgatory.find_by_id(@purgatory.id).should be_present
-          Purgatory.pending.count.should == 1
+          expect(new_purgatory).to be_nil
+          expect(Purgatory.find_by_id(@purgatory.id)).to be_present
+          expect(Purgatory.pending.count).to eq(1)
         end
 
         it "should succeed to create purgatory if matching approved Purgatory exists and fail_if_matching_soul is passed in" do
           @purgatory.approve!
           @widget.name = 'baz'
           new_purgatory = @widget.purgatory! user1, fail_if_matching_soul: true
-          new_purgatory.should be_present
-          Purgatory.count.should == 2
+          expect(new_purgatory).to be_present
+          expect(Purgatory.count).to eq(2)
         end
       end
 
@@ -83,30 +94,30 @@ describe Purgatory do
         end
 
         it "should not change the object" do
-          @item.name.should == 'foo'
-          @item.price.should == 100
+          expect(@item.name).to eq('foo')
+          expect(@item.price).to eq(100)
         end
 
         it "should not save attr_accessor variable of object" do
-          @item.dante.should == nil
+          expect(@item.dante).to eq(nil)
         end
 
         it "should store the attr_accessor variables in the Purgatory object" do
-          @purgatory.attr_accessor_fields.should == { :@dante => "inferno" }
+          expect(@purgatory.attr_accessor_fields).to eq({ :@dante => "inferno" })
         end
 
         it "should return item with changed attr_accessor if requested" do
-          @purgatory.soul_with_changes.dante.should == 'inferno'
+          expect(@purgatory.soul_with_changes.dante).to eq('inferno')
         end
       end
     
       it "should not allow invalid changes to be put into purgatory" do
         widget = Widget.create name: 'foo'
         widget.name = ''
-        widget.purgatory!(user1).should be_nil      
+        expect(widget.purgatory!(user1)).to be_nil
         widget.reload
-        widget.name.should == 'foo'
-        Purgatory.count.should be_zero
+        expect(widget.name).to eq('foo')
+        expect(Purgatory.count).to be_zero
       end
     end
     
@@ -115,30 +126,41 @@ describe Purgatory do
         before {create_new_object_purgatory}
     
         it "should create and return pending Purgatory object" do
-          @purgatory.should be_present
-          @purgatory.should_not be_approved
-          @purgatory.should be_pending            
-          Purgatory.pending.count.should == 1
-          Purgatory.pending.first.should == @purgatory
-          Purgatory.approved.count.should be_zero            
+          expect(@purgatory).to be_present
+          expect(@purgatory).not_to be_approved
+          expect(@purgatory).to be_pending
+          expect(Purgatory.pending.count).to eq(1)
+          expect(Purgatory.pending.first).to eq(@purgatory)
+          expect(Purgatory.approved.count).to be_zero
         end
         
         it "should return the soul as a new instance of the purgatoried class" do
           widget = @purgatory.soul
-          widget.class.should == Widget
-          widget.should be_new_record
+          expect(widget.class).to eq(Widget)
+          expect(widget).to be_new_record
+        end
+
+        it "should store attributes encrypted, but decrypt on access" do
+          raw_value = @purgatory.read_attribute(:requested_changes)
+          expect(raw_value['token']).to match([nil, a_string_matching(/\A\{/)])
+
+          processed_value = @purgatory.requested_changes
+          expect(processed_value['token']).to eq([nil, 'tk_123'])
+
+          soul_with_changes = @purgatory.soul_with_changes
+          expect(soul_with_changes.token).to eq('tk_123')
         end
         
         it "should store the requester and requested changes" do
-          @purgatory.requester.should == user1
-          @purgatory.requested_changes['name'].first.should == nil
-          @purgatory.requested_changes['name'].last.should == 'foo'
-          @purgatory.requested_changes['price'].first.should == nil
-          @purgatory.requested_changes['price'].last.should == 100
+          expect(@purgatory.requester).to eq(user1)
+          expect(@purgatory.requested_changes['name'].first).to eq(nil)
+          expect(@purgatory.requested_changes['name'].last).to eq('foo')
+          expect(@purgatory.requested_changes['price'].first).to eq(nil)
+          expect(@purgatory.requested_changes['price'].last).to eq(100)
         end
     
         it "should not create a widget" do
-          Widget.count.should be_zero
+          expect(Widget.count).to be_zero
         end
       end
 
@@ -146,28 +168,28 @@ describe Purgatory do
         before {create_new_object_purgatory_with_sti}
     
         it "should create and return pending Purgatory object" do
-          @purgatory.should be_present
-          @purgatory.should_not be_approved
-          @purgatory.should be_pending            
-          Purgatory.pending.count.should == 1
-          Purgatory.pending.first.should == @purgatory
-          Purgatory.approved.count.should be_zero            
+          expect(@purgatory).to be_present
+          expect(@purgatory).not_to be_approved
+          expect(@purgatory).to be_pending
+          expect(Purgatory.pending.count).to eq(1)
+          expect(Purgatory.pending.first).to eq(@purgatory)
+          expect(Purgatory.approved.count).to be_zero
         end
         
         it "should return the soul as a new instance of the purgatoried class" do
           dog = @purgatory.soul
-          dog.class.should == Dog
-          dog.should be_new_record
+          expect(dog.class).to eq(Dog)
+          expect(dog).to be_new_record
         end
         
         it "should store the requester and requested changes" do
-          @purgatory.requester.should == user1
-          @purgatory.requested_changes['name'].first.should == nil
-          @purgatory.requested_changes['name'].last.should == 'doggy'
+          expect(@purgatory.requester).to eq(user1)
+          expect(@purgatory.requested_changes['name'].first).to eq(nil)
+          expect(@purgatory.requested_changes['name'].last).to eq('doggy')
         end
     
         it "should not create a dog" do
-          Dog.count.should be_zero
+          expect(Dog.count).to be_zero
         end
       end
 
@@ -175,11 +197,11 @@ describe Purgatory do
         before {create_object_change_purgatory_with_sti}
 
         it "should delete old purgatory on object if new one is created" do
-          Purgatory.count.should == 1
+          expect(Purgatory.count).to eq(1)
           @dog.name = 'fluffy'
           @dog.purgatory!(user1)
-          Purgatory.last.requested_changes['name'].last.should == 'fluffy'
-          Purgatory.count.should == 1
+          expect(Purgatory.last.requested_changes['name'].last).to eq('fluffy')
+          expect(Purgatory.count).to eq(1)
         end
       end
     
@@ -189,23 +211,23 @@ describe Purgatory do
         end
 
         it "should store the attr_accessor variables in the Purgatory object" do
-          @purgatory.attr_accessor_fields.should == { :@dante => "inferno" }
+          expect(@purgatory.attr_accessor_fields).to eq({ :@dante => "inferno" })
         end
 
         it "should store the requester and requested changes" do
-          @purgatory.requester.should == user1
-          @purgatory.requested_changes['name'].first.should == nil
-          @purgatory.requested_changes['name'].last.should == 'foo'
-          @purgatory.requested_changes['price'].first.should == nil
-          @purgatory.requested_changes['price'].last.should == 100
+          expect(@purgatory.requester).to eq(user1)
+          expect(@purgatory.requested_changes['name'].first).to eq(nil)
+          expect(@purgatory.requested_changes['name'].last).to eq('foo')
+          expect(@purgatory.requested_changes['price'].first).to eq(nil)
+          expect(@purgatory.requested_changes['price'].last).to eq(100)
         end
       end
 
       it "should not allow invalid object creation to be put into purgatory" do
         widget = Widget.new name: ''
-        widget.purgatory!(user1).should be_nil      
-        Purgatory.count.should be_zero
-        Widget.count.should be_zero
+        expect(widget.purgatory!(user1)).to be_nil
+        expect(Purgatory.count).to be_zero
+        expect(Widget.count).to be_zero
       end
     end
   end
@@ -214,50 +236,50 @@ describe Purgatory do
     context "approving object change purgatory" do
       before do
         create_object_change_purgatory
-        @purgatory.approve!(user2).should be true
+        expect(@purgatory.approve!(user2)).to be true
         @widget.reload
       end
       
       it "should apply the changes" do
-        @widget.name.should == 'bar'
-        @widget.price.should == 200
+        expect(@widget.name).to eq('bar')
+        expect(@widget.price).to eq(200)
       end
       
       it "should mark purgatory as approved and store approver" do
-        @purgatory.approver.should == user2
-        @purgatory.should be_approved
-        @purgatory.should_not be_pending            
-        Purgatory.pending.count.should be_zero
-        Purgatory.approved.count.should == 1
-        Purgatory.approved.first.should == @purgatory
+        expect(@purgatory.approver).to eq(user2)
+        expect(@purgatory).to be_approved
+        expect(@purgatory).not_to be_pending
+        expect(Purgatory.pending.count).to be_zero
+        expect(Purgatory.approved.count).to eq(1)
+        expect(Purgatory.approved.first).to eq(@purgatory)
       end
       
       it "should fail if you try to approve again" do
-        @purgatory.approve!(user2).should be false
+        expect(@purgatory.approve!(user2)).to be false
       end
     end
 
     context "approving a performable method that returns false" do
       before do
         create_method_call_purgatory
-        @purgatory.soul.stub(:rename).and_return(false)
+        allow(@purgatory.soul).to receive(:rename).and_return(false)
       end
 
       it "should store the soul, requester and performable_method" do
-        @purgatory.soul.should == @widget
-        @purgatory.requester.should == user1
-        @purgatory.performable_method[:method].should == :rename
-        @purgatory.performable_method[:args].should == ['bar']
+        expect(@purgatory.soul).to eq(@widget)
+        expect(@purgatory.requester).to eq(user1)
+        expect(@purgatory.performable_method[:method]).to eq(:rename)
+        expect(@purgatory.performable_method[:args]).to eq(['bar'])
       end
 
       it "should fail when performable method returns false" do
-        @purgatory.approve!(user2).should be false
+        expect(@purgatory.approve!(user2)).to be false
       end
 
       it "it should not be approved" do
-        @purgatory.should be_present
-        @purgatory.should_not be_approved
-        @purgatory.should be_pending
+        expect(@purgatory).to be_present
+        expect(@purgatory).not_to be_approved
+        expect(@purgatory).to be_pending
       end
     end
 
@@ -269,74 +291,74 @@ describe Purgatory do
       end
 
       it "should apply the changes" do
-        @item.name.should == 'bar'
-        @item.price.should == 200
+        expect(@item.name).to eq('bar')
+        expect(@item.price).to eq(200)
       end
 
       it "should apply changes that depend on attr_accessor instance_variable" do
-        @item.original_name.should == "inferno"
+        expect(@item.original_name).to eq("inferno")
       end
       
       it "should mark purgatory as approved and store approver" do
-        @purgatory.approver.should == user2
-        @purgatory.should be_approved
-        @purgatory.should_not be_pending            
-        Purgatory.pending.count.should be_zero
-        Purgatory.approved.count.should == 1
-        Purgatory.approved.first.should == @purgatory
+        expect(@purgatory.approver).to eq(user2)
+        expect(@purgatory).to be_approved
+        expect(@purgatory).not_to be_pending
+        expect(Purgatory.pending.count).to be_zero
+        expect(Purgatory.approved.count).to eq(1)
+        expect(Purgatory.approved.first).to eq(@purgatory)
       end
       
       it "should fail if you try to approve again" do
-        @purgatory.approve!(user2).should be false
+        expect(@purgatory.approve!(user2)).to be false
       end
     end
     
     context "approving new object creation" do
       before do
         create_new_object_purgatory
-        @purgatory.approve!(user2).should be true
+        expect(@purgatory.approve!(user2)).to be true
       end
       
       it "should create the new object and apply any callbacks" do
-        Widget.count.should == 1
+        expect(Widget.count).to eq(1)
         widget = Widget.first
-        widget.name.should == 'foo'
-        widget.price.should == 100
-        widget.original_name.should == 'foo'
+        expect(widget.name).to eq('foo')
+        expect(widget.price).to eq(100)
+        expect(widget.original_name).to eq('foo')
       end
       
       it "should mark purgatory as approved and store approver" do
-        @purgatory.approver.should == user2
-        @purgatory.should be_approved
-        @purgatory.should_not be_pending            
-        Purgatory.pending.count.should be_zero
-        Purgatory.approved.count.should == 1
-        Purgatory.approved.first.should == @purgatory
+        expect(@purgatory.approver).to eq(user2)
+        expect(@purgatory).to be_approved
+        expect(@purgatory).not_to be_pending
+        expect(Purgatory.pending.count).to be_zero
+        expect(Purgatory.approved.count).to eq(1)
+        expect(Purgatory.approved.first).to eq(@purgatory)
       end
 
       it "should store the id of the newly created object so the purgatory can be accessed through the object" do
         widget = Widget.first
-        widget.purgatories.count.should == 1
-        widget.purgatories.first.should == @purgatory 
+        expect(widget.purgatories.count).to eq(1)
+        expect(widget.purgatories.first).to eq(@purgatory)
       end
       
       it "should fail if you try to approve again" do
-        @purgatory.approve!(user2).should be false
+        expect(@purgatory.approve!(user2)).to be false
       end
     end
 
     context "approving new object creation using STI" do
       before do
         create_new_object_purgatory_with_sti
-        @purgatory.approve!(user2).should be true
+        expect(@purgatory.approve!(user2)).to be true
       end
       
       it "should create the new object and apply any callbacks" do
-        Dog.count.should == 1
+        expect(Dog.count).to eq(1)
         dog = Dog.first
-        dog.name.should == 'doggy'
-        dog.original_name.should == 'doggy'
-        dog.price.should == Dog::DEFAULT_PRICE
+        expect(dog.name).to eq('doggy')
+        expect(dog.original_name).to eq('doggy')
+        expect(dog.price).to eq(Dog::DEFAULT_PRICE)
       end
     end
 
@@ -347,37 +369,37 @@ describe Purgatory do
       end
 
       it "should create the new object and apply any callbacks" do
-        Item.count.should == 1
+        expect(Item.count).to eq(1)
         item = Item.first
-        item.name.should == 'foo'
-        item.price.should == 100
+        expect(item.name).to eq('foo')
+        expect(item.price).to eq(100)
       end
 
       it "should apply changes that depend on attr_accessor instance_variable" do
-        Item.first.original_name.should == 'inferno'
+        expect(Item.first.original_name).to eq('inferno')
       end
       
       it "should mark purgatory as approved and store approver" do
-        @purgatory.approver.should == user2
-        @purgatory.should be_approved
-        @purgatory.should_not be_pending            
-        Purgatory.pending.count.should be_zero
-        Purgatory.approved.count.should == 1
-        Purgatory.approved.first.should == @purgatory
+        expect(@purgatory.approver).to eq(user2)
+        expect(@purgatory).to be_approved
+        expect(@purgatory).not_to be_pending
+        expect(Purgatory.pending.count).to be_zero
+        expect(Purgatory.approved.count).to eq(1)
+        expect(Purgatory.approved.first).to eq(@purgatory)
       end
       
       it "should fail if you try to approve again" do
-        @purgatory.approve!(user2).should be false
+        expect(@purgatory.approve!(user2)).to be false
       end
     end
 
     context "approving method call purgatory" do
       before{create_method_call_purgatory}
       it "should call the method" do
-        @widget.name.should == 'foo'
+        expect(@widget.name).to eq('foo')
         @purgatory.approve!
         @widget.reload
-        @widget.name.should == 'bar'
+        expect(@widget.name).to eq('bar')
       end
     end
   end
@@ -393,7 +415,7 @@ describe Purgatory do
         it "should not store attr_accessors" do
           obj = @klass.new name: 'foo', price: 100, dante: "inferno"
           purgatory = obj.purgatory! user1
-          purgatory.attr_accessor_fields.should == {}
+          expect(purgatory.attr_accessor_fields).to eq({})
         end
       end
 
@@ -407,7 +429,7 @@ describe Purgatory do
           it "should work" do
             obj = @klass.new name: 'foo', price: 100, dante: "inferno"
             purgatory = obj.purgatory! user1
-            purgatory.attr_accessor_fields.should == { :@dante => "inferno" }
+            expect(purgatory.attr_accessor_fields).to eq({ :@dante => "inferno" })
           end
         end
 
@@ -426,15 +448,15 @@ describe Purgatory do
           it "should work" do
             obj = @klass.new name: 'foo', price: 100, dante: "inferno"
             purgatory = obj.purgatory! user1
-            purgatory.attr_accessor_fields.should == { :@dante => "inferno" }
+            expect(purgatory.attr_accessor_fields).to eq({ :@dante => "inferno" })
 
             obj = @klass_2.new name: 'foo', price: 100, minos: "inferno"
             purgatory = obj.purgatory! user1
-            purgatory.attr_accessor_fields.should == { :@minos => "inferno" }
+            expect(purgatory.attr_accessor_fields).to eq({ :@minos => "inferno" })
 
             obj = @klass_3.new name: 'foo', price: 100
             purgatory = obj.purgatory! user1
-            purgatory.attr_accessor_fields.should == {}
+            expect(purgatory.attr_accessor_fields).to eq({})
           end
         end
       end
@@ -448,7 +470,7 @@ describe Purgatory do
       end
 
       it "should not contain any thing" do
-        AttributeAccessorFields.determine_attr_accessor_fields(@obj).should == {}
+        expect(AttributeAccessorFields.determine_attr_accessor_fields(@obj)).to eq({})
       end
     end
 
@@ -466,7 +488,7 @@ describe Purgatory do
 
       context "local_attributes is empty" do
         it "should not contain any attr_accessor values" do
-          AttributeAccessorFields.determine_attr_accessor_fields(@obj).should == {}
+          expect(AttributeAccessorFields.determine_attr_accessor_fields(@obj)).to eq({})
         end
       end
 
@@ -477,7 +499,7 @@ describe Purgatory do
           end
 
           it "should only contain attr_accessors specified in array" do
-            AttributeAccessorFields.determine_attr_accessor_fields(@obj).should == { :@dante => "inferno" }
+            expect(AttributeAccessorFields.determine_attr_accessor_fields(@obj)).to eq({ :@dante => "inferno" })
           end
         end
         context "array size is more than 1" do
@@ -486,7 +508,7 @@ describe Purgatory do
           end
 
           it "should only contain attr_accessors specified in array" do
-            AttributeAccessorFields.determine_attr_accessor_fields(@obj).should == { :@dante => "inferno", :@minos => "inferno" }
+            expect(AttributeAccessorFields.determine_attr_accessor_fields(@obj)).to eq({ :@dante => "inferno", :@minos => "inferno" })
           end
 
         end
@@ -498,7 +520,7 @@ describe Purgatory do
         end
 
         it "should automatically determine attr_accessor values that doesnt include ones belonging to AR::Base and its ancestors, and then store these values" do
-          AttributeAccessorFields.determine_attr_accessor_fields(@obj).should == { :@dante => "inferno", :@minos => "inferno", :@charon => "inferno" }
+          expect(AttributeAccessorFields.determine_attr_accessor_fields(@obj)).to eq({ :@dante => "inferno", :@minos => "inferno", :@charon => "inferno" })
         end
       end
     end
@@ -519,7 +541,7 @@ describe Purgatory do
       end
 
       it "should not include instance_variables that belong to ancestor of ActiveRecord::Base" do
-        ActiveRecordDescendantAttributeAccessors.attr_accessor_instance_variables(@widget).should == []
+        expect(ActiveRecordDescendantAttributeAccessors.attr_accessor_instance_variables(@widget)).to eq([])
       end
     end
 
@@ -536,7 +558,7 @@ describe Purgatory do
       end
 
       it "should not include instance_variables that belong to ActiveRecord::Base" do
-        ActiveRecordDescendantAttributeAccessors.attr_accessor_instance_variables(@widget).should == []
+        expect(ActiveRecordDescendantAttributeAccessors.attr_accessor_instance_variables(@widget)).to eq([])
       end
     end
 
@@ -552,7 +574,7 @@ describe Purgatory do
         end
         
         it "should include instance_variables from attr_accessors that belong to descendant of ActiveRecord::Base" do
-          ActiveRecordDescendantAttributeAccessors.attr_accessor_instance_variables(@widget).should == [:@dante]
+          expect(ActiveRecordDescendantAttributeAccessors.attr_accessor_instance_variables(@widget)).to eq([:@dante])
         end
       end
 
@@ -568,7 +590,7 @@ describe Purgatory do
         end
         
         it "should include instance_variables from attr_accessors that belong to descendant of ActiveRecord::Base" do
-          ActiveRecordDescendantAttributeAccessors.attr_accessor_instance_variables(@widget).should == [:@dante]
+          expect(ActiveRecordDescendantAttributeAccessors.attr_accessor_instance_variables(@widget)).to eq([:@dante])
         end
       end
 
@@ -582,7 +604,7 @@ describe Purgatory do
         end
         
         it "should include instance_variables from attr_accessors that belong to descendant of ActiveRecord::Base" do
-          ActiveRecordDescendantAttributeAccessors.attr_accessor_instance_variables(@widget).should == [:@dante]
+          expect(ActiveRecordDescendantAttributeAccessors.attr_accessor_instance_variables(@widget)).to eq([:@dante])
         end
       end
     end
@@ -592,19 +614,19 @@ describe Purgatory do
           before {create_method_call_purgatory}
           
           it "should create and return pending Purgatory object" do
-            @purgatory.should be_present
-            @purgatory.should_not be_approved
-            @purgatory.should be_pending            
-            Purgatory.pending.count.should == 1
-            Purgatory.pending.first.should == @purgatory
-            Purgatory.approved.count.should be_zero            
+            expect(@purgatory).to be_present
+            expect(@purgatory).not_to be_approved
+            expect(@purgatory).to be_pending
+            expect(Purgatory.pending.count).to eq(1)
+            expect(Purgatory.pending.first).to eq(@purgatory)
+            expect(Purgatory.approved.count).to be_zero
           end
       
           it "should store the soul, requester and performable_method" do
-            @purgatory.soul.should == @widget
-            @purgatory.requester.should == user1
-            @purgatory.performable_method[:method].should == :rename
-            @purgatory.performable_method[:args].should == ['bar']
+            expect(@purgatory.soul).to eq(@widget)
+            expect(@purgatory.requester).to eq(user1)
+            expect(@purgatory.performable_method[:method]).to eq(:rename)
+            expect(@purgatory.performable_method[:args]).to eq(['bar'])
           end
           
           it "should delete old pending purgatories with same soul" do
@@ -613,26 +635,26 @@ describe Purgatory do
             widget2_purgatory = @widget2.purgatize(user1).rename('bar')
             @widget.name = 'baz'
             new_purgatory = @widget.purgatize(user1).rename('bar')
-            Purgatory.find_by_id(@purgatory.id).should be_nil
-            Purgatory.find_by_id(widget2_purgatory.id).should be_present
-            Purgatory.pending.count.should == 2
-            Purgatory.last.requested_changes['name'].should == ['foo', 'baz'] 
+            expect(Purgatory.find_by_id(@purgatory.id)).to be_nil
+            expect(Purgatory.find_by_id(widget2_purgatory.id)).to be_present
+            expect(Purgatory.pending.count).to eq(2)
+            expect(Purgatory.last.requested_changes['name']).to eq(['foo', 'baz'])
           end
 
           it "should fail to create purgatory if matching pending Purgatory exists and fail_if_matching_soul is passed in" do
             @widget.name = 'baz'
             new_purgatory = @widget.purgatize(user1, fail_if_matching_soul: true).rename('bar')
-            new_purgatory.should be_nil
-            Purgatory.find_by_id(@purgatory.id).should be_present
-            Purgatory.pending.count.should == 1
+            expect(new_purgatory).to be_nil
+            expect(Purgatory.find_by_id(@purgatory.id)).to be_present
+            expect(Purgatory.pending.count).to eq(1)
           end
 
           it "should succeed to create purgatory if matching approved Purgatory exists and fail_if_matching_soul is passed in" do
             @purgatory.approve!
             @widget.name = 'baz'
             new_purgatory = @widget.purgatize(user1, fail_if_matching_soul: true).rename('bar')
-            new_purgatory.should be_present
-            Purgatory.count.should == 2
+            expect(new_purgatory).to be_present
+            expect(Purgatory.count).to eq(2)
           end
         end
       end
@@ -642,9 +664,10 @@ describe Purgatory do
   private
   
   def create_object_change_purgatory
-    @widget = Widget.create name: 'foo', price: 100
+    @widget = Widget.create name: 'foo', price: 100, token: 'tk_123'
     @widget.name = 'bar'
     @widget.price = 200
+    @widget.token = 'tk_456'
     purgatory = @widget.purgatory! user1
     @purgatory = Purgatory.find(purgatory.id)
     @widget.reload
@@ -658,7 +681,7 @@ describe Purgatory do
   end
 
   def create_new_object_purgatory
-    widget = Widget.new name: 'foo', price: 100
+    widget = Widget.new name: 'foo', price: 100, token: 'tk_123'
     purgatory = widget.purgatory! user1
     @purgatory = Purgatory.find(purgatory.id)
   end

data/spec/support/active_record.rb

@@ -1,12 +1,19 @@
 require 'active_record'
-require 'generators/purgatory/templates/create_purgatories'
-require 'generators/purgatory/templates/add_performable_method_to_purgatories'
 require 'purgatory/purgatory_module'
 
 ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
 
+ActiveRecord.use_yaml_unsafe_load = true
+
+ActiveRecord::Encryption.configure(
+  primary_key: 'abc123',
+  deterministic_key: 'def456',
+  key_derivation_salt: 'ghi789',
+)
+
 ActiveRecord::Migration.create_table :widgets do |t|
   t.string :name
+  t.string :token, limit: 510
   t.integer :price
   t.string :original_name 
   t.timestamps
@@ -31,8 +38,21 @@ ActiveRecord::Migration.create_table :items do |t|
   t.timestamps
 end
 
-CreatePurgatories.new.migrate(:up)
-AddPerformableMethodToPurgatories.new.migrate(:up)
+ActiveRecord::Migration.create_table :purgatories do |t|
+    t.integer :soul_id
+    t.string :soul_type
+    t.integer :requester_id
+    t.integer :approver_id
+    t.datetime :approved_at
+    t.text :requested_changes
+    t.text :attr_accessor_fields
+    t.text :performable_method
+    t.timestamps
+
+    t.index [:soul_id, :soul_type]
+    t.index :requester_id
+    t.index :approver_id
+end
 
 PurgatoryModule.configure do |config|
   config.user_class_name = 'User'

data/spec/support/widget.rb

@@ -5,8 +5,10 @@ class Widget < ActiveRecord::Base
   validates :name, presence: true
   before_create :set_original_name
   
+  encrypts :token
+
   def rename(new_name)
-    self.update_attributes(name: new_name)
+    self.update(name: new_name)
   end
 
   private
@@ -14,4 +16,4 @@ class Widget < ActiveRecord::Base
   def set_original_name
     self.original_name = name
   end
-end
+end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: purgatory
 version: !ruby/object:Gem::Version
-  version: 6.0.3
+  version: 6.1.0
 platform: ruby
 authors:
 - Elan Dubrofsky
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
 date: 2017-08-24 00:00:00.000000000 Z
@@ -21,16 +21,14 @@ extra_rdoc_files:
 files:
 - ".document"
 - ".rspec"
-- ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.markdown
 - VERSION
 - init.rb
 - lib/generators/purgatory/purgatory_generator.rb
-- lib/generators/purgatory/templates/add_performable_method_to_purgatories.rb
-- lib/generators/purgatory/templates/create_purgatories.rb
+- lib/generators/purgatory/templates/add_performable_method_to_purgatories.rb.erb
+- lib/generators/purgatory/templates/create_purgatories.rb.erb
 - lib/purgatory.rb
 - lib/purgatory/active_record_descendant_attribute_accessors.rb
 - lib/purgatory/attribute_accessor_fields.rb
@@ -47,7 +45,7 @@ homepage: http://github.com/financeit/purgatory
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -62,8 +60,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.15
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Allow changes to a model to be put in purgatory until they are approved
 test_files: []

data/.travis.yml

@@ -1,10 +0,0 @@
-language: ruby
-rvm:
-  - 2.2.10
-  - 2.3.8
-  - 2.4.9
-  - 2.5.7
-  - 2.6.5
-cache:
-  bundler: true
-script: bundle exec rspec

data/Gemfile.lock

@@ -1,53 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activemodel (4.2.11.1)
-      activesupport (= 4.2.11.1)
-      builder (~> 3.1)
-    activerecord (4.2.11.1)
-      activemodel (= 4.2.11.1)
-      activesupport (= 4.2.11.1)
-      arel (~> 6.0)
-    activesupport (4.2.11.1)
-      i18n (~> 0.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
-      tzinfo (~> 1.1)
-    arel (6.0.4)
-    builder (3.2.4)
-    coderay (1.1.0)
-    concurrent-ruby (1.1.6)
-    diff-lcs (1.2.5)
-    i18n (0.9.5)
-      concurrent-ruby (~> 1.0)
-    method_source (0.8.2)
-    minitest (5.14.0)
-    pry (0.9.12.4)
-      coderay (~> 1.0)
-      method_source (~> 0.8)
-      slop (~> 3.4)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.7)
-    rspec-expectations (2.14.4)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.4)
-    slop (3.4.7)
-    sqlite3 (1.3.13)
-    thread_safe (0.3.6)
-    tzinfo (1.2.6)
-      thread_safe (~> 0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activerecord (~> 4.1)
-  pry
-  rspec
-  sqlite3
-
-BUNDLED WITH
-   1.17.3