paper_trail 4.2.0 → 5.0.0

data/test/unit/protected_attrs_test.rb

@@ -1,47 +1,51 @@
-require 'test_helper'
+require "test_helper"
 
 class ProtectedAttrsTest < ActiveSupport::TestCase
   subject { ProtectedWidget.new }
 
-  if ActiveRecord::VERSION::MAJOR < 4 # these ActiveModel matchers (provided by shoulda-matchers) only work for Rails 3
+  # These ActiveModel matchers (provided by shoulda-matchers) only work for
+  # Rails 3.
+  if ActiveRecord::VERSION::MAJOR < 4
     accessible_attrs = ProtectedWidget.accessible_attributes.to_a
     accessible_attrs.each do |attr_name|
       should allow_mass_assignment_of(attr_name.to_sym)
     end
-    ProtectedWidget.column_names.reject { |column_name| accessible_attrs.include?(column_name) }.each do |attr_name|
+    inaccessible = ProtectedWidget.
+      column_names.
+      reject { |column_name| accessible_attrs.include?(column_name) }
+    inaccessible.each do |attr_name|
       should_not allow_mass_assignment_of(attr_name.to_sym)
     end
   end
 
-  context 'A model with `attr_accessible` created' do
+  context "A model with `attr_accessible` created" do
     setup do
-      @widget = ProtectedWidget.create! :name => 'Henry'
+      @widget = ProtectedWidget.create! name: "Henry"
       @initial_attributes = @widget.attributes
     end
 
-    should 'be `nil` in its previous version' do
+    should "be `nil` in its previous version" do
       assert_nil @widget.previous_version
     end
 
-    context 'which is then updated' do
+    context "which is then updated" do
       setup do
-        @widget.assign_attributes(:name => 'Jeff', :a_text => 'Short statement')
+        @widget.assign_attributes(name: "Jeff", a_text: "Short statement")
         @widget.an_integer = 42
         @widget.save!
       end
 
-      should 'not be `nil` in its previous version' do
+      should "not be `nil` in its previous version" do
         assert_not_nil @widget.previous_version
       end
 
-      should 'the previous version should contain right attributes' do
+      should "the previous version should contain right attributes" do
         # For some reason this test seems to be broken in JRuby 1.9 mode in the
         # test env even though it works in the console. WTF?
-        unless ActiveRecord::VERSION::MAJOR >= 4 && defined?(JRUBY_VERSION) && RUBY_VERSION >= '1.9'
+        unless ActiveRecord::VERSION::MAJOR >= 4 && defined?(JRUBY_VERSION)
           assert_attributes_equal @widget.previous_version.attributes, @initial_attributes
         end
       end
     end
-
   end
 end

data/test/unit/serializer_test.rb

@@ -1,36 +1,34 @@
-require 'test_helper'
-require 'custom_json_serializer'
+require "test_helper"
+require "custom_json_serializer"
 
 class SerializerTest < ActiveSupport::TestCase
-
-  context 'YAML Serializer' do
+  context "YAML Serializer" do
     setup do
       Fluxor.instance_eval <<-END
         has_paper_trail
       END
 
-      @fluxor = Fluxor.create :name => 'Some text.'
-      @original_fluxor_attributes = @fluxor.send(:attributes_before_change) # this is exactly what PaperTrail serializes
-      @fluxor.update_attributes :name => 'Some more text.'
+      @fluxor = Fluxor.create name: "Some text."
+
+      # this is exactly what PaperTrail serializes
+      @original_fluxor_attributes = @fluxor.send(:attributes_before_change)
+
+      @fluxor.update_attributes name: "Some more text."
     end
 
-    should 'work with the default `YAML` serializer' do
+    should "work with the default `YAML` serializer" do
       # Normal behaviour
       assert_equal 2, @fluxor.versions.length
       assert_nil @fluxor.versions[0].reify
-      assert_equal 'Some text.', @fluxor.versions[1].reify.name
+      assert_equal "Some text.", @fluxor.versions[1].reify.name
 
       # Check values are stored as `YAML`.
       assert_equal @original_fluxor_attributes, YAML.load(@fluxor.versions[1].object)
