rails-flog 1.3.2 → 1.6.1

data/lib/flog/status.rb

@@ -1,33 +1,49 @@
-# coding: utf-8
-require "rails"
+# frozen_string_literal: true
+
+require 'rails'
 
 module Flog
+  # Status returns checke result of switch files
   class Status
-    SWITCH_FILE_NAME = "no-flog.txt"
-    SQL_SWITCH_FILE_NAME = "no-flog-sql.txt"
-    PARAMS_SWITCH_FILE_NAME = "no-flog-params.txt"
-
-    def self.enabled?
-      !switch_file_exists?(SWITCH_FILE_NAME)
-    rescue
-      true
-    end
+    SWITCH_FILE_NAME = 'no-flog.txt'
+    SQL_SWITCH_FILE_NAME = 'no-flog-sql.txt'
+    PARAMS_SWITCH_FILE_NAME = 'no-flog-params.txt'
+    class << self
+      def enabled?
+        !switch_file_exists?(SWITCH_FILE_NAME)
+      rescue StandardError
+        true
+      end
 
-    def self.sql_formattable?
-      enabled? && !switch_file_exists?(SQL_SWITCH_FILE_NAME)
-    rescue
-      true
-    end
+      def sql_formattable?
+        enabled? && !switch_file_exists?(SQL_SWITCH_FILE_NAME)
+      rescue StandardError
+        true
+      end
 
-    def self.params_formattable?
-      enabled? && !switch_file_exists?(PARAMS_SWITCH_FILE_NAME)
-    rescue
-      true
-    end
+      def params_formattable?
+        enabled? && !switch_file_exists?(PARAMS_SWITCH_FILE_NAME)
+      rescue StandardError
+        true
+      end
+
+      def switch_file_base_path
+        if Rails.root&.exist?
+          Rails.root
+        else
+          Pathname.new(File.expand_path(File.dirname(__FILE__) + '../../'))
+        end
+      end
+
+      def switch_file_dir_path
+        switch_file_base_path.join('tmp')
+      end
+
+      private
 
-    private
-    def self.switch_file_exists?(file_name)
-      File.exist?(Rails.root.join("tmp", file_name).to_s)
+      def switch_file_exists?(file_name)
+        switch_file_dir_path.join(file_name).exist?
+      end
     end
   end
 end

data/lib/flog/version.rb

@@ -1,4 +1,5 @@
-# coding: utf-8
+# frozen_string_literal: true
+
 module Flog
-  VERSION = "1.3.2"
+  VERSION = '1.6.1'
 end

data/rails-flog.gemspec

@@ -1,30 +1,32 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'flog/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "rails-flog"
+  spec.name          = 'rails-flog'
   spec.version       = Flog::VERSION
-  spec.authors       = ["pinzolo"]
-  spec.email         = ["pinzolo@gmail.com"]
-  spec.description   = %q{This formats parameters and sql in rails log.}
-  spec.summary       = %q{Rails log formatter for parameters and sql}
-  spec.homepage      = "https://github.com/pinzolo/rails-flog"
-  spec.license       = "MIT"
+  spec.authors       = ['pinzolo']
+  spec.email         = ['pinzolo@gmail.com']
+  spec.description   = 'This formats parameters and sql in rails log.'
+  spec.summary       = 'Rails log formatter for parameters and sql'
+  spec.homepage      = 'https://github.com/pinzolo/rails-flog'
+  spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "sqlite3"
-  spec.add_development_dependency "coveralls"
-  spec.add_development_dependency "mocha"
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'sqlite3'
 
-  spec.add_dependency "rails", ">=3.2.0"
-  spec.add_dependency "anbt-sql-formatter"
-  spec.add_dependency "awesome_print"
+  spec.add_dependency 'anbt-sql-formatter', '>=0.0.7'
+  spec.add_dependency 'amazing_print'
+  spec.add_dependency 'rails', '>=4.2.0'
 end

data/test/test_helper.rb

@@ -1,43 +1,56 @@
-# coding: utf-8
-require "coveralls"
-require "simplecov"
+# frozen_string_literal: true
+
+require 'coveralls'
+require 'simplecov'
 SimpleCov.formatter = Coveralls::SimpleCov::Formatter
 SimpleCov.start do
   add_filter '/test/'
   add_filter '/bundle/'
 end
 
