paper_trail 6.0.2 → 7.0.0

data/lib/paper_trail/frameworks/sinatra.rb

@@ -1,40 +0,0 @@
-require "active_support/core_ext/object" # provides the `try` method
-
-module PaperTrail
-  # Extensions to `Sinatra`.
-  module Sinatra
-    # Register this module inside your Sinatra application to gain access to
-    # controller-level methods used by PaperTrail.
-    def self.registered(app)
-      app.use RequestStore::Middleware
-      app.helpers self
-      app.before { set_paper_trail_whodunnit }
-    end
-
-    protected
-
-    # Returns the user who is responsible for any changes that occur.
-    # By default this calls `current_user` and returns the result.
-    #
-    # Override this method in your controller to call a different
-    # method, e.g. `current_person`, or anything you like.
-    def user_for_paper_trail
-      return unless defined?(current_user)
-      ActiveSupport::VERSION::MAJOR >= 4 ? current_user.try!(:id) : current_user.try(:id)
-    rescue NoMethodError
-      current_user
-    end
-
-    private
-
-    # Tells PaperTrail who is responsible for any changes that occur.
-    def set_paper_trail_whodunnit
-      @set_paper_trail_whodunnit_called = true
-      ::PaperTrail.whodunnit = user_for_paper_trail if ::PaperTrail.enabled?
-    end
-  end
-end
-
-if defined?(::Sinatra)
-  ::Sinatra.register(::PaperTrail::Sinatra)
-end

data/test/functional/modular_sinatra_test.rb

@@ -1,46 +0,0 @@
-# PaperTrail is not compatible with sinatra 2 yet. Contributions welcome.
-if Gem::Version.new(Rack.release) < Gem::Version.new("2.0.0.alpha")
-  require "test_helper"
-  require "sinatra/base"
-
-  # --- Tests for modular `Sinatra::Base` style ----
-  class BaseApp < Sinatra::Base
-    configs = YAML.load_file(File.expand_path("../../dummy/config/database.yml", __FILE__))
-    ActiveRecord::Base.configurations = configs
-    ActiveRecord::Base.establish_connection(:test)
-    register PaperTrail::Sinatra
-
-    get "/test" do
-      Widget.create!(name: "foo")
-      "Hello"
-    end
-
-    def current_user
-      @current_user ||= OpenStruct.new(id: "foobar")
-    end
-  end
-
-  class ModularSinatraTest < ActionDispatch::IntegrationTest
-    include Rack::Test::Methods
-
-    def app
-      @app ||= BaseApp
-    end
-
-    test "baseline" do
-      assert_nil Widget.create.versions.first.whodunnit
-    end
-
-    context "`PaperTrail::Sinatra` in a `Sinatra::Base` application" do
-      should "sets the `user_for_paper_trail` from the `current_user` method" do
-        get "/test"
-        assert_equal "Hello", last_response.body
-        widget = Widget.last
-        assert_not_nil widget
-        assert_equal "foo", widget.name
-        assert_equal 1, widget.versions.size
-        assert_equal "foobar", widget.versions.first.whodunnit
-      end
-    end
-  end
-end

data/test/functional/sinatra_test.rb

@@ -1,51 +0,0 @@
-# PaperTrail is not compatible with sinatra 2 yet. Contributions welcome.
-if Gem::Version.new(Rack.release) < Gem::Version.new("2.0.0.alpha")
-  require "test_helper"
-  # require 'sinatra/main'
-
-  # --- Tests for non-modular `Sinatra::Application` style ----
-  module Sinatra
-    class Application
-      configs = YAML.load_file(File.expand_path("../../dummy/config/database.yml", __FILE__))
-      ActiveRecord::Base.configurations = configs
-      ActiveRecord::Base.establish_connection(:test)
-
-      # We shouldn't actually need this line if I'm not mistaken but the tests
-      # seem to fail without it ATM
-      register PaperTrail::Sinatra
-
-      get "/test" do
-        Widget.create!(name: "bar")
-        "Hai"
-      end
-
-      def current_user
-        @current_user ||= OpenStruct.new(id: "raboof")
-      end
-    end
-  end
-
-  class SinatraTest < ActionDispatch::IntegrationTest
-    include Rack::Test::Methods
-
-    def app
-      @app ||= Sinatra::Application
-    end
-
-    test "baseline" do
-      assert_nil Widget.create.versions.first.whodunnit
-    end
-
-    context "`PaperTrail::Sinatra` in a `Sinatra::Application` application" do
-      should "sets the `user_for_paper_trail` from the `current_user` method" do
-        get "/test"
-        assert_equal "Hai", last_response.body
-        widget = Widget.last
-        assert_not_nil widget
-        assert_equal "bar", widget.name
-        assert_equal 1, widget.versions.size
-        assert_equal "raboof", widget.versions.first.whodunnit
-      end
-    end
-  end
-end

data/test/unit/cleaner_test.rb