-      # This test can't consistently pass in Ruby1.8 because hashes do no preserve order, which means the order of the
-      # attributes in the `YAML` can't be ensured.
-      if RUBY_VERSION >= '1.9'
-        assert_equal YAML.dump(@original_fluxor_attributes), @fluxor.versions[1].object
-      end
+      assert_equal YAML.dump(@original_fluxor_attributes), @fluxor.versions[1].object
     end
   end
 
-  context 'JSON Serializer' do
+  context "JSON Serializer" do
     setup do
       PaperTrail.configure do |config|
         config.serializer = PaperTrail::Serializers::JSON
@@ -40,39 +38,40 @@ class SerializerTest < ActiveSupport::TestCase
         has_paper_trail
       END
 
-      @fluxor = Fluxor.create :name => 'Some text.'
-      @original_fluxor_attributes = @fluxor.send(:attributes_before_change) # this is exactly what PaperTrail serializes
-      @fluxor.update_attributes :name => 'Some more text.'
+      @fluxor = Fluxor.create name: "Some text."
+
+      # this is exactly what PaperTrail serializes
+      @original_fluxor_attributes = @fluxor.send(:attributes_before_change)
+
+      @fluxor.update_attributes name: "Some more text."
     end
 
     teardown do
       PaperTrail.config.serializer = PaperTrail::Serializers::YAML
     end
 
-    should 'reify with JSON serializer' do
+    should "reify with JSON serializer" do
       # Normal behaviour
       assert_equal 2, @fluxor.versions.length
       assert_nil @fluxor.versions[0].reify
-      assert_equal 'Some text.', @fluxor.versions[1].reify.name
+      assert_equal "Some text.", @fluxor.versions[1].reify.name
 
       # Check values are stored as JSON.
-      assert_equal @original_fluxor_attributes, ActiveSupport::JSON.decode(@fluxor.versions[1].object)
-      # This test can't consistently pass in Ruby1.8 because hashes do no preserve order, which means the order of the
-      # attributes in the JSON can't be ensured.
-      if RUBY_VERSION >= '1.9'
-        assert_equal ActiveSupport::JSON.encode(@original_fluxor_attributes), @fluxor.versions[1].object
-      end
+      assert_equal @original_fluxor_attributes,
+        ActiveSupport::JSON.decode(@fluxor.versions[1].object)
+      assert_equal ActiveSupport::JSON.encode(@original_fluxor_attributes),
+        @fluxor.versions[1].object
     end
 
-    should 'store object_changes' do
-      initial_changeset = {"name" => [nil, "Some text."], "id" => [nil, @fluxor.id]}
-      second_changeset =  {"name"=>["Some text.", "Some more text."]}
+    should "store object_changes" do
+      initial_changeset = { "name" => [nil, "Some text."], "id" => [nil, @fluxor.id] }
+      second_changeset = { "name" => ["Some text.", "Some more text."] }
       assert_equal initial_changeset, @fluxor.versions[0].changeset
       assert_equal second_changeset,  @fluxor.versions[1].changeset
     end
   end
 
-  context 'Custom Serializer' do
+  context "Custom Serializer" do
     setup do
       PaperTrail.configure do |config|
         config.serializer = CustomJsonSerializer
@@ -83,35 +82,37 @@ class SerializerTest < ActiveSupport::TestCase
       END
 
       @fluxor = Fluxor.create
-      @original_fluxor_attributes = @fluxor.send(:attributes_before_change).reject { |k,v| v.nil? } # this is exactly what PaperTrail serializes
-      @fluxor.update_attributes :name => 'Some more text.'
+
+      # this is exactly what PaperTrail serializes
+      @original_fluxor_attributes = @fluxor.
+        send(:attributes_before_change).
+        reject { |_k, v| v.nil? }
+
+      @fluxor.update_attributes name: "Some more text."
     end
 
     teardown do
       PaperTrail.config.serializer = PaperTrail::Serializers::YAML
     end
 
-    should 'reify with custom serializer' do
+    should "reify with custom serializer" do
       # Normal behaviour
       assert_equal 2, @fluxor.versions.length
       assert_nil @fluxor.versions[0].reify
       assert_nil @fluxor.versions[1].reify.name
 
       # Check values are stored as JSON.
