deprecation_collector 0.5.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12a18a7dcdd264edfd2e2350b648a5f7ba9ade6c6623ee500ffff557277bc02e
-  data.tar.gz: 4c39ea72577e7eca7092aa040a9b0095134f833c155b8a417b80be5e6b9a25bf
+  metadata.gz: 26bc69b0016762d0f5e8546f48177a7b2d90334bc8f4c995853c51e814386731
+  data.tar.gz: d059f4d6985f9136305160d0e0a6ffe184a6ac1a927e31959241e525974d78ea
 SHA512:
-  metadata.gz: 0e5acf3561f2b2f106362e3738050197188bd9d51b32c8534feb30ba2bcba67b51ca514a20e529818ac28388b1823371131735adb61ae5e095150908e4542b5e
-  data.tar.gz: e35978336a7642085f9daca1eff1922d80abd9e769bffef46f6ba6d4c36d066fe99b39f0dba262710c0d8469c7e5f7b9567dc702268d9d4712247ef22dc8f9a1
+  metadata.gz: 7a4609b79edbf7f54aa11538a7201595951ced8194d2a65fd01f4ef9be21cc75719fb27c1e0debbfcad5be2fc5407a9e8a04a6b398e7af2bc19c196461017437
+  data.tar.gz: 70f742f7dbd0525ee444c5aa076ccd241f1b8b5acd7c20a10b8778e838a40b3ba383dffd2b58b8776da6bc978583775f16104e89db5d1f1746bfe03e6e1ef8a3

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+== 0.7.0
+- support for Rails 7.1
+- make install critical section smaller to prevent installation deprecations preventing installation
+
+== 0.6.0
+- added active_record storage
+- redis dependency will become optional in v1.0
+- more test coverage
+
 == 0.5.0
 - more work on ui
 - refactored to separate deprecations storage from other logic

data/README.md

@@ -55,6 +55,16 @@ Rails.application.routes.draw do
 end
 ```
 
+usually it's a good idea to secure the ui in some way, you can use rails route constraint (actual check will depend on your app):
+```ruby
+Rails.application.routes.draw do
+  constraints(->(request) { request.session[:admin] }) do
+    require 'deprecation_collector/web'
+    mount DeprecationCollector::Web => '/deprecations', as: :deprecations
+  end
+end
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/deprecation_collector.gemspec

@@ -18,17 +18,8 @@ Gem::Specification.new do |spec|
   spec.metadata["source_code_uri"] = "https://github.com/Vasfed/deprecation_collector"
   spec.metadata["changelog_uri"] = "https://github.com/Vasfed/deprecation_collector/blob/main/CHANGELOG.md"
 
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)}) ||
-        f.match(%r{\Alib/deprecation_collector/web/views/.+\.slim\z})
-    end
-  end + Dir["lib/deprecation_collector/web/views/*.slim"].map { |template| template.sub(/\.slim\z/, ".template.rb") }
+  spec.files = Dir["lib/**/*", "sig/**/*", "*.md", "*.txt", "*.gemspec"].select { |filename| File.file?(filename) }
   spec.require_paths = ["lib"]
 
   spec.add_dependency "redis", ">= 3.0"
-  spec.add_development_dependency "appraisal"
-  spec.add_development_dependency "rack-test"
 end

data/lib/deprecation_collector/collectors.rb

@@ -2,6 +2,27 @@
 
 # :nodoc:
 class DeprecationCollector
+  ACTIVE_SUPPORT_BEHAVIORS = {
+    rails71: ->(message, callstack, deprecator) do
+      # TODO: use deprecator.gem_name, deprecator.deprecation_horizon
+      DeprecationCollector.collect(message, callstack, :rails)
+      ActiveSupport::Deprecation::DEFAULT_BEHAVIORS[stock_activesupport_behavior].call(message, callstack, deprecator)
+    end,
+    legacy: ->(message, callstack, deprecation_horizon, gem_name) do
+      DeprecationCollector.collect(message, callstack, :rails)
+      ActiveSupport::Deprecation::DEFAULT_BEHAVIORS[stock_activesupport_behavior].call(
+        message, callstack, deprecation_horizon, gem_name
+      )
+    end
+  }.freeze
+
+  # for intercepting deprecations from deprecators not installed in Rails.application.deprecators
+  module ActiveSupportDeprecationCollectionPatch
+    def behavior
+      @behavior ||= [DeprecationCollector::ACTIVE_SUPPORT_BEHAVIORS[:rails71]]
+    end
+  end
+
   class << self
     protected
 
