Improve gem loading

CHANGELOG.md

@@ -3,7 +3,10 @@
 ## [3.0.1] - Unreleased
 
 ### Changed or Fixed or Added
-- Your contribution here.
+
+### Changed
+- Move dev dependencies to Gemfile
+- Use zeitwerk to load gem
 
 [3.0.1]: https://github.com/aserafin/grape_logging/compare/v3.0.0...master
 

Gemfile

@@ -2,3 +2,10 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in grape_logging.gemspec
 gemspec
+
+gem 'rake', '~> 13.3'
+gem 'rspec', '~> 3.5'
+
+# This is pinned to an exact version otherwise we can't know which rules
+# are in play at any given time in different environments.
+gem 'rubocop', '1.77.0'

grape_logging.gemspec

@@ -22,11 +22,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'grape', '>= 2.4.0'
   spec.add_dependency 'rack'
-
-  spec.add_development_dependency 'rake', '~> 13.3'
-  spec.add_development_dependency 'rspec', '~> 3.5'
-
-  # This is pinned to an exact version otherwise we can't know which rules
-  # are in play at any given time in different environments.
-  spec.add_development_dependency 'rubocop', '1.77.0'
+  spec.add_dependency 'zeitwerk'
 end

lib/grape_logging.rb

@@ -1,17 +1,12 @@
-require 'grape_logging/multi_io'
-require 'grape_logging/version'
-require 'grape_logging/formatters/default'
-require 'grape_logging/formatters/json'
-require 'grape_logging/formatters/lograge'
-require 'grape_logging/formatters/logstash'
-require 'grape_logging/formatters/rails'
-require 'grape_logging/loggers/base'
-require 'grape_logging/loggers/response'
-require 'grape_logging/loggers/filter_parameters'
-require 'grape_logging/loggers/client_env'
-require 'grape_logging/loggers/request_headers'
-require 'grape_logging/reporters/active_support_reporter'
-require 'grape_logging/reporters/logger_reporter'
-require 'grape_logging/timings'
-require 'grape_logging/middleware/request_logger'
-require 'grape_logging/util/parameter_filter'
+require 'grape'
+require 'rack/utils'
+require 'zeitwerk'
+
+# load zeitwerk
+Zeitwerk::Loader.for_gem.tap do |loader|
+  loader.inflector.inflect 'multi_io' => 'MultiIO'
+  loader.setup
+end
+
+module GrapeLogging
+end

lib/grape_logging/formatters/rails.rb

@@ -1,5 +1,3 @@
-require 'rack/utils'
-
 module GrapeLogging
   module Formatters
     class Rails

lib/grape_logging/loggers/filter_parameters.rb

@@ -16,7 +16,7 @@ def parameters(request, _)
       private
 
       def parameter_filter
-        @parameter_filter ||= ParameterFilter.new(@replacement, @filter_parameters)
+        @parameter_filter ||= GrapeLogging::Util::ParameterFilter.new(@replacement, @filter_parameters)
       end
 
       def safe_parameters(request)

lib/grape_logging/middleware/request_logger.rb

@@ -1,5 +1,3 @@
-require 'grape'
-
 module GrapeLogging
   module Middleware
     class RequestLogger < Grape::Middleware::Base

lib/grape_logging/reporters/active_support_reporter.rb

@@ -1,11 +1,13 @@
-module Reporters
-  class ActiveSupportReporter
-    def initialize(instrumentation_key)
-      @instrumentation_key = instrumentation_key
-    end
+module GrapeLogging
+  module Reporters
+    class ActiveSupportReporter
+      def initialize(instrumentation_key)
+        @instrumentation_key = instrumentation_key
+      end
 
-    def perform(params)
-      ActiveSupport::Notifications.instrument @instrumentation_key, params
+      def perform(params)
+        ActiveSupport::Notifications.instrument @instrumentation_key, params
+      end
     end
   end
 end

lib/grape_logging/reporters/logger_reporter.rb

@@ -1,13 +1,15 @@
-module Reporters
-  class LoggerReporter
-    def initialize(logger, formatter, log_level)
-      @logger = logger.clone || Logger.new(STDOUT)
-      @log_level = log_level || :info
-      @logger.formatter = formatter || @logger.formatter || GrapeLogging::Formatters::Default.new if @logger.respond_to?(:formatter=)
-    end
+module GrapeLogging
+  module Reporters
+    class LoggerReporter
+      def initialize(logger, formatter, log_level)
+        @logger = logger.clone || Logger.new(STDOUT)
+        @log_level = log_level || :info
+        @logger.formatter = formatter || @logger.formatter || GrapeLogging::Formatters::Default.new if @logger.respond_to?(:formatter=)
+      end
 
-    def perform(params)
-      @logger.send(@log_level, params)
+      def perform(params)
+        @logger.send(@log_level, params)
+      end
     end
   end
 end

lib/grape_logging/util/parameter_filter.rb

@@ -1,101 +1,105 @@
-if defined?(Rails.application)
-  if Gem::Version.new(Rails.version) < Gem::Version.new('6.0.0')
-    class ParameterFilter < ActionDispatch::Http::ParameterFilter
-      def initialize(_replacement, filter_parameters)
-        super(filter_parameters)
-      end
-    end
-  else
-    require 'active_support/parameter_filter'
+module GrapeLogging
+  module Util
+    if defined?(Rails.application)
+      if Gem::Version.new(Rails.version) < Gem::Version.new('6.0.0')
+        class ParameterFilter < ActionDispatch::Http::ParameterFilter
+          def initialize(_replacement, filter_parameters)
+            super(filter_parameters)
+          end
+        end
+      else
+        require 'active_support/parameter_filter'
 
