rails6-footnotes 5.0.0

data/lib/rails-footnotes/notes/cookies_note.rb

@@ -0,0 +1,17 @@
+module Footnotes
+  module Notes
+    class CookiesNote < AbstractNote
+      def initialize(controller)
+        @cookies = controller.request.cookies
+      end
+
+      def title
+        "Cookies (#{@cookies.length})"
+      end
+
+      def content
+        mount_table_for_hash(@cookies, :summary => "Debug information for #{title}")
+      end
+    end
+  end
+end

data/lib/rails-footnotes/notes/env_note.rb

@@ -0,0 +1,24 @@
+module Footnotes
+  module Notes
+    class EnvNote < AbstractNote
+      def initialize(controller)
+        @env = controller.request.env.dup
+      end
+
+      def content
+        env_data = @env.map { |k, v|
+          case k
+          when 'HTTP_COOKIE'
+            # Replace HTTP_COOKIE for a link
+            [k.to_s, '<a href="#" style="color:#009" onclick="Footnotes.hideAllAndToggle(\'cookies_debug_info\');return false;">See cookies on its tab</a>']
+          else
+            [k.to_s, escape(v.to_s)]
+          end
+        }.sort.unshift([ :key, escape('value') ])
+
+        # Create the env table
+        mount_table(env_data)
+      end
+    end
+  end
+end

data/lib/rails-footnotes/notes/files_note.rb