@@ -18,12 +39,17 @@ class DeprecationCollector
 
     def tap_activesupport
       # TODO: a more polite hook
-      ActiveSupport::Deprecation.behavior = lambda do |message, callstack, deprecation_horizon, gem_name|
-        # not polite to turn off all other possible behaviors, but otherwise may get duplicate calls
-        DeprecationCollector.collect(message, callstack, :rails)
-        ActiveSupport::Deprecation::DEFAULT_BEHAVIORS[stock_activesupport_behavior].call(
-          message, callstack, deprecation_horizon, gem_name
-        )
+      # not polite to turn off all other possible behaviors, but otherwise may get duplicate calls
+      if Rails.respond_to?(:gem_version) && Rails.gem_version >= "7.1"
+        Rails.application.deprecators.behavior = ACTIVE_SUPPORT_BEHAVIORS[:rails71] if Rails.application&.deprecators
+        # Rails.application.deprecators.behavior only captures new-style deprecations, but we need all:
+        if ActiveSupport::Deprecation.respond_to?(:_instance)
+          ActiveSupport::Deprecation._instance.behavior = ACTIVE_SUPPORT_BEHAVIORS[:rails71]
+        end
+        # collect deprecations from deprecators that are not installed in `Rails.application.deprecators`
+        ActiveSupport::Deprecation.prepend(ActiveSupportDeprecationCollectionPatch)
+      else
+        ActiveSupport::Deprecation.behavior = ACTIVE_SUPPORT_BEHAVIORS[:legacy]
       end
     end
 