-Bundler.require
-require "flog"
-require "minitest/autorun"
-require "mocha/api"
+require 'flog'
+require 'minitest/autorun'
 
-class TestLogger
-  attr_accessor :debugs, :infos, :errors
+unless defined?(TestLogger)
+  class TestLogger
+    attr_accessor :debugs, :infos, :errors
 
-  def initialize
-    @debugs = []
-    @infos = []
-    @errors = []
-  end
+    def initialize
+      @debugs = []
+      @infos = []
+      @errors = []
+    end
 
-  def debug?
-    true
-  end
+    def debug?
+      true
+    end
 
-  def info?
-    true
-  end
+    def info?
+      true
+    end
 
-  def debug(message)
-    @debugs += message.split("\n")
+    def debug(message)
+      @debugs += message.split("\n") if message
+    end
+
+    def info(message)
+      @infos += message.split("\n") if message
+    end
+
+    def error(message)
+      @errors += message.split("\n") if message
+    end
   end
+end
+
+unless defined?(COLOR_SEQ_REGEX)
+  COLOR_SEQ_REGEX = /\e\[(\d+;)*\d+m/.freeze
 
-  def info(message)
-    @infos += message.split("\n")
+  def remove_color_seq(log)
+    log.gsub(COLOR_SEQ_REGEX, '')
   end
 
-  def error(message)
-    @errors += message.split("\n")
+  def match_color_seq(log)
+    COLOR_SEQ_REGEX.match(log)
   end
 end

data/test/unit/params_formattable_test.rb

@@ -1,6 +1,7 @@
-# coding: utf-8
-require "action_controller"
-require "test_helper"
+# frozen_string_literal: true
+
+require 'action_controller'
+require 'test_helper'
 
 class TestController < ActionController::Base
   def initialize(routes)
@@ -12,11 +13,11 @@ class TestController < ActionController::Base
   end
 
   def show
-    render nothing: true
+    head :not_found
   end
 end
 
-class ParamsFormattableTest < ActionController::TestCase
+module ParamsFormattableTestHelper
   def setup
     # default configuration
     Flog.configure do |config|
@@ -26,11 +27,7 @@ class ParamsFormattableTest < ActionController::TestCase
 
     @old_logger = ActionController::Base.logger
     ActiveSupport::LogSubscriber.colorize_logging = false
-    @routes = ActionDispatch::Routing::RouteSet.new
-    @routes.draw do
-        get "test/show", to: "test#show"
-      end
-    @controller = TestController.new(@routes)
+    setup_routes
     super
     ActionController::Base.logger = TestLogger.new
   end
@@ -40,46 +37,90 @@ class ParamsFormattableTest < ActionController::TestCase
     ActionController::Base.logger = @old_logger
   end
 
+  def setup_routes
+    @routes = ActionDispatch::Routing::RouteSet.new
+    @routes.draw do
+      get 'test/show', to: 'test#show'
+    end
+    @controller = TestController.new(@routes)
+  end
+
+  def assert_logger(&block)
+    raise ActionController::Base.logger.errors.first if ActionController::Base.logger.errors.present?
+
+    block.call(ActionController::Base.logger)
+  end
+
+  def assert_include(log, *expected_includees)
+    expected_includees.each do |e|
+      assert log.include?(e)
+    end
+  end
+
+  def assert_hash(hash)
+    assert_equal hash['foo'], 'foo_value'
+    assert_equal hash['bar']['prop'], 'prop_value'
+    assert_equal hash['bar']['attr'], 'attr_value'
+  end
+
+  def get_show(params)
+    if Gem::Version.new(Rails.version) >= Gem::Version.new('5.0.0')
+      get :show, params: params
+    else
+      get :show, params
+    end
+  end
+
+  def hash_from_logs(logs, start, finish)
+    eval(start.upto(finish).reduce('') { |s, n| s + logs[n] })
+  end
+end
+
+class ParamsFormattableTest < ActionController::TestCase
+  include ParamsFormattableTestHelper
+
   def test_parameters_log_is_formatted
-    get :show, foo: "foo_value", bar: "bar_value"
+    get_show foo: 'foo_value', bar: { prop: 'prop_value', attr: 'attr_value' }
     assert_logger do |logger|
-      logs = logger.infos.map { |log| log.gsub(/\e\[(\d+;)*\d+m/, "") }
-      assert_equal %(  Parameters: )           , logs[1]
-      assert_equal %({)                        , logs[2]
-      assert_equal %(    "foo" => "foo_value",), logs[3]
-      assert_equal %(    "bar" => "bar_value") , logs[4]
-      assert_equal %(})                        , logs[5]
+      logs = logger.infos.map { |log| remove_color_seq(log) }
+      assert_equal '  Parameters: ', logs[1]
+      hash = hash_from_logs(logs, 2, 8)
+      assert_hash hash
     end
   end
 
   def test_colorized_on_colorize_loggin_is_true
     ActiveSupport::LogSubscriber.colorize_logging = true
-    get :show, foo: "foo_value", bar: "bar_value"
+    get_show foo: 'foo_value', bar: 'bar_value'
     assert_logger do |logger|
-      assert /\e\[(\d+;)*\d+m/.match(logger.infos.join())
+      assert match_color_seq(logger.infos.join)
     end
   end
 
   def test_not_colorized_on_colorize_loggin_is_false
-    get :show, foo: "foo_value", bar: "bar_value"
-    assert_logger do |logger|
-      assert_nil /\e\[(\d+;)*\d+m/.match(logger.infos.join())
+    Flog::Status.stub(:enabled?, true) do
+      get_show foo: 'foo_value', bar: 'bar_value'
+      assert_logger do |logger|
+        assert_nil match_color_seq(logger.infos.join)
+      end
     end
   end
 
   def test_parameters_log_is_not_formatted_when_enabled_is_false
-    Flog::Status.stubs(:enabled?).returns(false)
-    get :show, foo: "foo_value", bar: "bar_value"
-    assert_logger do |logger|
-      assert logger.infos[1].include?(%(Parameters: {"foo"=>"foo_value", "bar"=>"bar_value"}))
+    Flog::Status.stub(:enabled?, false) do
+      get_show foo: 'foo_value', bar: 'bar_value'
+      assert_logger do |logger|
+        assert_include logger.infos[1], 'Parameters: {', %("foo"=>"foo_value"), %("bar"=>"bar_value")
+      end
     end
   end
 
   def test_parameters_log_is_not_formatted_when_params_formattable_is_false
-    Flog::Status.stubs(:params_formattable?).returns(false)
-    get :show, foo: "foo_value", bar: "bar_value"
-    assert_logger do |logger|
-      assert logger.infos[1].include?(%(Parameters: {"foo"=>"foo_value", "bar"=>"bar_value"}))
+    Flog::Status.stub(:params_formattable?, false) do
+      get_show foo: 'foo_value', bar: 'bar_value'
+      assert_logger do |logger|
+        assert_include logger.infos[1], 'Parameters: {', %("foo"=>"foo_value"), %("bar"=>"bar_value")
+      end
     end
   end
 
@@ -87,9 +128,9 @@ class ParamsFormattableTest < ActionController::TestCase
     Flog.configure do |config|
       config.params_key_count_threshold = 2
     end
-    get :show, foo: "foo_value", bar: "bar_value"
+    get_show foo: 'foo_value', bar: 'bar_value'
     assert_logger do |logger|
-      assert logger.infos[1].include?(%(Parameters: {"foo"=>"foo_value", "bar"=>"bar_value"}))
+      assert_include logger.infos[1], 'Parameters: {', %("foo"=>"foo_value"), %("bar"=>"bar_value")
     end
   end
 
@@ -97,36 +138,34 @@ class ParamsFormattableTest < ActionController::TestCase
     Flog.configure do |config|
       config.params_key_count_threshold = 3
     end
-    get :show, foo: "foo_value", bar: "bar_value"
+    get_show foo: 'foo_value', bar: 'bar_value'
     assert_logger do |logger|
-      assert logger.infos[1].include?(%(Parameters: {"foo"=>"foo_value", "bar"=>"bar_value"}))
+      assert_include logger.infos[1], 'Parameters: {', %("foo"=>"foo_value"), %("bar"=>"bar_value")
     end
   end
 
+  # rubocop:disable Metrics/LineLength
   def test_parameters_log_is_formatted_when_key_of_parameters_count_is_under_configured_threshold_but_force_on_nested_params_configuration_is_true
     Flog.configure do |config|
       config.params_key_count_threshold = 3
     end
-    get :show, foo: "foo_value", bar: { prop: "prop_value", attr: "attr_value" }
+    get_show foo: 'foo_value', bar: { prop: 'prop_value', attr: 'attr_value' }
     assert_logger do |logger|
-      logs = logger.infos.map { |log| log.gsub(/\e\[(\d+;)*\d+m/, "") }
-      assert_equal %(  Parameters: )                 , logs[1]
-      assert_equal %({)                              , logs[2]
-      assert_equal %(    "foo" => "foo_value",)      , logs[3]
-      assert_equal %(    "bar" => {)                 , logs[4]
-      assert_equal %(        "prop" => "prop_value",), logs[5]
-      assert_equal %(        "attr" => "attr_value") , logs[6]
-      assert_equal %(    })                          , logs[7]
-      assert_equal %(})                              , logs[8]
+      logs = logger.infos.map { |log| remove_color_seq(log) }
+      assert_equal '  Parameters: ', logs[1]
+      hash = hash_from_logs(logs, 2, 8)
+      assert_hash hash
     end
   end
+  # rubocop:enable Metrics/LineLength
 
-  private
-  def assert_logger(&block)
-    if ActionController::Base.logger.errors.present?
-      fail ActionController::Base.logger.errors.first
-    else
-      block.call(ActionController::Base.logger)
+  def test_parameters_log_is_not_formatted_when_ignore_params_configuration_is_true
+    Flog.configure do |config|
+      config.ignore_params = true
+    end
+    get_show foo: 'foo_value', bar: 'bar_value'
+    assert_logger do |logger|
+      assert_include logger.infos[1], 'Parameters: {', %("foo"=>"foo_value"), %("bar"=>"bar_value")
     end
   end
 end

data/test/unit/payload_value_shuntable_test.rb

@@ -1,5 +1,6 @@
-# coding: utf-8
-require "test_helper"
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class TestClass
   include Flog::PayloadValueShuntable
@@ -8,49 +9,49 @@ end
 class PayloadValueShuntableTest < ActiveSupport::TestCase
   def setup
     @tester = TestClass.new
-    @payload = { foo: "foo_value", bar: "bar_value" }
+    @payload = { foo: 'foo_value', bar: 'bar_value' }
   end
 
   def test_shunt_payload_value
-    @tester.shunt_payload_value(@payload, :foo, "new_value") do
-      assert_equal "new_value", @payload[:foo]
+    @tester.shunt_payload_value(@payload, :foo, 'new_value') do
+      assert_equal 'new_value', @payload[:foo]
     end
   end
 
   def test_value_of_other_key_is_not_changed
-    @tester.shunt_payload_value(@payload, :foo, "new_value") do
-      assert_equal "bar_value", @payload[:bar]
+    @tester.shunt_payload_value(@payload, :foo, 'new_value') do
+      assert_equal 'bar_value', @payload[:bar]
     end
   end
 
   def test_restoration
-    @tester.shunt_payload_value(@payload, :foo, "new_value") do
-      assert_equal "new_value", @payload[:foo]
+    @tester.shunt_payload_value(@payload, :foo, 'new_value') do
+      assert_equal 'new_value', @payload[:foo]
     end
-    assert_equal "foo_value", @payload[:foo]
+    assert_equal 'foo_value', @payload[:foo]
   end
 
   def test_ensure_restoration_on_error_raised_in_block
     error_raised = false
     begin
-      @tester.shunt_payload_value(@payload, :foo, "new_value") do
-        raise "error"
+      @tester.shunt_payload_value(@payload, :foo, 'new_value') do
+        raise 'error'
       end
-    rescue => ex
+    rescue StandardError
       error_raised = true
     end
     assert error_raised
-    assert_equal "foo_value", @payload[:foo]
+    assert_equal 'foo_value', @payload[:foo]
   end
 
   def test_without_block
-    @tester.shunt_payload_value(@payload, :foo, "new_value")
-    assert_equal "foo_value", @payload[:foo]
+    @tester.shunt_payload_value(@payload, :foo, 'new_value')
+    assert_equal 'foo_value', @payload[:foo]
   end
 
   def test_key_removed_when_give_not_exist_key
-    @tester.shunt_payload_value(@payload, :baz, "new_value") do
-      assert_equal "new_value", @payload[:baz]
+    @tester.shunt_payload_value(@payload, :baz, 'new_value') do
+      assert_equal 'new_value', @payload[:baz]
     end
     assert_equal false, @payload.key?(:baz)
   end