rails3-footnotes 4.0.0.pre

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

@@ -0,0 +1,187 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class QueriesNote < AbstractNote
+      @@alert_db_time = 0.16
+      @@alert_sql_number = 8
+      @@sql = []
+      @@include_when_new_relic_installed = false
+      @@loaded = false
+      
+      cattr_accessor :sql, :alert_db_time, :alert_sql_number, :alert_explain, :loaded, :sql_explain, :instance_writter => false
+      cattr_reader :include_when_new_relic_installed
+      
+      def self.include_when_new_relic_installed=(include_me)
+        @@include_when_new_relic_installed = include_me
+        load if include_me
+      end
+      
+      def self.start!(controller)
+        @@sql = []
+      end
+
+      def self.to_sym
+        :queries
+      end
+
+      def title
+        db_time = @@sql.inject(0){|sum, item| sum += item.time }
+        query_color = generate_red_color(@@sql.length, alert_sql_number)
+        db_color    = generate_red_color(db_time, alert_db_time)
+
+        <<-TITLE
+  <span style="background-color:#{query_color}">Queries (#{@@sql.length})</span> 
+  <span style="background-color:#{db_color}">DB (#{"%.6f" % db_time}s)</span>
+        TITLE
+      end
+
+      def stylesheet
+        <<-STYLESHEET
+  #queries_debug_info table td, #queries_debug_info table th{border:1px solid #A00; padding:0 3px; text-align:center;}
+  #queries_debug_info table thead, #queries_debug_info table tbody {color:#A00;}
+  #queries_debug_info p {background-color:#F3F3FF; border:1px solid #CCC; margin:12px; padding:4px 6px;}
+  #queries_debug_info a:hover {text-decoration:underline;}
+        STYLESHEET
+      end
+
+      def content
+        html = ''
+
+        @@sql.each_with_index do |item, i|
+          sql_links = []
+          sql_links << "<a href=\"javascript:Footnotes.toggle('qtable_#{i}')\" style=\"color:#A00;\">explain</a>" if item.explain
+          sql_links << "<a href=\"javascript:Footnotes.toggle('qtrace_#{i}')\" style=\"color:#00A;\">trace</a>" if item.trace
+
+          html << <<-HTML
+  <b id="qtitle_#{i}">#{escape(item.type.to_s.upcase)}</b> (#{sql_links.join(' | ')})<br />
+  #{print_name_and_time(item.name, item.time)}<br />
+  <span id="explain_#{i}">#{print_query(item.query)}</span><br />
+  #{print_explain(i, item.explain) if item.explain}
+  <p id="qtrace_#{i}" style="display:none;">#{parse_trace(item.trace) if item.trace}</p><br />
+          HTML
+        end
+
+        return html
+      end
+      
+      def self.load
+        #only include when NewRelic is installed if configured to do so
+        if !loaded and included? and defined?(ActiveRecord)
+          ActiveRecord::ConnectionAdapters::AbstractAdapter.send :include, Footnotes::Extensions::AbstractAdapter
+          ActiveRecord::ConnectionAdapters.local_constants.each do |adapter|
+            next unless adapter =~ /.*[^Abstract]Adapter$/
+            next if adapter =~ /(SQLite|Salesforce)Adapter$/
+            eval("ActiveRecord::ConnectionAdapters::#{adapter}").send :include, Footnotes::Extensions::QueryAnalyzer
+            self.loaded = true
+          end
+        end
+      end
+      
+      protected
+        def parse_explain(results)
+          table = []
+          table << results.fetch_fields.map(&:name)
+          results.each do |row|
+            table << row
+          end
+          table
+        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
+
+        def print_name_and_time(name, time)
+          "<span style='background-color:#{generate_red_color(time, alert_ratio)}'>#{escape(name || 'SQL')} (#{sprintf('%f', time)}s)</span>"
+        end
+
+        def print_query(query)
+          escape(query.to_s.gsub(/(\s)+/, ' ').gsub('`', ''))
+        end
+
+        def print_explain(i, explain)
+          mount_table(parse_explain(explain), :id => "qtable_#{i}", :style => 'margin:10px;display:none;', :summary => "Debug information for #{title}")
+        end
+
+        def generate_red_color(value, alert)
+          c = ((value.to_f/alert).to_i - 1) * 16
+          c = 0  if c < 0
+          c = 15 if c > 15
+
+          c = (15-c).to_s(16)
+          "#ff#{c*4}"
+        end
+
+        def alert_ratio
+          alert_db_time / alert_sql_number
+        end
+
+    end
+  end
+
+  module Extensions
+    class Sql
+      attr_accessor :type, :name, :time, :query, :explain, :trace
+
+      def initialize(type, name, time, query, explain)
+        @type = type
+        @name = name
+        @time = time
+        @query = query
+        @explain = explain
+
+        # Strip, select those ones from app and reject first two, because they
+        # are from the plugin
+        @trace = Kernel.caller.collect(&:strip).select{|i| i.gsub!(/^#{Rails.root}\//im, '') }[2..-1]
+      end
+    end
+
+    module QueryAnalyzer
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :execute, :analyzer
+        end
+      end
+
+      def execute_with_analyzer(query, name = nil)
+        query_results = nil
+        time = Benchmark.realtime { query_results = execute_without_analyzer(query, name) }
+
+        if query =~ /^(select|create|update|delete)\b/i
+          type = $&.downcase.to_sym
+          explain = nil
+
+          if adapter_name == 'MySQL' && type == :select && Footnotes::Notes::QueriesNote.sql_explain
+            log_silence do
+              explain = execute_without_analyzer("EXPLAIN #{query}", name)
+            end
+          end
+          Footnotes::Notes::QueriesNote.sql << Footnotes::Extensions::Sql.new(type, name, time, query, explain)
+        end
+
+        query_results
+      end
+    end
+
+    module AbstractAdapter
+      def log_silence
+        result = nil
+        if @logger
+          @logger.silence do
+            result = yield
+          end
+        else
+          result = yield
+        end
+        result
+      end
+    end
+
+  end
+end
+
+Footnotes::Notes::QueriesNote.load

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

@@ -0,0 +1,63 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class RoutesNote < AbstractNote
+      def initialize(controller)
+        @controller = controller
+        @parsed_routes = parse_routes
+      end
+
+      def legend
+        "Routes for #{@controller.class.to_s}"
+      end
+
+      def content
+        mount_table(@parsed_routes.unshift([:path, :name, :options, :requirements]), :summary => "Debug information for #{title}")
+      end
+
+      protected
+        def parse_routes
+          routes_with_name = Rails.application.routes.named_routes.to_a.flatten
+
+          return Rails.application.routes.filtered_routes(:controller => @controller.controller_path).collect do |route|
+            # Catch routes name if exists
+            i = routes_with_name.index(route)
+            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
+          end
+        end
+    end
+  end
+
+  module Extensions
+    module Routes
+      # 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 == filter) || (filter_diff != route_diff)
+        end
+      end
+    end
+  end
+end
+
+if Footnotes::Notes::RoutesNote.included?
+  ActionController::Routing::RouteSet.send :include, Footnotes::Extensions::Routes
+end

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

@@ -0,0 +1,30 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+if defined?(NewRelic)
+module Footnotes
+  module Notes
+    class RpmNote < AbstractNote
+      def initialize(controller)
+        @rpm_id=NewRelic::Agent.instance.transaction_sampler.current_sample_id
+      end
+
+      def row
+        :edit
+      end
+
+      def link
+         #{:controller => 'newrelic', :action => 'show_sample_detail', :id => @rpm_id}
+         "/newrelic/show_sample_detail/#{@rpm_id}" if @rpm_id
+      end
+      
+      def valid?
+        if defined?(NewRelic::Control)
+          !NewRelic::Control.instance['skip_developer_route']
+        else
+          !NewRelic::Config.instance['skip_developer_route']
+        end
+      end
+    end
+  end
+end
+end

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

@@ -0,0 +1,29 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class SessionNote < AbstractNote
+      def initialize(controller)
+        session = controller.session
+        if session
+          if session.respond_to? :to_hash
+            # rails >= 2.3
+            session = session.to_hash
+          else
+            #rails < 2.3
+            session = session.data
+          end
+        end
+        @session = (session || {}).symbolize_keys
+      end
+
+      def title
+        "Session (#{@session.length})"
+      end
+
+      def content
+        mount_table_for_hash(@session, :summary => "Debug information for #{title}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require "#{File.dirname(__FILE__)}/files_note"
+
+module Footnotes
+  module Notes
+    class StylesheetsNote < FilesNote
+      def title
+        "Stylesheets (#{@files.length})"
+      end
+
+      protected
+        def scan_text(text)
+          text.scan(/<link[^>]+href\s*=\s*['"]([^>?'"]+\.css)/im).flatten
+        end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class ViewNote < AbstractNote
+      def initialize(controller)
+        @controller = controller
+        @template = controller.instance_variable_get(:@template)
+      end
+
+      def row
+        :edit
+      end
+
+      def link
+        escape(Footnotes::Filter.prefix(filename, 1, 1))
+      end
+
+      def valid?
+        prefix? && first_render?
+      end
+
+      protected
+
+        def first_render?
+          @template.instance_variable_get(:@_first_render)
+        end
+
+        def filename
+          @filename ||= @template.instance_variable_get(:@_first_render).filename
+        end
+
+    end
+  end
+end

data/lib/rails-footnotes.rb

@@ -0,0 +1,22 @@
+module Footnotes
+  
+  # The footnotes are applied by default to all actions. You can change this
+  # behavior commenting the after_filter line below and putting it in Your
+  # application. Then you can cherrypick in which actions it will appear.
+  #
+  module RailsFootnotesExtension
+    def self.included(base)
+      base.prepend_before_filter Footnotes::BeforeFilter
+      base.after_filter Footnotes::AfterFilter
+    end
+  end
+  
+  def self.run!
+    require 'rails-footnotes/footnotes'
+    require 'rails-footnotes/backtracer'
+     
+    Dir[File.join(File.dirname(__FILE__), 'rails-footnotes', 'notes', '*.rb')].each { |note| require note }
+    
+    ActionController::Base.send(:include, RailsFootnotesExtension)    
+  end
+end

data/test/footnotes_test.rb

@@ -0,0 +1,207 @@
+require 'test_helper'
+
+require 'action_controller'
+require 'action_controller/test_case'
+
+class FootnotesController < ActionController::Base; attr_accessor :template, :performed_render; end
+
+module Footnotes::Notes
+  class TestNote < AbstractNote
+    def self.to_sym; :test; end
+    def valid?; true; end
+  end
+end
+
+class FootnotesTest < Test::Unit::TestCase
+  def setup
+    @controller = FootnotesController.new
+    @controller.template = Object.new
+    @controller.request = ActionController::TestRequest.new
+    @controller.response = ActionController::TestResponse.new
+    @controller.response.body = $html.dup
+    @controller.params = {}
+
+    Footnotes::Filter.notes = [ :test ]
+    Footnotes::Filter.multiple_notes = false
+    @footnotes = Footnotes::Filter.new(@controller)
+  end
+
+  def test_footnotes_controller
+    index = @controller.response.body.index(/This is the HTML page/)
+    assert_equal 334, index
+  end
+  
+  def test_foonotes_included
+    footnotes_perform!
+    assert_not_equal $html, @controller.response.body
+  end
+
+  def test_footnotes_not_included_when_request_is_xhr
+    @controller.request.env['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
+    @controller.request.env['HTTP_ACCEPT'] = 'text/javascript, text/html, application/xml, text/xml, */*'
+
+    footnotes_perform!
+    assert_equal $html, @controller.response.body
+  end
+
+  def test_footnotes_not_included_when_content_type_is_javascript
+    @controller.response.headers['Content-Type'] = 'text/javascript'
+
+    footnotes_perform!
+    assert_equal $html, @controller.response.body
+  end
+
+  def test_footnotes_included_when_content_type_is_html
+    @controller.response.headers['Content-Type'] = 'text/html'
+
+    footnotes_perform!
+    assert_not_equal $html, @controller.response.body
+  end
+
+  def test_footnotes_included_when_content_type_is_nil
+    footnotes_perform!
+    assert_not_equal $html, @controller.response.body
+  end
+
+  def test_not_included_when_body_is_not_a_string
+    @controller.response.body = Proc.new{ Time.now }
+    assert_nothing_raised do
+      footnotes_perform!
+    end
+  end
+
+  def test_footnotes_prefix
+    assert_equal 'txmt://open?url=file://%s&amp;line=%d&amp;column=%d', Footnotes::Filter.prefix
+    assert_equal 'txmt://open?url=file://file&amp;line=0&amp;column=0', Footnotes::Filter.prefix('file', 0, 0)
+    assert_equal 'txmt://open?url=file://file&amp;line=10&amp;column=10', Footnotes::Filter.prefix('file', 10, 10)
+    assert_equal 'txmt://open?url=file://file&amp;line=10&amp;column=10', Footnotes::Filter.prefix('file', 10, 10, 10)
+    assert_equal 'txmt://open?url=file://file&amp;line=10&amp;column=10', Footnotes::Filter.prefix('file', '10', '10')
+  end
+
+  def test_notes_are_initialized
+    footnotes_perform!
+    test_note = @footnotes.instance_variable_get('@notes').first
+    assert_equal 'Footnotes::Notes::TestNote', test_note.class.name
+    assert_equal :test, test_note.to_sym
+  end
+
+  def test_notes_links
+    note = Footnotes::Notes::TestNote.new
+    note.expects(:row).times(2)
+    @footnotes.instance_variable_set(:@notes, [note])
+    footnotes_perform!
+  end
+
+  def test_notes_fieldset
+    note = Footnotes::Notes::TestNote.new
+    note.expects(:has_fieldset?).times(3)
+    @footnotes.instance_variable_set(:@notes, [note])
+    footnotes_perform!
+  end
+
+  def test_multiple_notes
+    Footnotes::Filter.multiple_notes = true
+    note = Footnotes::Notes::TestNote.new
+    note.expects(:has_fieldset?).times(2)
+    @footnotes.instance_variable_set(:@notes, [note])
+    footnotes_perform!
+  end
+
+  def test_notes_are_reset
+    note = Footnotes::Notes::TestNote.new
+    note.class.expects(:close!)
+    @footnotes.instance_variable_set(:@notes, [note])
+    @footnotes.send(:close!, @controller)
+  end
+
+  def test_links_helper
+    note = Footnotes::Notes::TestNote.new
+    assert_equal '<a href="#" onclick="">Test</a>', @footnotes.send(:link_helper, note)
+
+    note.expects(:link).times(1).returns(:link)
+    assert_equal '<a href="link" onclick="">Test</a>', @footnotes.send(:link_helper, note)
+  end
+
+  def test_links_helper_has_fieldset?
+    note = Footnotes::Notes::TestNote.new
+    note.expects(:has_fieldset?).times(1).returns(true)
+    assert_equal '<a href="#" onclick="Footnotes.hideAllAndToggle(\'test_debug_info\');return false;">Test</a>', @footnotes.send(:link_helper, note)
+  end
+
+  def test_links_helper_onclick
+    note = Footnotes::Notes::TestNote.new
+    note.expects(:onclick).times(2).returns(:onclick)
+    assert_equal '<a href="#" onclick="onclick">Test</a>', @footnotes.send(:link_helper, note)
+
+    note.expects(:has_fieldset?).times(1).returns(true)
+    assert_equal '<a href="#" onclick="onclick">Test</a>', @footnotes.send(:link_helper, note)
+  end
+
+  def test_insert_style
+    @controller.response.body = "<head></head><split><body></body>"
+    @footnotes = Footnotes::Filter.new(@controller)
+    footnotes_perform!
+    assert @controller.response.body.split('<split>').first.include?('<!-- Footnotes Style -->')
+  end
+
+  def test_insert_footnotes_inside_body
+    @controller.response.body = "<head></head><split><body></body>"
+    @footnotes = Footnotes::Filter.new(@controller)
+    footnotes_perform!
+    assert @controller.response.body.split('<split>').last.include?('<!-- End Footnotes -->')
+  end
+
+  def test_insert_footnotes_inside_holder
+    @controller.response.body = "<head></head><split><div id='footnotes_holder'></div>"
+    @footnotes = Footnotes::Filter.new(@controller)
+    footnotes_perform!
+    assert @controller.response.body.split('<split>').last.include?('<!-- End Footnotes -->')
+  end
+
+  def test_insert_text
+    @footnotes.send(:insert_text, :after, /<head>/, "Graffiti")
+    after = "    <head>Graffiti"
+    assert_equal after, @controller.response.body.split("\n")[2]
+
+    @footnotes.send(:insert_text, :before, /<\/body>/, "Notes")
+    after = "    Notes</body>"
+    assert_equal after, @controller.response.body.split("\n")[12]
+  end
+  
+  protected
+    # First we make sure that footnotes will perform (long life to mocha!)
+    # Then we call add_footnotes!
+    #
+    def footnotes_perform!
+      template_expects('html')
+      @controller.performed_render = true
+
+      Footnotes::Filter.start!(@controller)
+      @footnotes.add_footnotes!
+    end
+
+    def template_expects(format)
+      if @controller.template.respond_to?(:template_format)
+        @controller.template.expects(:template_format).returns(format)
+      else
+        @controller.template.expects(:format).returns(format)
+      end
+    end
+end
+
+$html = <<HTML
+<!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>
+HTML