data/lib/deprecation_collector/storage/active_record.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+class DeprecationCollector
+  module Storage
+    # NB: this will not work in tests because of transactions, and may be affected by transactions of the app
+    # TODO: use separate db connection to mitigate this
+    class ActiveRecord < DeprecationCollector::Storage::Base
+      def initialize(model: nil, mutex: nil, count: false, write_interval: 900, write_interval_jitter: 60,
+                     key_prefix: nil)
+        super
+        raise "key prefix not supported in AR" if key_prefix && key_prefix != "deprecations"
+
+        self.model = model if model
+        @last_write_time = current_time
+        @count = count
+        @write_interval = write_interval
+        @write_interval_jitter = write_interval_jitter
+        # on cruby hash itself is threadsafe, but we need to prevent races
+        @deprecations_mutex = mutex || Mutex.new
+        @deprecations = {}
+        @known_digests = Set.new
+      end
+
+      def model=(model)
+        expected_class_methods = %i[column_names where pluck delete_all upsert_all find_in_batches find_by]
+        unless expected_class_methods.all? { |method_name| model.respond_to?(method_name) }
+          raise ArgumentError, "model expected to be a AR-like class responding to #{expected_class_methods.join(', ')}"
+        end
+
+        expected_fields = %w[digest data notes created_at updated_at]
+        unless expected_fields.all? { |column_name| model.column_names.include?(column_name) }
+          raise ArgumentError, "model expected to be a AR-like class with fields #{expected_fields.join(', ')}"
+        end
+
+        @model = model
+      end
+
+      def model
+        @model ||= ::Deprecation
+      end
+
+      attr_writer :key_prefix
+
+      def unsent_deprecations
+        @deprecations
+      end
+
+      def delete(remove_digests)
+        model.where(digest: remove_digests).delete_all
+      end
+
+      def clear(enable: false) # rubocop:disable Lint/UnusedMethodArgument
+        model.delete_all
+        @known_digests.clear
+        @deprecations.clear
+      end
+
+      def fetch_known_digests
+        @known_digests.merge(model.pluck(:digest))
+      end
+
+      def store(deprecation)
+        fresh = !@deprecations.key?(deprecation.digest)
+        @deprecations_mutex.synchronize do
+          (@deprecations[deprecation.digest] ||= deprecation).touch
+        end
+
+        flush if current_time - @last_write_time > (@write_interval + rand(@write_interval_jitter))
+        fresh
+      end
+
+      def flush(force: false)
+        return unless force || (current_time > @last_write_time + @write_interval)
+
+        deprecations_to_flush = nil
+        @deprecations_mutex.synchronize do
+          deprecations_to_flush = @deprecations
+          @deprecations = {}
+          @last_write_time = current_time
+          # checking in this section to prevent multiple parallel check requests
+          return DeprecationCollector.instance.instance_variable_set(:@enabled, false) unless enabled?
+        end
+
+        # write_count_to_redis(deprecations_to_flush) if @count
+
+        # make as few writes as possible, other workers may already have reported our warning
+        fetch_known_digests
+        deprecations_to_flush.reject! { |digest, _val| @known_digests.include?(digest) }
+        return unless deprecations_to_flush.any?
+
+        @known_digests.merge(deprecations_to_flush.keys)
+
+        model.upsert_all(
+          deprecations_to_flush.map do |key, deprecation|
+            {
+              digest: key, data: deprecation.as_json,
+              created_at: timestamp_to_time(deprecation.first_timestamp),
+              updated_at: timestamp_to_time(deprecation.first_timestamp)
+            }
+          end,
+          unique_by: :digest # , update_only: %i[data updated_at] # rails 7
+        )
+      end
+
+      def read_each
+        model.find_in_batches do |batch| # this is find_each, but do not require it to be implemented
+          batch.each do |record|
+            yield(record.digest, record.data.to_json, record.data&.dig("count"), record.notes)
+          end
+        end
+      end
+
+      def read_one(digest)
+        return [nil] * 4 unless (record = model.find_by(digest: digest))
+
+        [record.digest, record.data.to_json, record.data&.dig("count"), record.notes]
+      end
+
+      def import(dump_hash)
+        attrs = dump_hash.map do |key, deprecation|
+          time = deprecation["first_timestamp"] || deprecation[:first_timestamp]
+          time = time&.yield_self { |tme| timestamp_to_time(tme) } || current_time
+          { digest: key, data: deprecation, created_at: time, updated_at: time }
+        end
+        model.upsert_all(attrs, unique_by: :digest) # , update_only: %i[data updated_at])
+      end
+
+      def cleanup(&_block)
+        removed = total = 0
+
+        model.find_in_batches do |batch|
+          total += batch.size
+          removed += delete(
+            batch.select { |record| yield(record.data.deep_symbolize_keys) }.map(&:digest)
+          )
+        end
+        "#{removed} removed, #{total - removed} left"
+      end
+
+      protected
+
+      def current_time
+        return Time.zone.now if Time.respond_to?(:zone) && Time.zone
+
+        Time.now
+      end
+
+      def timestamp_to_time(timestamp)
+        return Time.zone.at(timestamp) if Time.respond_to?(:zone) && Time.zone
+
+        Time.at(timestamp)
+      end
+    end
+  end
+end

data/lib/deprecation_collector/storage.rb

@@ -21,6 +21,11 @@ class DeprecationCollector
       def flush(**); end
 
       def store(_deprecation); raise("Not implemented"); end
+
+      def read_each; end
+      def read_one(_digest); [nil] * 4 end
+
+      def import(_dump); end
       # rubocop:enable Style/SingleLineMethods
     end
 
@@ -36,7 +41,7 @@ class DeprecationCollector
       attr_accessor :write_interval, :write_interval_jitter, :redis, :count
 
       def initialize(redis: nil, mutex: nil, count: false, write_interval: 900, write_interval_jitter: 60,
-                            key_prefix: nil)
+                     key_prefix: nil)
         super
         @key_prefix = key_prefix || "deprecations"
         @redis = redis

data/lib/deprecation_collector/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class DeprecationCollector
-  VERSION = "0.5.2"
+  VERSION = "0.7.0"
 end

data/lib/deprecation_collector/web/application.rb

@@ -24,17 +24,17 @@ class DeprecationCollector
 
       root do # index
         @deprecations = collector_instance.read_each.to_a.compact