@@ -0,0 +1,49 @@
+module Footnotes
+  module Notes
+    class FilesNote < AbstractNote
+      def initialize(controller)
+        @files = scan_text(controller.response.body)
+        parse_files!
+      end
+
+      def row
+        :edit
+      end
+
+      def content
+        if @files.empty?
+          ""
+        else
+          "<ul><li>%s</li></ul>" % @files.join("</li><li>")
+        end
+      end
+
+      def valid?
+        prefix?
+      end
+
+      protected
+        def scan_text(text)
+          raise NotImplementedError, "implement this in your subclass"
+        end
+
+        def parse_files!
+          asset_paths = Rails.application.config.try(:assets).try(:paths) || []
+          linked_files = []
+
+          @files.collect do |file|
+            file.gsub!(/-[a-f0-9]{64}\./, '.')
+            base_name = File.basename(file)
+            asset_paths.each do |asset_path|
+              results = Dir[File.expand_path(base_name, asset_path) + '*']
+              results.each do |r|
+                linked_files << %[<a href="#{Footnotes::Filter.prefix(r, 1, 1)}">#{File.basename(r)}</a>]
+              end
+              break if results.present?
+            end
+          end
+          @files = linked_files
+        end
+    end
+  end
+end

data/lib/rails-footnotes/notes/filters_note.rb

@@ -0,0 +1,51 @@
+module Footnotes
+  module Notes
+    class FiltersNote < AbstractNote
+      def initialize(controller)
+        @controller = controller
+        @parsed_filters = parse_filters
+      end
+
+      def legend
+        "Filter chain for #{@controller.class.to_s}"
+      end
+
+      def content
+        mount_table(@parsed_filters.unshift([:name, :type, :actions]), :summary => "Debug information for #{title}")
+      end
+
+      protected
+        # Get controller filter chain
+        #
+        def parse_filters
+          return [] # TODO @controller.class.filter_chain.collect do |filter|
+#            [parse_method(filter.method), filter.type.inspect, controller_filtered_actions(filter).inspect]
+#          end
+        end
+
+        # This receives a filter, creates a mock controller and check in which
+        # actions the filter is performed
+        #
+        def controller_filtered_actions(filter)
+          mock_controller = Footnotes::Extensions::MockController.new
+
+          return @controller.class.action_methods.select { |action|
+            mock_controller.action_name = action
+
+            #remove conditions (this would call a Proc on the mock_controller)
+            filter.options.merge!(:if => nil, :unless => nil)
+
+            filter.__send__(:should_run_callback?, mock_controller)
+          }.map(&:to_sym)
+        end
+
+        def parse_method(method = '')
+          escape(method.inspect.gsub(RAILS_ROOT, ''))
+        end
+    end
+  end
+
+  module Extensions
+    class MockController < Struct.new(:action_name); end
+  end
+end

data/lib/rails-footnotes/notes/javascripts_note.rb

@@ -0,0 +1,16 @@
+require "rails-footnotes/notes/files_note"
+
+module Footnotes
+  module Notes
+    class JavascriptsNote < FilesNote
+      def title
+        "Javascripts (#{@files.length})"
+      end
+
+      protected
+        def scan_text(text)
+          text.scan(/<script[^>]+src\s*=\s*['"]([^>?'"]+\.js)/im).flatten
+        end
+    end
+  end
+end

data/lib/rails-footnotes/notes/layout_note.rb

@@ -0,0 +1,26 @@
+module Footnotes
+  module Notes
+    class LayoutNote < AbstractNote
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def row
+        :edit
+      end
+
+      def link
+        escape(Footnotes::Filter.prefix(filename, 1, 1))
+      end
+
+      def valid?
+        prefix? && nil#@controller.active_layout TODO doesn't work with Rails 3
+      end
+
+      protected
+        def filename
+          File.join(File.expand_path(Rails.root), 'app', 'layouts', "#{@controller.active_layout.to_s.underscore}").sub('/layouts/layouts/', '/views/layouts/')
+        end
+    end
+  end
+end

data/lib/rails-footnotes/notes/log_note.rb

@@ -0,0 +1,47 @@
+module Footnotes
+  module Notes
+    class LogNote < AbstractNote
+
+      autoload :NoteLogger, 'rails-footnotes/notes/log_note/note_logger'
+
+      cattr_accessor :logs
+      cattr_accessor :original_logger
+
+      def self.start!(controller)
+        self.logs = []
+        self.original_logger = Rails.logger
+        note_logger = NoteLogger.new(self.logs)
+        note_logger.level = self.original_logger.level
+        note_logger.formatter =
+          if self.original_logger.kind_of?(Logger)
+            self.original_logger.formatter
+          else
+            defined?(ActiveSupport::Logger) ? ActiveSupport::Logger::SimpleFormatter.new : Logger::SimpleFormatter.new
+          end
+        # Rails 3 don't have ActiveSupport::Logger#broadcast so we backported it
+        extend_module = defined?(ActiveSupport::Logger) ? ActiveSupport::Logger.broadcast(note_logger) : NoteLogger.broadcast(note_logger)
+        Rails.logger = self.original_logger.clone.extend(extend_module)
+      end
+
+      def title
+        "Log (#{log.count})"
+      end
+
+      def content
+        result = '<table>'
+          log.compact.each do |l|
+            result << "<tr><td>#{l.gsub(/\e\[.+?m/, '')}</td></tr>"
+          end
+        result << '</table>'
+        # Restore formatter
+        Rails.logger = self.class.original_logger
+        result
+      end
+
+      def log
+        self.class.logs
+      end
+
+    end
+  end
+end

data/lib/rails-footnotes/notes/log_note/note_logger.rb

@@ -0,0 +1,59 @@
+module Footnotes
+  module Notes
+    class LogNote
+      class NoteLogger < Logger
+
+        def initialize(logs)
+          @logs = logs
+        end
+
+        def add(severity, message = nil, progname = nil, &block)
+          severity ||= UNKNOWN
+          if severity < level
+            return true
+          end
+          formatter = @formatter || Logger::Formatter.new
+          @logs << formatter.call(format_severity(severity), Time.now, message, progname)
+        end
+
+        ## Backport from rails 4 for handling logging broadcast, should be removed when rails 3 is deprecated :
+
+        # Broadcasts logs to multiple loggers.
+        def self.broadcast(logger) # :nodoc:
+          Module.new do
+            define_method(:add) do |*args, &block|
+              logger.add(*args, &block)
+              super(*args, &block)
+            end
+
+            define_method(:<<) do |x|
+              logger << x
+              super(x)
+            end
+
+            define_method(:close) do
+              logger.close
+              super()
+            end
+
+            define_method(:progname=) do |name|
+              logger.progname = name
+              super(name)
+            end
+
+            define_method(:formatter=) do |formatter|
+              logger.formatter = formatter
+              super(formatter)
+            end
+
+            define_method(:level=) do |level|
+              logger.level = level
+              super(level)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rails-footnotes/notes/params_note.rb

@@ -0,0 +1,21 @@
+module Footnotes
+  module Notes
+    class ParamsNote < AbstractNote
+      def initialize(controller)
+        @params = if Rails::VERSION::MAJOR >= 5
+          controller.params.to_unsafe_h
+        else
+          controller.params
+        end
+      end
+
+      def title
+        "Params (#{@params.length})"
+      end
+
+      def content
+        mount_table_for_hash(@params, :summary => "Debug information for #{title}")
+      end
+    end
+  end
+end

data/lib/rails-footnotes/notes/partials_note.rb

@@ -0,0 +1,38 @@
+module Footnotes
+  module Notes
+    class PartialsNote < AbstractNote
+
+      cattr_accessor :partials
+
+      def self.start!(controller)
+        self.partials = []
+        @subscriber ||= ActiveSupport::Notifications.subscribe('render_partial.action_view') do |*args|
+          event = ActiveSupport::Notifications::Event.new *args
+          self.partials << {:file => event.payload[:identifier], :duration => event.duration}
+        end
+      end
+
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def row
+        :edit
+      end
+
+      def title
+        "Partials (#{partials.size})"
+      end
+
+      def content
+        rows = self.class.partials.map do |partial|
+          href = Footnotes::Filter.prefix(partial[:file],1,1)
+          shortened_name = partial[:file].gsub(File.join(Rails.root,"app/views/"),"")
+          [%{<a href="#{href}">#{shortened_name}</a>},"#{partial[:duration]}ms"]
+        end
+        mount_table(rows.unshift(%w(Partial Time)), :summary => "Partials for #{title}")
+      end
+
+    end
+  end
+end

data/lib/rails-footnotes/notes/queries_note.rb

@@ -0,0 +1,121 @@
+module Footnotes
+  module Notes
+    class QueriesNote < AbstractNote
+      cattr_accessor :alert_db_time, :alert_sql_number, :orm, :ignored_regexps, :instance_writer => false
+      @@alert_db_time    = 16.0
+      @@alert_sql_number = 8
+      @@query_subscriber = nil
+      @@orm              = [:active_record, :data_mapper]
+      @@ignored_regexps  = [%r{(pg_table|pg_attribute|pg_namespace|show\stables|pragma|sqlite_master)}i]
+
+      def self.start!(controller)
+        self.query_subscriber.reset!
+      end
+
+      def self.query_subscriber
+        @@query_subscriber ||= Footnotes::Notes::QuerySubscriber.new(self.orm)
+      end
+
+      def events
+        self.class.query_subscriber.events
+      end
+
+      def title
+        queries = self.events.count
+        total_time = self.events.map(&:duration).sum
+        query_color = alert_color(self.events.count, alert_sql_number)
+        db_color    = alert_color(total_time, alert_db_time)
+
+        <<-TITLE
+        <span style="background-color:#{query_color}">Queries (#{queries})</span>
+        <span style="background-color:#{db_color}">DB (#{"%.3f" % total_time}ms)</span>
+        TITLE
+      end
+
+      def content
+        html = '<table>'
+        self.events.each_with_index do |event, index|
+          sql_links = []
+          sql_links << "<a href=\"javascript:Footnotes.toggle('qtrace_#{index}')\" style=\"color:#00A;\">trace</a>"
+
+          html << <<-HTML
+          <tr>
+            <td>
+              <b id="qtitle_#{index}">#{escape(event.type.to_s.upcase)}</b> (#{sql_links.join(' | ')})
+              <p id="qtrace_#{index}" style="display:none;">#{parse_trace(event.trace)}</p><br />
+            </td>
+            <td>
+              <span id="sql_#{index}">#{print_query(event.payload[:sql])}</span>
+            </td>
+            <td>#{print_name_and_time(event.payload[:name], event.duration)}</td>
+          </tr>
+          HTML
+        end
+        html << '</table>'
+        return html
+      end
+
+      protected
+      def print_name_and_time(name, time)
+        "<span style='background-color:#{alert_color(time, alert_ratio)}'>#{escape(name || 'SQL')} (#{'%.3fms' % time})</span>"
+      end
+
+      def print_query(query)
+        escape(query.to_s.gsub(/(\s)+/, ' ').gsub('`', ''))
+      end
+
+      def alert_color(value, threshold)
+        return 'transparent' if value < threshold
+        '#ffff00'
+      end
+
+      def alert_ratio
+        alert_db_time / alert_sql_number
+      end
+
+      def parse_trace(trace)
+        trace.map do |t|
+          s = t.split(':')
+          %[<a href="#{escape(Footnotes::Filter.prefix("#{Rails.root.to_s}/#{s[0]}", s[1].to_i, 1))}">#{escape(t)}</a><br />]
+        end.join
+      end
+    end
+
+    class QuerySubscriberNotifactionEvent
+      attr_reader :event, :trace, :query
+      delegate :name, :payload, :duration, :time, :type, :to => :event
+
+      def initialize(event, ctrace)
+        @event, @ctrace, @query = event, ctrace, event.payload[:sql]
+      end
+
+      def trace
+        @trace ||= @ctrace.collect(&:strip).select{|i| i.gsub!(/^#{Rails.root.to_s}\//, '') } || []
+      end
+
+      def type
+        @type ||= self.query.match(/^(\s*)(select|insert|update|delete|alter)\b/im) || 'Unknown'
+      end
+    end
+
+    class QuerySubscriber < ActiveSupport::LogSubscriber
+      attr_accessor :events, :ignore_regexps
+
+      def initialize(orm)
+        super()
+        @events = []
+        orm.each {|adapter| ActiveSupport::LogSubscriber.attach_to adapter, self}
+      end
+
+      def reset!
+        self.events.clear
+      end
+
+      def sql(event)
+        unless QueriesNote.ignored_regexps.any? {|rex| event.payload[:sql] =~ rex }
+          @events << QuerySubscriberNotifactionEvent.new(event.dup, caller)
+        end
+      end
+    end
+  end
+end