@@ -1,151 +0,0 @@
-require "test_helper"
-
-class PaperTrailCleanerTest < ActiveSupport::TestCase
-  def populate_db!
-    @animals = [@animal = Animal.new, @dog = Dog.new, @cat = Cat.new]
-    @animals.each do |animal|
-      3.times { animal.update_attribute(:name, FFaker::Name.name) }
-    end
-  end
-
-  context "`clean_versions!` method" do
-    setup { populate_db! }
-
-    should "Baseline" do
-      assert_equal 9, PaperTrail::Version.count
-      @animals.each { |animal| assert_equal 3, animal.versions.size }
-    end
-
-    should "be extended by `PaperTrail` module" do
-      assert_respond_to PaperTrail, :clean_versions!
-    end
-
-    context "No options provided" do
-      should "removes extra versions for each item" do
-        PaperTrail.clean_versions!
-        assert_equal 3, PaperTrail::Version.count
-        @animals.each { |animal| assert_equal 1, animal.versions.size }
-      end
-
-      should "removes the earliest version(s)" do
-        before = @animals.map { |animal| animal.versions.last.reify.name }
-        PaperTrail.clean_versions!
-        after = @animals.map { |animal| animal.versions.last.reify.name }
-        assert_equal before, after
-      end
-    end
-
-    context "`:keeping` option" do
-      should "modifies the number of versions ommitted from destruction" do
-        PaperTrail.clean_versions!(keeping: 2)
-        assert_equal 6, PaperTrail::Version.all.count
-        @animals.each { |animal| assert_equal 2, animal.versions.size }
-      end
-    end
-
-    context "`:date` option" do
-      setup do
-        @animal.versions.each { |ver| ver.update_attribute(:created_at, ver.created_at - 1.day) }
-        @date = @animal.versions.first.created_at.to_date
-        @animal.update_attribute(:name, FFaker::Name.name)
-      end
-
-      should "restrict the versions destroyed to those that were created on the date provided" do
-        assert_equal 10, PaperTrail::Version.count
-        assert_equal 4, @animal.versions.size
-        assert_equal 3, @animal.paper_trail.versions_between(@date, @date + 1.day).size
-        PaperTrail.clean_versions!(date: @date)
-        assert_equal 8, PaperTrail::Version.count
-        assert_equal 2, @animal.versions.reload.size
-        assert_equal @date, @animal.versions.first.created_at.to_date
-        assert_not_same @date, @animal.versions.last.created_at.to_date
-      end
-    end
-
-    context "`:item_id` option" do
-      context "single ID received" do
-        should "restrict the versions destroyed to the versions for the Item with that ID" do
-          PaperTrail.clean_versions!(item_id: @animal.id)
-          assert_equal 1, @animal.versions.size
-          assert_equal 7, PaperTrail::Version.count
-        end
-      end
-
-      context "collection of ID's received" do
-        should "restrict the versions destroyed to the versions for the Item with those ID's" do
-          PaperTrail.clean_versions!(item_id: [@animal.id, @dog.id])
-          assert_equal 1, @animal.versions.size
-          assert_equal 1, @dog.versions.size
-          assert_equal 5, PaperTrail::Version.count
-        end
-      end
-    end
-
-    context "options combinations" do # additional tests to cover combinations of options
-      context "`:date`" do
-        setup do
-          [@animal, @dog].each do |animal|
-            animal.versions.each { |ver| ver.update_attribute(:created_at, ver.created_at - 1.day) }
-            animal.update_attribute(:name, FFaker::Name.name)
-          end
-          @date = @animal.versions.first.created_at.to_date
-        end
-
-        should "Baseline" do
-          assert_equal 11, PaperTrail::Version.count
-          [@animal, @dog].each do |animal|
-            assert_equal 4, animal.versions.size
-            assert_equal 3, animal.versions.between(@date, @date + 1.day).size
-          end
-        end
-
-        context "and `:keeping`" do
-          should "restrict cleaning properly" do
-            PaperTrail.clean_versions!(date: @date, keeping: 2)
-            [@animal, @dog].each do |animal|
-              # reload the association to pick up the destructions made by the `Cleaner`
-              animal.versions.reload
-              assert_equal 3, animal.versions.size
-              assert_equal 2, animal.versions.between(@date, @date + 1.day).size
-            end
-            # ensure that the versions for the `@cat` instance wasn't touched
-            assert_equal 9, PaperTrail::Version.count
-          end
-        end
-
-        context "and `:item_id`" do
-          should "restrict cleaning properly" do
-            PaperTrail.clean_versions!(date: @date, item_id: @dog.id)
-            # reload the association to pick up the destructions made by the `Cleaner`
-            @dog.versions.reload
-            assert_equal 2, @dog.versions.size
-            assert_equal 1, @dog.versions.between(@date, @date + 1.day).size
-            # ensure the versions for other animals besides `@animal` weren't touched
-            assert_equal 9, PaperTrail::Version.count
-          end
-        end
-
-        context ", `:item_id`, and `:keeping`" do
-          should "restrict cleaning properly" do
-            PaperTrail.clean_versions!(date: @date, item_id: @dog.id, keeping: 2)
-            # reload the association to pick up the destructions made by the `Cleaner`
-            @dog.versions.reload
-            assert_equal 3, @dog.versions.size
-            assert_equal 2, @dog.versions.between(@date, @date + 1.day).size
-            # ensure the versions for other animals besides `@animal` weren't touched
-            assert_equal 10, PaperTrail::Version.count
-          end
-        end
-      end
-
-      context "`:keeping` and `:item_id`" do
-        should "restrict cleaning properly" do
-          PaperTrail.clean_versions!(keeping: 2, item_id: @animal.id)
-          assert_equal 2, @animal.versions.size
-          # ensure the versions for other animals besides `@animal` weren't touched
-          assert_equal 8, PaperTrail::Version.count
-        end
-      end
-    end
-  end # clean_versions! method
-end