-        @deprecations = @deprecations.sort_by { |dep| dep[:message] } unless params[:sort] == "0"
+        @deprecations = @deprecations.sort_by { |dep| dep[:message].to_s } unless params[:sort] == "0"
 
         if params[:reject]
-          @deprecations = @deprecations.reject { |dep| dep[:message].match?(Regexp.union(Array(params[:reject]))) }
+          @deprecations = @deprecations.reject { |dep| dep[:message]&.match?(Regexp.union(Array(params[:reject]))) }
         end
 
         if params[:realm]
-          @deprecations = @deprecations.select { |dep| dep[:realm].match?(Regexp.union(Array(params[:realm]))) }
+          @deprecations = @deprecations.select { |dep| dep[:realm]&.match?(Regexp.union(Array(params[:realm]))) }
         end
 
-        render slim: "index.html"
+        render slim: "index.html", locals: { deprecations: @deprecations }
       end
 
       get "/dump.json" do
@@ -42,12 +42,13 @@ class DeprecationCollector
       end
 
       get "/import" do
-        return "Import not enabled" unless import_enabled?
+        halt 403, "Import not enabled" unless import_enabled?
 
         render slim: "import.html"
       end
 
       post "/import" do
+        halt 403, "Import not enabled" unless import_enabled?
         unless env["CONTENT_TYPE"]&.start_with?("multipart/form-data") && params.dig(:file, :tempfile)
           halt 422, "need multipart json file"
         end

data/lib/deprecation_collector/web/helpers.rb

@@ -14,7 +14,7 @@ class DeprecationCollector
 
       def root_path
         # request.base_url ?
-        "#{env["SCRIPT_NAME"]}/"
+        "#{env['SCRIPT_NAME']}/"
       end
 
       def current_path
@@ -26,7 +26,7 @@ class DeprecationCollector
       end
 
       def deprecation_path(id, format: nil)
-        ["#{root_path}#{id}", format].compact.join('.')
+        ["#{root_path}#{id}", format].compact.join(".")
       end
 
       def enable_deprecations_path
@@ -50,7 +50,10 @@ class DeprecationCollector
       def trigger_rails_deprecation
         return unless defined?(ActiveSupport::Deprecation)
 
-        -> { ActiveSupport::Deprecation.warn("Test deprecation") } []
+        deprecator = ActiveSupport::Deprecation
+        deprecator = ActiveSupport::Deprecation.new("0.0", "deprecation_collector") if Rails.gem_version >= "7.1"
+
+        -> { deprecator.warn("Test deprecation") } []
       end
 
       def current_color_theme
@@ -62,14 +65,16 @@ class DeprecationCollector
       end
 
       def detect_tag(deprecation)
-        msg = deprecation[:message]
+        msg = deprecation[:message].to_s
         return :kwargs if msg.include?("Using the last argument as keyword parameters is deprecated") ||
                           msg.include?("Passing the keyword argument as the last hash parameter is deprecated")
+
+        nil
       end
 
       def test_deprecation?(deprecation)
-        %w[trigger_kwargs_error_warning trigger_rails_deprecation].any? do
-          |method| deprecation[:message].include?(method)
+        %w[trigger_kwargs_error_warning trigger_rails_deprecation].any? do |method|
+          deprecation[:message].to_s.include?(method)
         end
       end
 
@@ -82,11 +87,13 @@ class DeprecationCollector
         tags << deprecation[:realm] if deprecation[:realm] && deprecation[:realm] != "rails"
         tags.merge(deprecation.dig(:notes, :tags) || [])
 
-        tags.to_h do |tag|
-          next [tag, "bg-success"] if tag == :test
-
-          [tag, "bg-secondary"]
-        end
+        tags.map do |tag|
+          if tag == :test
+            [tag, "bg-success"]
+          else
+            [tag, "bg-secondary"]
+          end
+        end.to_h
       end
     end
   end

data/lib/deprecation_collector/web/router.rb

@@ -54,7 +54,7 @@ class DeprecationCollector
           return [
             404,
             { "content-type" => "text/plain", "x-cascade" => "pass" },
-            ["Not Found #{env["REQUEST_METHOD"].inspect} #{env[PATH_INFO].inspect}"]
+            ["Not Found #{env['REQUEST_METHOD'].inspect} #{env[PATH_INFO].inspect}"]
           ]
         end
 
