lexrupy-rails-footnotes 3.3.2

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

@@ -0,0 +1,16 @@
+require "#{File.dirname(__FILE__)}/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,33 @@
+require "#{File.dirname(__FILE__)}/view_note"
+
+module Footnotes
+  module Notes
+    class LayoutNote < AbstractNote
+      def initialize(controller)
+        @controller = controller
+        @template = controller.instance_variable_get('@template')
+      end
+
+      def row
+        :edit
+      end
+
+      def link
+        escape(Footnotes::Filter.prefix(layout_filename, 1, 1))
+      end
+
+      def valid?
+        prefix? && @controller.active_layout && layout_template
+      end
+
+      protected
+        def layout_template
+          @layout_template ||= @template.send(:_pick_template, @controller.active_layout)
+        end
+
+        def layout_filename
+          layout_template.filename
+        end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class LogNote < AbstractNote
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def content
+        escape(log_tail).gsub("\n","<br />")
+      end
+
+      protected
+        def log_tail
+          filename = if RAILS_DEFAULT_LOGGER.instance_variable_get('@log')
+            RAILS_DEFAULT_LOGGER.instance_variable_get('@log').path
+          else 
+            RAILS_DEFAULT_LOGGER.instance_variable_get('@logdev').filename
+          end
+          file_string = File.open(filename).read.to_s
+
+          # We try to select the specified action from the log
+          # If we can't find it, we get the last 100 lines
+          #
+          if rindex = file_string.rindex('Processing '+@controller.controller_class_name+'#'+@controller.action_name)
+            file_string[rindex..-1].gsub(/\e\[.+?m/, '')
+          else
+            lines = file_string.split("\n")
+            index = [lines.size-100,0].max
+            lines[index..-1].join("\n")
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class ParamsNote < AbstractNote
+      def initialize(controller)
+        @params = controller.params.symbolize_keys
+      end
+
+      def title
+        "Params (#{@params.length})"
+      end
+
+      def content
+        escape(@params.inspect)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class QueriesNote < AbstractNote
+      @@sql = []
+      cattr_accessor :sql
+
+      def self.start!(controller)
+        @@sql = []
+      end
+
+      def self.to_sym
+        :queries
+      end
+
+      def title
+        "Queries (#{@@sql.length})"
+      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 javascript
+<<-JAVASCRIPT
+  function queries_toogle(type, id){
+    s = document.getElementById('q'+type+'_'+id).style
+    s.display = (s.display != 'block') ? 'block' : 'none'
+    location.href = '#qtitle_'+id
+  }
+JAVASCRIPT
+      end
+
+      def content
+        html = ''
+
+        @@sql.each_with_index do |item, i|
+          sql_links = []
+          sql_links << "<a href=\"#\" style=\"color:#A00;\" onclick=\"queries_toogle('table',#{i});return false\">explain</a>" if item.explain
+          sql_links << "<a href=\"#\" style=\"color:#00A;\" onclick=\"queries_toogle('trace',#{i});return false\">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 />
+  #{print_query(item.query)}<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
+
+      protected
+        def parse_explain(results)
+          table = []
+          table << results.fetch_fields.map(&:name)
+          results.each{|row| table << row}
+          table
+        end
+
+        def parse_trace(trace)
+          trace.map do |t|
+            s = t.split(':')
+            %[<a href="#{escape(Footnotes::Filter.prefix("#{RAILS_ROOT}/#{s[0]}", s[1].to_i, 1))}">#{escape(t)}</a><br />]
+          end.join
+        end
+
+        def print_name_and_time(name, time)
+          "#{escape(name || 'SQL')} (#{sprintf('%f', time)}s)"
+        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;')
+        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
+            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
+
+if Footnotes::Notes::QueriesNote.included?
+  ActiveRecord::ConnectionAdapters::AbstractAdapter.send :include, Footnotes::Extensions::AbstractAdapter
+  ActiveRecord::ConnectionAdapters.local_constants.each do |adapter|
+    next unless adapter =~ /.*[^Abstract]Adapter$/
+    next if adapter =~ /SQLite.Adapter$/
+    eval("ActiveRecord::ConnectionAdapters::#{adapter}").send :include, Footnotes::Extensions::QueryAnalyzer
+  end
+end

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

@@ -0,0 +1,59 @@
+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]))
+      end
+
+      protected
+        def parse_routes
+          routes_with_name = ActionController::Routing::Routes.named_routes.to_a.flatten
+
+          return ActionController::Routing::Routes.filtered_routes(:controller => @controller.controller_name).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 = {}
+            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]
+          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/session_note.rb

@@ -0,0 +1,15 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class SessionNote < AbstractNote
+      def initialize(controller)
+        @session = (controller.session.instance_variable_get("@data") || {}).symbolize_keys
+      end
+
+      def content
+        escape(@session.inspect)
+      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,33 @@
+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/test/footnotes_test.rb

@@ -0,0 +1,199 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+require 'action_controller'
+require 'action_controller/test_case'
+require 'action_controller/test_process'
+
+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.request = ActionController::TestRequest.new
+    @controller.response = ActionController::TestResponse.new
+    @controller.response.body = $html.dup
+
+    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&line=%d&column=%d', Footnotes::Filter.prefix
+    assert_equal 'txmt://open?url=file://file&line=0&column=0', Footnotes::Filter.prefix('file', 0, 0)
+    assert_equal 'txmt://open?url=file://file&line=10&column=10', Footnotes::Filter.prefix('file', 10, 10)
+    assert_equal 'txmt://open?url=file://file&line=10&column=10', Footnotes::Filter.prefix('file', 10, 10, 10)
+    assert_equal 'txmt://open?url=file://file&line=10&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 'Footnotes::Notes::TestNote', test_note.class
+    assert :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_toogle(\'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\n"
+    assert_equal after, @controller.response.body.to_a[2]
+
+    @footnotes.send(:insert_text, :before, /<\/body>/, "Notes")
+    after = "    Notes</body>\n"
+    assert_equal after, @controller.response.body.to_a[12]
+  end
+  
+  protected
+    # First we make sure that footnotes will perform (long life to mocha!)
+    # Then we call add_footnotes!
+    #
+    def footnotes_perform!
+      @controller.template.expects(:instance_variable_get).returns(true)
+      @controller.template.expects(:template_format).returns('html')
+      @controller.performed_render = true
+
+      Footnotes::Filter.start!(@controller)
+      @footnotes.add_footnotes!
+    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