-      assert_equal @original_fluxor_attributes, ActiveSupport::JSON.decode(@fluxor.versions[1].object)
-      # This test can't consistently pass in Ruby1.8 because hashes do no preserve order, which means the order of the
-      # attributes in the JSON can't be ensured.
-      if RUBY_VERSION >= '1.9'
-        assert_equal ActiveSupport::JSON.encode(@original_fluxor_attributes), @fluxor.versions[1].object
-      end
+      assert_equal @original_fluxor_attributes,
+        ActiveSupport::JSON.decode(@fluxor.versions[1].object)
+      assert_equal ActiveSupport::JSON.encode(@original_fluxor_attributes),
+        @fluxor.versions[1].object
     end
 
-    should 'store object_changes' do
-      initial_changeset = {"id" => [nil, @fluxor.id]}
-      second_changeset =  {"name"=>[nil, "Some more text."]}
+    should "store object_changes" do
+      initial_changeset = { "id" => [nil, @fluxor.id] }
+      second_changeset = { "name" => [nil, "Some more text."] }
       assert_equal initial_changeset, @fluxor.versions[0].changeset
       assert_equal second_changeset,  @fluxor.versions[1].changeset
     end
   end
-
 end

data/test/unit/serializers/json_test.rb

@@ -1,50 +1,49 @@
-require 'test_helper'
+require "test_helper"
 
 class JSONTest < ActiveSupport::TestCase
-
   setup do
     # Setup a hash with random values
     @hash = {}
     (1..4).each do |i|
-      @hash["key#{i}"] = Faker::Lorem.word
+      @hash["key#{i}"] = FFaker::Lorem.word
     end
     @hash_as_json = @hash.to_json
     # Setup an array of random words
     @array = []
-    (rand(5) + 4).times { @array << Faker::Lorem.word }
+    (rand(5) + 4).times { @array << FFaker::Lorem.word }
     @array_as_json = @array.to_json
   end
 
-  context '`load` class method' do
-    should 'exist' do
+  context "`load` class method" do
+    should "exist" do
       assert PaperTrail::Serializers::JSON.respond_to?(:load)
     end
 
-    should '`deserialize` JSON to Ruby' do
+    should "`deserialize` JSON to Ruby" do
       assert_equal @hash, PaperTrail::Serializers::JSON.load(@hash_as_json)
       assert_equal @array, PaperTrail::Serializers::JSON.load(@array_as_json)
     end
   end
 
-  context '`dump` class method' do
-    should 'exist' do
+  context "`dump` class method" do
+    should "exist" do
       assert PaperTrail::Serializers::JSON.respond_to?(:dump)
     end
 
-    should '`serialize` Ruby to JSON' do
+    should "`serialize` Ruby to JSON" do
       assert_equal @hash_as_json, PaperTrail::Serializers::JSON.dump(@hash)
       assert_equal @array_as_json, PaperTrail::Serializers::JSON.dump(@array)
     end
   end
 
-  context '`where_object` class method' do
+  context "`where_object` class method" do
     context "when value is a string" do
-      should 'construct correct WHERE query' do
+      should "construct correct WHERE query" do
         matches = PaperTrail::Serializers::JSON.where_object_condition(
           PaperTrail::Version.arel_table[:object], :arg1, "Val 1")
 
         assert matches.instance_of?(Arel::Nodes::Matches)
-        if Arel::VERSION >= '6'
+        if Arel::VERSION >= "6"
           assert_equal matches.right.val, "%\"arg1\":\"Val 1\"%"
         else
           assert_equal matches.right, "%\"arg1\":\"Val 1\"%"
@@ -53,12 +52,12 @@ class JSONTest < ActiveSupport::TestCase
     end
 
     context "when value is `null`" do
-      should 'construct correct WHERE query' do
+      should "construct correct WHERE query" do
         matches = PaperTrail::Serializers::JSON.where_object_condition(
           PaperTrail::Version.arel_table[:object], :arg1, nil)
 
         assert matches.instance_of?(Arel::Nodes::Matches)
