rails-footnotes 3.7.9 → 4.0.0

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

@@ -1,14 +1,21 @@
 module Footnotes
   module Notes
     class LogNote < AbstractNote
-      @@log = []
 
-      def self.log(message)
-        @@log << message
-      end
+      autoload :NoteLogger, 'rails-footnotes/notes/log_note/note_logger'
+
+      cattr_accessor :logs
+      cattr_accessor :original_logger
 
-      def initialize(controller)
-        @controller = controller
+      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 = self.original_logger.kind_of?(Logger) ? self.original_logger.formatter : Logger::SimpleFormatter.new
+        # 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.dup.extend(extend_module)
       end
 
       def title
@@ -16,30 +23,16 @@ module Footnotes
       end
 
       def content
-        escape(log.gsub(/\e\[.+?m/, '')).gsub("\n", '<br />')
+        result = escape(log.gsub(/\e\[.+?m/, '')).gsub("\n", '<br />')
+        # Restore formatter
+        Rails.logger = self.class.original_logger
+        result
       end
 
       def log
-        unless @log
-          @log = @@log.join('')
-          @@log = []
-          if rindex = @log.rindex('Processing '+@controller.class.name+'#'+@controller.action_name)
-            @log = @log[rindex..-1]
-          end
-        end
-        @log
+        self.class.logs.join("\n")
       end
 
-      module LoggingExtensions
-        def add(*args, &block)
-          logged_message = super
-          Footnotes::Notes::LogNote.log(logged_message)
-          logged_message
-        end
-      end
-
-      Rails.logger.extend LoggingExtensions
     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/partials_note.rb

@@ -1,56 +1,38 @@
-require 'rails-footnotes/notes/log_note'
-
 module Footnotes
   module Notes
-    class PartialsNote < LogNote
+    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)
-        super
         @controller = controller
       end
+
       def row
         :edit
       end
+
       def title
         "Partials (#{partials.size})"
       end
+
       def content
-        rows = partials.map do |filename|
-          href = Footnotes::Filter.prefix(filename,1,1)
-          shortened_name=filename.gsub(File.join(Rails.root,"app/views/"),"")
-          [%{<a href="#{href}">#{shortened_name}</a>},"#{@partial_times[filename].sum}ms",@partial_counts[filename]]
+        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 Count)), :summary => "Partials for #{title}")
+        mount_table(rows.unshift(%w(Partial Time)), :summary => "Partials for #{title}")
       end
 
-      protected
-        #Generate a list of partials that were rendered, also build up render times and counts.
-        #This is memoized so we can use its information in the title easily.
-        def partials
-          @partials ||= begin
-            partials = []
-            @partial_counts = {}
-            @partial_times = {}
-            log_lines = log
-            log_lines.split("\n").each do |line|
-              if line =~ /Rendered (\S*) \(([\d\.]+)\S*?\)/
-                partial = $1
-                @controller.view_paths.each do |view_path|
-                  path = File.join(view_path.to_s, "#{partial}*")
-                  files = Dir.glob(path)
-                  for file in files
-                    #TODO figure out what format got rendered if theres multiple
-                    @partial_times[file] ||= []
-                    @partial_times[file] << $2.to_f
-                    @partial_counts[file] ||= 0
-                    @partial_counts[file] += 1
-                    partials << file unless partials.include?(file)
-                  end
-                end
-              end
-            end
-            partials.reverse
-          end
-        end
     end
   end
 end

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

@@ -6,7 +6,7 @@ module Footnotes
       @@alert_sql_number = 8
       @@query_subscriber = nil
       @@orm              = [:active_record, :data_mapper]
-      @@ignored_regexps  = [%r{(pg_table|pg_attribute|show\stables|pragma|sqlite_master)}i]
+      @@ignored_regexps  = [%r{(pg_table|pg_attribute|pg_namespace|show\stables|pragma|sqlite_master)}i]
 
       def self.start!(controller)
         self.query_subscriber.reset!

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