@@ -172,18 +172,18 @@ class DeprecationCollector
           }
 
           return [status, { "content-type" => "text/html" }.merge(color_scheme_headers), [html.to_s]] if html
+
+          nil
         end
 
         VIEW_PATH = "#{__dir__}/views"
 
         def render_template(template, &block)
           template_target = template.gsub(/\.slim\z/, ".template.rb")
-          template_method_name = "_template_#{template_target.gsub(/[^\w]/, "_")}"
+          template_method_name = "_template_#{template_target.gsub(/[^\w]/, '_')}"
           template_filename = File.join(VIEW_PATH, template_target.to_s)
 
-          if ENV["DEPRECATION_COLLECTOR_RELOAD_WEB_TEMPLATES"]
-            _recompile_template(template, template_filename, template_method_name)
-          end
+          _recompile_template(template, template_filename, template_method_name) if _recompile_enabled?
 
           _load_template(template_filename, template_method_name) unless respond_to?(template_method_name)
 
@@ -202,6 +202,10 @@ class DeprecationCollector
           ActionContext.class_eval(src, template_filename.gsub(/\.template\.rb\z/, ".slim"), 1)
         end
 
+        def _recompile_enabled?
+          ENV["DEPRECATION_COLLECTOR_RELOAD_WEB_TEMPLATES"]
+        end
+
         def _recompile_template(template, template_filename, template_method_name)
           original_template_name = File.join(VIEW_PATH, template.to_s)
           puts "Recompiling #{original_template_name}"

data/lib/deprecation_collector/web/views/import.html.slim

@@ -0,0 +1,12 @@
+header
+  h1 Import dump
+
+main
+  form method="post" action=import_deprecations_path enctype="multipart/form-data"
+    .mb-3
+      label.form-label> for="file" Choose a JSON file to upload:
+      input.form-comtrol type="file" name="file" id="file"
+    .mb-3
+      button.btn.btn-primary> type="submit" Upload
+      a.btn.btn-secondary> href=dump_deprecations_path Dump
+      a.btn.btn-secondary> href=deprecations_path Back

data/lib/deprecation_collector/web/views/import.html.template.rb

@@ -1,4 +1,4 @@
-_buf = ''; _buf << ("<header><h1>Import dump</h1></header><main><form".freeze); 
+_buf = ''.dup; _buf << ("<header><h1>Import dump</h1></header><main><form".freeze); 
 ; 
 ; 
 ; 

data/lib/deprecation_collector/web/views/index.html.slim