-        if Arel::VERSION >= '6'
+        if Arel::VERSION >= "6"
           assert_equal matches.right.val, "%\"arg1\":null%"
         else
           assert_equal matches.right, "%\"arg1\":null%"
@@ -67,15 +66,15 @@ class JSONTest < ActiveSupport::TestCase
     end
 
     context "when value is a number" do
-      should 'construct correct WHERE query' do
+      should "construct correct WHERE query" do
         grouping = PaperTrail::Serializers::JSON.where_object_condition(
           PaperTrail::Version.arel_table[:object], :arg1, -3.5)
 
         assert grouping.instance_of?(Arel::Nodes::Grouping)
         matches = grouping.select { |v| v.instance_of?(Arel::Nodes::Matches) }
-        # Numeric arguments need to ensure that they match for only the number, not the beginning 
+        # Numeric arguments need to ensure that they match for only the number, not the beginning
         # of a #, so it uses an Grouping matcher (See notes on `PaperTrail::Serializers::JSON`)
-        if Arel::VERSION >= '6'
+        if Arel::VERSION >= "6"
           assert_equal matches.first.right.val, "%\"arg1\":-3.5,%"
           assert_equal matches.last.right.val, "%\"arg1\":-3.5}%"
         else

data/test/unit/serializers/mixin_json_test.rb

@@ -1,36 +1,37 @@
-require 'test_helper'
-require 'custom_json_serializer'
+require "test_helper"
+require "custom_json_serializer"
 
 class MixinJsonTest < ActiveSupport::TestCase
-
   setup do
     # Setup a hash with random values, ensuring some values are nil
     @hash = {}
     (1..4).each do |i|
-      @hash["key#{i}"] = [Faker::Lorem.word, nil].sample
+      @hash["key#{i}"] = [FFaker::Lorem.word, nil].sample
     end
-    @hash['tkey'] = nil
-    @hash[''] = 'foo'
+    @hash["tkey"] = nil
+    @hash[""] = "foo"
     @hash_as_json = @hash.to_json
   end
 
-  context '`load` class method' do
-    should 'exist' do
+  context "`load` class method" do
+    should "exist" do
       assert CustomJsonSerializer.respond_to?(:load)
     end
 
-    should '`deserialize` JSON to Ruby, removing pairs with `blank` keys or values' do
-      assert_equal @hash.reject { |k,v| k.blank? || v.blank? }, CustomJsonSerializer.load(@hash_as_json)
+    should "`deserialize` JSON to Ruby, removing pairs with `blank` keys or values" do
+      assert_equal @hash.reject { |k, v| k.blank? || v.blank? },
+        CustomJsonSerializer.load(@hash_as_json)
     end
   end
 
-  context '`dump` class method' do
-    should 'exist' do
+  context "`dump` class method" do
+    should "exist" do
       assert CustomJsonSerializer.respond_to?(:dump)
     end
 
-    should '`serialize` Ruby to JSON, removing pairs with `nil` values' do
-      assert_equal @hash.reject { |k,v| v.nil? }.to_json, CustomJsonSerializer.dump(@hash)
+    should "`serialize` Ruby to JSON, removing pairs with `nil` values" do
+      assert_equal @hash.reject { |_k, v| v.nil? }.to_json,
+        CustomJsonSerializer.dump(@hash)
     end
   end
 end

data/test/unit/serializers/mixin_yaml_test.rb

@@ -1,49 +1,53 @@
-require 'test_helper'
+require "test_helper"
 
 module CustomYamlSerializer
   extend PaperTrail::Serializers::YAML
 
   def self.load(string)
     parsed_value = super(string)
-    parsed_value.is_a?(Hash) ? parsed_value.reject { |k,v| k.blank? || v.blank? } : parsed_value
+    if parsed_value.is_a?(Hash)
+      parsed_value.reject { |k, v| k.blank? || v.blank? }
+    else
+      parsed_value
+    end
   end
 
   def self.dump(object)
-    object.is_a?(Hash) ? super(object.reject { |k,v| v.nil? }) : super
+    object.is_a?(Hash) ? super(object.reject { |_k, v| v.nil? }) : super
   end
 end
 
 class MixinYamlTest < ActiveSupport::TestCase