@@ -24,17 +24,8 @@ module Footnotes
             name = i ? routes_with_name[i-1].to_s : ''
 
             # Catch segments requirements
-            req = {}
-            if Rails.version < '3.0'
-              route.segments.each do |segment|
-                next unless segment.is_a?(ActionController::Routing::DynamicSegment) && segment.regexp
-                req[segment.key.to_sym] = segment.regexp
-              end
-              [escape(name), route.segments.join, route.requirements.reject{|key,value| key == :controller}.inspect, req.inspect]
-            else
-              req = route.conditions
-              [escape(name), route.conditions.keys.join, route.requirements.reject{|key,value| key == :controller}.inspect, req.inspect]
-            end
+            req = route.conditions
+            [escape(name), route.conditions.keys.join, route.requirements.reject{|key,value| key == :controller}.inspect, req.inspect]
           end
         end
     end
@@ -42,13 +33,21 @@ module Footnotes
 
   module Extensions
     module Routes
+
+      def __hash_diff(hash_self, other)
+        # ActiveSupport::Deprecation.warn "Hash#diff is no longer used inside of Rails,
+        # and is being deprecated with no replacement. If you're using it to compare hashes for the purpose of testing, please use MiniTest's diff instead."
+        hash_self.dup.delete_if { |k, v| other[k] == v }.merge!(other.dup.delete_if { |k, v| hash_self.has_key?(k) })
+      end
+
       # Filter routes according to the filter sent
       #
       def filtered_routes(filter = {})
         return [] unless filter.is_a?(Hash)
         return routes.reject do |r|
-          filter_diff = filter.diff(r.requirements)
-          route_diff  = r.requirements.diff(filter)
+          filter_diff = __hash_diff(filter, r.requirements)
+          route_diff  = __hash_diff(r.requirements, filter)
+
           (filter_diff == filter) || (filter_diff != route_diff)
         end
       end
@@ -57,5 +56,5 @@ module Footnotes
 end
 
 if Footnotes::Notes::RoutesNote.included?
-  ActionController::Routing::RouteSet.send :include, Footnotes::Extensions::Routes
+  ActionDispatch::Routing::RouteSet.send :include, Footnotes::Extensions::Routes
 end

data/lib/rails-footnotes/version.rb

@@ -1,3 +1,3 @@
 module Footnotes
-  VERSION = "3.7.9"
+  VERSION = "4.0.0"
 end

data/rails-footnotes.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.name        = "rails-footnotes"
   s.version     = Footnotes::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Roman V. Babenko", "José Valim", "Keenan Brock", "Duane Johnson"]
+  s.authors     = ["Roman V. Babenko", "José Valim", "Keenan Brock", "Duane Johnson", "Adrien Siami"]
   s.email       = ["romanvbabenko@gmail.com"]
   s.homepage    = "http://github.com/josevalim/rails-footnotes"
   s.summary     = %q{Every Rails page has footnotes that gives information about your application and links back to your editor.}
@@ -14,14 +14,13 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "rails-footnotes"
 
-  s.add_dependency "rails", ">= 3.0.0"
+  s.add_dependency "rails", ">= 3.2"
 
-  s.add_development_dependency "rails", ">= 3.0.0"
-  s.add_development_dependency "rspec", "~> 2.9.0"
+  s.add_development_dependency "rspec-rails"
+  s.add_development_dependency "capybara"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 end
-

data/spec/abstract_note_spec.rb

@@ -3,9 +3,14 @@ require "spec_helper"
 describe Footnotes::Notes::AbstractNote do
   before do
     @note = Footnotes::Notes::AbstractNote.new
+    @notes = Footnotes::Filter.notes
     Footnotes::Filter.notes = [:abstract]
   end
 
+  after do
+    Footnotes::Filter.notes = @notes
+  end
+
   it {described_class.should respond_to :start!}
   it {described_class.should respond_to :close!}
   it {described_class.should respond_to :title}