-    class ParameterFilter < ActiveSupport::ParameterFilter
-      def initialize(_replacement, filter_parameters)
-        super(filter_parameters)
+        class ParameterFilter < ActiveSupport::ParameterFilter
+          def initialize(_replacement, filter_parameters)
+            super(filter_parameters)
+          end
+        end
       end
-    end
-  end
-else
-  #
-  # lifted from https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/http/parameter_filter.rb
-  # we could depend on Rails specifically, but that would us way to hefty!
-  #
-  class ParameterFilter
-    def initialize(replacement, filters = [])
-      @replacement = replacement
-      @filters = filters
-    end
-
-    def filter(params)
-      compiled_filter.call(params)
-    end
+    else
+      #
+      # lifted from https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/http/parameter_filter.rb
+      # we could depend on Rails specifically, but that would us way to hefty!
+      #
+      class ParameterFilter
+        def initialize(replacement, filters = [])
+          @replacement = replacement
+          @filters = filters
+        end
 
-    private
+        def filter(params)
+          compiled_filter.call(params)
+        end
 
-    def compiled_filter
-      @compiled_filter ||= CompiledFilter.compile(@replacement, @filters)
-    end
+        private
 
-    class CompiledFilter # :nodoc:
-      def self.compile(replacement, filters)
-        return ->(params) { params.dup } if filters.empty?
-
-        strings = []
-        regexps = []
-        blocks = []
-
-        filters.each do |item|
-          case item
-          when Proc
-            blocks << item
-          when Regexp
-            regexps << item
-          else
-            strings << Regexp.escape(item.to_s)
-          end
+        def compiled_filter
+          @compiled_filter ||= CompiledFilter.compile(@replacement, @filters)
         end
 
-        deep_regexps, regexps = regexps.partition { |r| r.to_s.include?('\\.'.freeze) }
-        deep_strings, strings = strings.partition { |s| s.include?('\\.'.freeze) }
+        class CompiledFilter # :nodoc:
+          def self.compile(replacement, filters)
+            return ->(params) { params.dup } if filters.empty?
 
-        regexps << Regexp.new(strings.join('|'.freeze), true) unless strings.empty?
-        deep_regexps << Regexp.new(deep_strings.join('|'.freeze), true) unless deep_strings.empty?
+            strings = []
+            regexps = []
+            blocks = []
 
-        new replacement, regexps, deep_regexps, blocks
-      end
+            filters.each do |item|
+              case item
+              when Proc
+                blocks << item
+              when Regexp
+                regexps << item
+              else
+                strings << Regexp.escape(item.to_s)
+              end
+            end
 
-      attr_reader :regexps, :deep_regexps, :blocks
+            deep_regexps, regexps = regexps.partition { |r| r.to_s.include?('\\.'.freeze) }
+            deep_strings, strings = strings.partition { |s| s.include?('\\.'.freeze) }
 
-      def initialize(replacement, regexps, deep_regexps, blocks)
-        @replacement = replacement
-        @regexps = regexps
-        @deep_regexps = deep_regexps.any? ? deep_regexps : nil
-        @blocks = blocks
-      end
+            regexps << Regexp.new(strings.join('|'.freeze), true) unless strings.empty?
+            deep_regexps << Regexp.new(deep_strings.join('|'.freeze), true) unless deep_strings.empty?
 
-      def call(original_params, parents = [])
-        filtered_params = {}
-
-        original_params.each do |key, value|
-          parents.push(key) if deep_regexps
-          if regexps.any? { |r| key =~ r }
-            value = @replacement
-          elsif deep_regexps && (joined = parents.join('.')) && deep_regexps.any? { |r| joined =~ r }
-            value = @replacement
-          elsif value.is_a?(Hash)
-            value = call(value, parents)
-          elsif value.is_a?(Array)
-            value = value.map { |v| v.is_a?(Hash) ? call(v, parents) : v }
-          elsif blocks.any?
-            key = key.dup if key.duplicable?
-            value = value.dup if value.duplicable?
-            blocks.each { |b| b.call(key, value) }
+            new replacement, regexps, deep_regexps, blocks
           end
-          parents.pop if deep_regexps
 
-          filtered_params[key] = value
-        end
+          attr_reader :regexps, :deep_regexps, :blocks
+
+          def initialize(replacement, regexps, deep_regexps, blocks)
+            @replacement = replacement
+            @regexps = regexps
+            @deep_regexps = deep_regexps.any? ? deep_regexps : nil
+            @blocks = blocks
+          end
 
-        filtered_params
+          def call(original_params, parents = [])
+            filtered_params = {}
+
+            original_params.each do |key, value|
+              parents.push(key) if deep_regexps
+              if regexps.any? { |r| key =~ r }
+                value = @replacement
+              elsif deep_regexps && (joined = parents.join('.')) && deep_regexps.any? { |r| joined =~ r }
+                value = @replacement
+              elsif value.is_a?(Hash)
+                value = call(value, parents)
+              elsif value.is_a?(Array)
+                value = value.map { |v| v.is_a?(Hash) ? call(v, parents) : v }
+              elsif blocks.any?
+                key = key.dup if key.duplicable?
+                value = value.dup if value.duplicable?
+                blocks.each { |b| b.call(key, value) }
+              end
+              parents.pop if deep_regexps
+
+              filtered_params[key] = value
+            end
+
+            filtered_params
+          end
+        end
       end
     end
   end