-
   setup do
     # Setup a hash with random values, ensuring some values are nil
     @hash = {}
     (1..4).each do |i|
-      @hash["key#{i}"] = [Faker::Lorem.word, nil].sample
+      @hash["key#{i}"] = [FFaker::Lorem.word, nil].sample
     end
-    @hash['tkey'] = nil
-    @hash[''] = 'foo'
+    @hash["tkey"] = nil
+    @hash[""] = "foo"
     @hash_as_yaml = @hash.to_yaml
   end
 
-  context '`load` class method' do
-    should 'exist' do
+  context "`load` class method" do
+    should "exist" do
       assert CustomYamlSerializer.respond_to?(:load)
     end
 
-    should '`deserialize` YAML to Ruby, removing pairs with `blank` keys or values' do
-      assert_equal @hash.reject { |k,v| k.blank? || v.blank? }, CustomYamlSerializer.load(@hash_as_yaml)
+    should "`deserialize` YAML to Ruby, removing pairs with `blank` keys or values" do
+      assert_equal @hash.reject { |k, v| k.blank? || v.blank? },
+        CustomYamlSerializer.load(@hash_as_yaml)
     end
   end
 
-  context '`dump` class method' do
-    should 'exist' do
+  context "`dump` class method" do
+    should "exist" do
       assert CustomYamlSerializer.respond_to?(:dump)
     end
 
-    should '`serialize` Ruby to YAML, removing pairs with `nil` values' do
-      assert_equal @hash.reject { |k,v| v.nil? }.to_yaml, CustomYamlSerializer.dump(@hash)
+    should "`serialize` Ruby to YAML, removing pairs with `nil` values" do
+      assert_equal @hash.reject { |_k, v| v.nil? }.to_yaml,
+        CustomYamlSerializer.dump(@hash)
     end
   end
-
 end

data/test/unit/serializers/yaml_test.rb

@@ -1,48 +1,47 @@
-require 'test_helper'
+require "test_helper"
 
 class YamlTest < ActiveSupport::TestCase
-
   setup do
     # Setup a hash with random values
     @hash = {}
     (1..4).each do |i|
-      @hash["key#{i}".to_sym] = Faker::Lorem.word
+      @hash["key#{i}".to_sym] = FFaker::Lorem.word
     end
     @hash_as_yaml = @hash.to_yaml
     # Setup an array of random words
     @array = []
-    (rand(5) + 4).times { @array << Faker::Lorem.word }
+    (rand(5) + 4).times { @array << FFaker::Lorem.word }
     @array_as_yaml = @array.to_yaml
   end
 
-  context '`load` class method' do
-    should 'exist' do
+  context "`load` class method" do
+    should "exist" do
       assert PaperTrail::Serializers::YAML.respond_to?(:load)
     end
 
-    should 'deserialize `YAML` to Ruby' do
+    should "deserialize `YAML` to Ruby" do
       assert_equal @hash, PaperTrail::Serializers::YAML.load(@hash_as_yaml)
       assert_equal @array, PaperTrail::Serializers::YAML.load(@array_as_yaml)
     end
   end
 
-  context '`dump` class method' do
-    should 'exist' do
+  context "`dump` class method" do
+    should "exist" do
       assert PaperTrail::Serializers::YAML.respond_to?(:dump)
     end
 
-    should 'serialize Ruby to `YAML`' do
+    should "serialize Ruby to `YAML`" do
       assert_equal @hash_as_yaml, PaperTrail::Serializers::YAML.dump(@hash)
       assert_equal @array_as_yaml, PaperTrail::Serializers::YAML.dump(@array)
     end
   end
 
-  context '`where_object` class method' do
-    should 'construct correct WHERE query' do
+  context "`where_object` class method" do
+    should "construct correct WHERE query" do
       matches = PaperTrail::Serializers::YAML.where_object_condition(
         PaperTrail::Version.arel_table[:object], :arg1, "Val 1")
       assert matches.instance_of?(Arel::Nodes::Matches)
-      if Arel::VERSION >= '6'
+      if Arel::VERSION >= "6"
         assert_equal matches.right.val, "%\narg1: Val 1\n%"
       else
         assert_equal matches.right, "%\narg1: Val 1\n%"