@@ -0,0 +1,121 @@
+header.mb-3
+  h1 Deprecations
+
+  a.btn.btn-primary>(data-method="post" href=deprecation_path(:trigger) rel="nofollow") Trigger a couple
+  a.btn.btn-danger>(data-method="delete" data-confirm="Sure?" href=deprecation_path(:all) rel="nofollow")
+    i.bi.bi-trash
+    ' Delete all
+
+  - if DeprecationCollector.instance.storage.support_disabling?
+    - if DeprecationCollector.instance.storage.enabled?
+      a.btn.btn-danger>(
+        data-method="delete" href=disable_deprecations_path rel="nofollow"
+        data-confirm="Sure? Will need to restart workers after enabling"
+        ) Disable
+    - else
+      a.btn.btn-secondary>(
+        data-method="post" href=enable_deprecations_path rel="nofollow"
+      ) Turn on (after workers restart)
+
+main
+  table.table.table-striped
+    tr
+      th Count
+      th Message
+      th Location
+      th Ruby/Rails
+
+    - total = 0
+    - by_realm = Hash.new(0)
+    - deprecations.each do |deprecation|
+      - total += 1
+      - by_realm[deprecation[:realm]] += 1
+      tr data-digest=deprecation[:digest]
+        td
+          a href=deprecation_path(deprecation[:digest]) = deprecation[:count]
+          br
+          - deprecation_tags(deprecation).each_pair do |tag, cls|
+            .badge> class=cls = tag
+
+        td
+          ruby:
+            msg = deprecation[:message].to_s
+            delete_prefixes = Gem.path + [defined?(Rails) && Rails.root.to_s].compact
+            delete_prefixes.each { |path| msg = msg.gsub(path, '') }
+            msg.delete_prefix! deprecation[:gem_traceline].gsub(/:in .+/, ':') if deprecation[:gem_traceline]
+            msg.delete_prefix! deprecation[:app_traceline].gsub(/:in .+/, ':') if deprecation[:app_traceline]
+            msg.strip!
+            msg.delete_prefix!("DEPRECATION WARNING: ")
+            msg.delete_prefix!("warning: ")
+
+          - if msg.lines.size > 2
+            pre.pre-scrollable.p-1(style="overflow: auto; max-width: 700px; max-height: 200px; font-size: 11px")
+              code = msg
+          - else
+            .msg = msg
+          - if deprecation.dig(:notes, :comment)
+            = deprecation.dig(:notes, :comment)
+
+          - if deprecation.dig(:context, :action)
+            i.small.controller = deprecation.dig(:context, :action)
+          - elsif deprecation.dig(:context, :params, :controller)
+            i.small.controller = deprecation.dig(:context, :params).slice(:controller, :action).values.join('#')
+
+        td.small
+          - if deprecation[:gem_traceline]
+            .gem_location
+              - location, function = deprecation[:gem_traceline].split(':in `', 2)
+              - full_gemname = location.delete_prefix('/gems/').gsub(%r{/.*}, '')
+              - location_in_gem = location.delete_prefix("/gems/#{full_gemname}/")
+              i>= full_gemname
+              code.code_location> data-copy-value=location_in_gem = location_in_gem.delete_prefix('lib/')
+              i= function.delete_suffix("'")
+          - if deprecation[:app_traceline]
+            .app_location
+              - location, function = deprecation[:app_traceline].split(':in `', 2)
+              code.code_location>= location
+              i= function.delete_suffix("'")
+        td
+          .small.ruby = deprecation[:ruby_version]
+          .small.rails = deprecation[:rails_version]
+
+          a href=deprecation_path(deprecation[:digest]) data-method="delete" data-confirm="Delete?" rel="nofollow" title="Delete"
+            i.bi.bi-trash
+    - if total.zero?
+      tr
+        td colspan=4
+          p Looks like there're no deprecations (or workers have not yet wrote to redis)
+          p
+            ' You can try
+            a href=deprecation_path(:trigger) data-method="post" rel="nofollow" trigger a couple
+            - if import_enabled?
+              |> , or
+              a> href=import_deprecations_path import
+
+
+footer
+  - if total > 3
+    => total
+    ' deprecations
+  - by_realm.each_pair do |realm, count|
+    a.btn.btn-sm.btn-outline-secondary> href="?realm=#{realm}"
+      => realm
+      .badge> class=(count == 0 ? 'bg-success' : 'bg-secondary') = count
+  - if params[:realm] && params[:realm] != ''
+    a.btn.btn-sm.btn-outline-primary> href="?realm="
+      ' Other realms    
+
+css:
+  .code_location {
+    cursor: pointer;
+  }
+
+javascript:
+  document.querySelectorAll('.code_location').forEach(function(elem){
+    elem.addEventListener('click', function () {
+      let textToCopy = elem.getAttribute('data-copy-value');
+      if(!textToCopy) textToCopy = elem.innerText;
+      console.log("Copying", textToCopy)
+      navigator.clipboard.writeText(textToCopy);
+    }, false);
+  });

data/lib/deprecation_collector/web/views/index.html.template.rb

@@ -1,4 +1,4 @@
-_buf = ''; _buf << ("<header class=\"mb-3\"><h1>Deprecations</h1><a class=\"btn btn-primary\" data-method=\"post\"".freeze); 
+_buf = ''.dup; _buf << ("<header class=\"mb-3\"><h1>Deprecations</h1><a class=\"btn btn-primary\" data-method=\"post\"".freeze); 
 ; 
 ; 
 ; _slim_codeattributes1 = deprecation_path(:trigger); if _slim_codeattributes1; if _slim_codeattributes1 == true; _buf << (" href=\"\"".freeze); else; _buf << (" href=\"".freeze); _buf << ((::Temple::Utils.escape_html((_slim_codeattributes1))).to_s); _buf << ("\"".freeze); end; end; _buf << (" rel=\"nofollow\">Trigger a couple</a> <a class=\"btn btn-danger\" data-confirm=\"Sure?\" data-method=\"delete\"".freeze); 