data/spec/controllers/footnotes_controller_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+class FootnotesController < ActionController::Base
+
+  def foo
+    render :text => HTML_DOCUMENT, :content_type => 'text/html'
+  end
+
+  def foo_holder
+    render :text => '<html><body><div id="footnotes_holder"></div></body></html>'
+  end
+
+  def foo_js
+    render :text => '<script></script>', :content_type => 'text/javascript'
+  end
+
+  def foo_download
+    send_file Rails.root.join('spec', 'fixtures', 'html_download.html'), :disposition => 'attachment'
+  end
+
+end
+
+describe FootnotesController do
+
+  def page
+    Capybara::Node::Simple.new(response.body)
+  end
+
+  shared_examples 'has_footnotes' do
+    it 'includes footnotes' do
+      get :foo
+      response.body.should have_selector('#footnotes_debug')
+    end
+  end
+
+  shared_examples 'has_no_footnotes' do
+    it 'does not include footnotes' do
+      response.body.should_not have_selector('#footnotes_debug')
+    end
+  end
+
+  it 'does not alter the page by default' do
+    get :foo
+    response.body.should == HTML_DOCUMENT
+  end
+
+  context 'with footnotes' do
+
+    before :all do
+      Footnotes.enabled = true
+    end
+
+    after :all do
+      Footnotes.enabled = false
+    end
+
+    describe 'by default' do
+      include_context 'has_footnotes'
+
+      before do
+        get :foo
+      end
+
+      it 'includes footnotes in the last div in body' do
+        all('body > :last-child')[0][:id].should == 'footnotes_debug'
+      end
+
+      it 'includes footnotes in the footnoted_holder div if present' do
+        get :foo_holder
+        response.body.should have_selector('#footnotes_holder > #footnotes_debug')
+      end
+
+      it 'does not alter a html file download' do
+        get :foo_download
+        response.body.should == File.open(Rails.root.join('spec', 'fixtures', 'html_download.html')).read
+      end
+    end
+
+    describe 'when request is xhr' do
+      include_context 'has_no_footnotes'
+      before do
+        xhr :get, :foo
+      end
+    end
+
+    describe 'when content type is javascript' do
+      include_context 'has_no_footnotes'
+      before do
+        get :foo_js
+      end
+    end
+
+  end
+
+end
+
+
+HTML_DOCUMENT = <<EOF
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+    <head>
+        <title>HTML to XHTML Example: HTML page</title>
+        <link rel="Stylesheet" href="htmltohxhtml.css" type="text/css" media="screen">
+        <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
+    </head>
+    <body>
+        <p>This is the HTML page. It works and is encoded just like any HTML page you
+         have previously done. View <a href="htmltoxhtml2.htm">the XHTML version</a> of
+         this page to view the difference between HTML and XHTML.</p>
+        <p>You will be glad to know that no changes need to be made to any of your CSS files.</p>
+    </body>
+</html>
+EOF

data/spec/controllers/log_note_controller_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'stringio'
+
+describe 'log note' do
+
+  class ApplicationController < ActionController::Base
+  end
+
+  controller do
+    def index
+      Rails.logger.error 'foo'
+      Rails.logger.warn 'bar'
+      render :text => '<html><head></head><body></body></html>', :content_type => 'text/html'
+    end
+  end
+
+  def page
+    Capybara::Node::Simple.new(response.body)
+  end
+
+  before :all do
+    Footnotes.enabled = true
+  end
+
+  after :all do
+    Footnotes.enabled = false
+  end
+
+  before do
+    @original_logger = Rails.logger
+    Rails.logger = Logger.new(StringIO.new)
+  end
+
+  after do
+    Rails.logger = @original_logger
+  end
+
+  it 'Includes the log in the response' do
+    get :index
+    log_debug = first('fieldset#log_debug_info div', :visible => false)
+    log_debug.should have_content('foo')
+    log_debug.should have_content('bar')
+  end
+
+end