data/test/unit/inheritance_column_test.rb

@@ -1,41 +0,0 @@
-require "test_helper"
-
-class InheritanceColumnTest < ActiveSupport::TestCase
-  context "STI models" do
-    setup do
-      @animal = Animal.create name: "Animal"
-      @animal.update_attributes name: "Animal from the Muppets"
-      @animal.update_attributes name: "Animal Muppet"
-      @animal.destroy
-
-      @dog = Dog.create name: "Snoopy"
-      @dog.update_attributes name: "Scooby"
-      @dog.update_attributes name: "Scooby Doo"
-      @dog.destroy
-
-      @cat = Cat.create name: "Garfield"
-      @cat.update_attributes name: "Garfield (I hate Mondays)"
-      @cat.update_attributes name: "Garfield The Cat"
-      @cat.destroy
-    end
-
-    should "work with custom STI inheritance column" do
-      assert_equal 12, PaperTrail::Version.count
-      assert_equal 4, @animal.versions.count
-      assert_nil @animal.versions.first.reify
-      @animal.versions[1..-1].each { |v| assert_equal "Animal", v.reify.class.name }
-
-      # For some reason `@dog.versions` doesn't include the final `destroy` version.
-      # Neither do `@dog.versions.scoped` nor `@dog.versions(true)` nor `@dog.versions.reload`.
-      dog_versions = PaperTrail::Version.where(item_id: @dog.id).order(:created_at)
-      assert_equal 4, dog_versions.count
-      assert_nil dog_versions.first.reify
-      assert_equal %w(NilClass Dog Dog Dog), dog_versions.map { |v| v.reify.class.name }
-
-      cat_versions = PaperTrail::Version.where(item_id: @cat.id).order(:created_at)
-      assert_equal 4, cat_versions.count
-      assert_nil cat_versions.first.reify
-      assert_equal %w(NilClass Cat Cat Cat), cat_versions.map { |v| v.reify.class.name }
-    end
-  end
-end

data/test/unit/serializers/json_test.rb

@@ -1,95 +0,0 @@
-require "test_helper"
-
-class JSONTest < ActiveSupport::TestCase
-  setup do
-    # Setup a hash with random values
-    @hash = {}
-    (1..4).each do |i|
-      @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 << FFaker::Lorem.word }
-    @array_as_json = @array.to_json
-  end
-
-  context "`load` class method" do
-    should "exist" do
-      assert PaperTrail::Serializers::JSON.respond_to?(:load)
-    end
-
-    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
-      assert PaperTrail::Serializers::JSON.respond_to?(:dump)
-    end
-
-    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 "when value is a string" 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"
-          assert_equal matches.right.val, "%\"arg1\":\"Val 1\"%"
-        else
-          assert_equal matches.right, "%\"arg1\":\"Val 1\"%"
-        end
-      end
-    end
-
-    context "when value is `null`" 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"
-          assert_equal matches.right.val, "%\"arg1\":null%"
-        else
-          assert_equal matches.right, "%\"arg1\":null%"
-        end
-      end
-    end
-
-    context "when value is a number" 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
-        # of a #, so it uses an Grouping matcher (See notes on `PaperTrail::Serializers::JSON`)
-        if Arel::VERSION >= "6"
-          assert_equal matches.first.right.val, "%\"arg1\":-3.5,%"
-          assert_equal matches.last.right.val, "%\"arg1\":-3.5}%"
-        else
-          assert_equal matches.first.right, "%\"arg1\":-3.5,%"
-          assert_equal matches.last.right, "%\"arg1\":-3.5}%"
-        end
-      end
-    end
-  end
-end

data/test/unit/serializers/mixin_yaml_test.rb

@@ -1,53 +0,0 @@
-require "test_helper"
-
-module CustomYamlSerializer
-  extend PaperTrail::Serializers::YAML
-
-  def self.load(string)
-    parsed_value = super(string)
-    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
-  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}"] = [FFaker::Lorem.word, nil].sample
-    end
-    @hash["tkey"] = nil
-    @hash[""] = "foo"
-    @hash_as_yaml = @hash.to_yaml
-  end
-
-  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)
-    end
-  end
-
-  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)
-    end
-  end
-end