@@ -27,7 +27,7 @@ _buf = ''; _buf << ("<header class=\"mb-3\"><h1>Deprecations</h1><a class=\"btn
 ; 
 ; total = 0; 
 ; by_realm = Hash.new(0); 
-; @deprecations.each do |deprecation|; 
+; deprecations.each do |deprecation|; 
 ; total += 1; 
 ; by_realm[deprecation[:realm]] += 1; 
 ; _buf << ("<tr".freeze); _slim_codeattributes5 = deprecation[:digest]; if _slim_codeattributes5; if _slim_codeattributes5 == true; _buf << (" data-digest=\"\"".freeze); else; _buf << (" data-digest=\"".freeze); _buf << ((::Temple::Utils.escape_html((_slim_codeattributes5))).to_s); _buf << ("\"".freeze); end; end; _buf << ("><td><a".freeze); 
@@ -35,13 +35,13 @@ _buf = ''; _buf << ("<header class=\"mb-3\"><h1>Deprecations</h1><a class=\"btn
 ; _slim_codeattributes6 = deprecation_path(deprecation[:digest]); if _slim_codeattributes6; if _slim_codeattributes6 == true; _buf << (" href=\"\"".freeze); else; _buf << (" href=\"".freeze); _buf << ((::Temple::Utils.escape_html((_slim_codeattributes6))).to_s); _buf << ("\"".freeze); end; end; _buf << (">".freeze); _buf << ((::Temple::Utils.escape_html((deprecation[:count]))).to_s); 
 ; _buf << ("</a><br />".freeze); 
 ; deprecation_tags(deprecation).each_pair do |tag, cls|; 
-; _buf << ("<div".freeze); _temple_html_attributeremover1 = ''; _temple_html_attributemerger1 = []; _temple_html_attributemerger1[0] = "badge"; _temple_html_attributemerger1[1] = ''; _slim_codeattributes7 = cls; if Array === _slim_codeattributes7; _slim_codeattributes7 = _slim_codeattributes7.flatten; _slim_codeattributes7.map!(&:to_s); _slim_codeattributes7.reject!(&:empty?); _temple_html_attributemerger1[1] << ((::Temple::Utils.escape_html((_slim_codeattributes7.join(" ")))).to_s); else; _temple_html_attributemerger1[1] << ((::Temple::Utils.escape_html((_slim_codeattributes7))).to_s); end; _temple_html_attributemerger1[1]; _temple_html_attributeremover1 << ((_temple_html_attributemerger1.reject(&:empty?).join(" ")).to_s); _temple_html_attributeremover1; if !_temple_html_attributeremover1.empty?; _buf << (" class=\"".freeze); _buf << ((_temple_html_attributeremover1).to_s); _buf << ("\"".freeze); end; _buf << (">".freeze); _buf << ((::Temple::Utils.escape_html((tag))).to_s); 
+; _buf << ("<div".freeze); _temple_html_attributeremover1 = ''.dup; _temple_html_attributemerger1 = []; _temple_html_attributemerger1[0] = "badge"; _temple_html_attributemerger1[1] = ''.dup; _slim_codeattributes7 = cls; if Array === _slim_codeattributes7; _slim_codeattributes7 = _slim_codeattributes7.flatten; _slim_codeattributes7.map!(&:to_s); _slim_codeattributes7.reject!(&:empty?); _temple_html_attributemerger1[1] << ((::Temple::Utils.escape_html((_slim_codeattributes7.join(" ")))).to_s); else; _temple_html_attributemerger1[1] << ((::Temple::Utils.escape_html((_slim_codeattributes7))).to_s); end; _temple_html_attributemerger1[1]; _temple_html_attributeremover1 << ((_temple_html_attributemerger1.reject(&:empty?).join(" ")).to_s); _temple_html_attributeremover1; if !_temple_html_attributeremover1.empty?; _buf << (" class=\"".freeze); _buf << ((_temple_html_attributeremover1).to_s); _buf << ("\"".freeze); end; _buf << (">".freeze); _buf << ((::Temple::Utils.escape_html((tag))).to_s); 
 ; 
 ; _buf << ("</div> ".freeze); end; _buf << ("</td><td>".freeze); 
 ; 
-; msg = deprecation[:message]
+; msg = deprecation[:message].to_s
 delete_prefixes = Gem.path + [defined?(Rails) && Rails.root.to_s].compact
-delete_prefixes.each { |path| msg.gsub!(path, '') }
+delete_prefixes.each { |path| msg = msg.gsub(path, '') }
 msg.delete_prefix! deprecation[:gem_traceline].gsub(/:in .+/, ':') if deprecation[:gem_traceline]
 msg.delete_prefix! deprecation[:app_traceline].gsub(/:in .+/, ':') if deprecation[:app_traceline]
 msg.strip!
@@ -100,7 +100,7 @@ msg.delete_prefix!("warning: ")
 ; end; by_realm.each_pair do |realm, count|; 
 ; _buf << ("<a class=\"btn btn-sm btn-outline-secondary\" href=\"?realm=".freeze); _buf << ((::Temple::Utils.escape_html((realm))).to_s); _buf << ("\">".freeze); 
 ; _buf << ((::Temple::Utils.escape_html((realm))).to_s); 
-; _buf << (" <div".freeze); _temple_html_attributeremover2 = ''; _temple_html_attributemerger2 = []; _temple_html_attributemerger2[0] = "badge"; _temple_html_attributemerger2[1] = ''; _slim_codeattributes13 = (count == 0 ? 'bg-success' : 'bg-secondary'); if Array === _slim_codeattributes13; _slim_codeattributes13 = _slim_codeattributes13.flatten; _slim_codeattributes13.map!(&:to_s); _slim_codeattributes13.reject!(&:empty?); _temple_html_attributemerger2[1] << ((::Temple::Utils.escape_html((_slim_codeattributes13.join(" ")))).to_s); else; _temple_html_attributemerger2[1] << ((::Temple::Utils.escape_html((_slim_codeattributes13))).to_s); end; _temple_html_attributemerger2[1]; _temple_html_attributeremover2 << ((_temple_html_attributemerger2.reject(&:empty?).join(" ")).to_s); _temple_html_attributeremover2; if !_temple_html_attributeremover2.empty?; _buf << (" class=\"".freeze); _buf << ((_temple_html_attributeremover2).to_s); _buf << ("\"".freeze); end; _buf << (">".freeze); _buf << ((::Temple::Utils.escape_html((count))).to_s); 
+; _buf << (" <div".freeze); _temple_html_attributeremover2 = ''.dup; _temple_html_attributemerger2 = []; _temple_html_attributemerger2[0] = "badge"; _temple_html_attributemerger2[1] = ''.dup; _slim_codeattributes13 = (count == 0 ? 'bg-success' : 'bg-secondary'); if Array === _slim_codeattributes13; _slim_codeattributes13 = _slim_codeattributes13.flatten; _slim_codeattributes13.map!(&:to_s); _slim_codeattributes13.reject!(&:empty?); _temple_html_attributemerger2[1] << ((::Temple::Utils.escape_html((_slim_codeattributes13.join(" ")))).to_s); else; _temple_html_attributemerger2[1] << ((::Temple::Utils.escape_html((_slim_codeattributes13))).to_s); end; _temple_html_attributemerger2[1]; _temple_html_attributeremover2 << ((_temple_html_attributemerger2.reject(&:empty?).join(" ")).to_s); _temple_html_attributeremover2; if !_temple_html_attributeremover2.empty?; _buf << (" class=\"".freeze); _buf << ((_temple_html_attributeremover2).to_s); _buf << ("\"".freeze); end; _buf << (">".freeze); _buf << ((::Temple::Utils.escape_html((count))).to_s); 
 ; _buf << ("</div> </a> ".freeze); end; if params[:realm] && params[:realm] != ''; 
 ; _buf << ("<a class=\"btn btn-sm btn-outline-primary\" href=\"?realm=\">Other realms     </a> ".freeze); 
 ;