rails3-footnotes 4.0.0.pre

data/CHANGELOG

@@ -0,0 +1,81 @@
+== Footnotes v3.6.7
+  * fixed log_note error - long overdue (thanks to many including Moritz Heidkamp)
+  * 1.9: ignore more assigns (thanks to justin case)
+  * 1.9 fixed test mocking (thanks to lsylvester)
+  * sort notes includes (thanks Alexey Smolianiov)
+  * handle controller paths in gems / others (thanks ubilabs)
+  * more graceful fallback when controller not found
+  * fixes for table entries being double encoded
+  * moved rpm exclude sql explain logic to config option
+
+== Footnotes v3.6.6
+  * fix for ruby 1.9 compat (thanks to ivanoats)
+  * fix for log note (thanks to tobias)
+  * pre rails 2.3 support fixes (thanks to tobias)
+  * better disabling of query notes (thanks to tobias)
+  * fixed variable assignment escaping (thanks to gdelvino)
+  * fixed cookie value escaping (thanks to indirect) 
+  * Turn off footnotes with a parameter footnotes=false (thanks to indirect)
+
+== Footnotes v3.6
+  * Cookies, sessions and params notes now use table;
+  * Old components note removed;
+  * Added assigns notes (thanks to scorpio);
+  * Improve query note, count query time and display it with several configurable
+    options (:alert_db_time and :alert_sql_number) (thanks to scorpio);
+  * Fixed bugs of layout link and route note related (thanks to scorpio).
+
+== Footnotes v3.5
+  * Added NewRelic RPM footnote (thanks to kbrock);
+  * Several bug fixes (thanks to kbrock, ivanoats and kristopher).
+
+== Footnotes v3.4
+  * Rails 2.3 compatible.
+
+== Footnotes v3.3.1
+  * Changed prefix to support %s and %d;
+  * Created gemspec;
+  * Some code refactoring (called eval just once instead of three times).
+
+== Footnotes v3.3
+  * Rails Edge (aka 2.2) compatibility;
+  * Initial Ruby 1.9 compatibility.
+
+== Footnotes v3.2.2
+  * Added trace to QueriesNote;
+  * Fixed incompatibility with Ultrasphinx (thanks to mhartl);
+  * Added W3C compatibility (thanks to tapajos);
+  * Added support to other log mechanisms in LogNote.
+
+== Footnotes v3.2.1
+  * Added some tests;
+  * Redefined Footnotes CSS and Javascripts to use concise names.
+  
+== Footnotes v3.2
+  * Now you can easily add your own notes;
+  * Added numbers to tabs;
+  * Added Queries note;
+  * Added MySQL Query Analyzer.
+
+== Footnotes v3.1
+  * Code refactoring (using modules, except backtracer);
+  * Ability to cherry pick notes;
+  * Working on Rails 2.1.
+
+== Footnotes v3.0
+  * Some code refactoring;
+  * Stylesheets bug fixed: was showing not only css in Stylesheets div;
+  * Logtail fix: working with Rails 2.0 logger and in all OS, since it's Regexp based;
+  * Rails 1.2 (except backtrace) and 2.0 compatible;
+  * RoutingNavigator (based on Rick Olson plugin);
+  * FilterChain.
+
+== Textmate Footnotes v2.0
+Copyright (c) 2006 InquiryLabs, Inc.
+http://inquirylabs.com/
+
+Description:
+  Creates clickable footnotes on each rendered page, as well as clickable
+  links in the backtrace should an error occur in your Rails app. Links take
+  you to the right place inside TextMate.
+  Enable only the TextMate on Macs in development mode

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006 Coda Hale
+Copyright (c) 2008 José Valim (jose.valim at gmail dot com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# Rails Footnotes
+#### Version 4.0.0.pre (The Rails 3 Edition™)
+#### MIT License
+
+## Rails 3
+
+Rails 3 compatibility was started by mperham, but was dropped when he discovered rack-bug. I happen to have a
+soft spot for rails-footnotes, so I'm keeping this around for myself.
+
+## Description
+
+If you are developing in Rails you should know the plugin! It displays footnotes in your application for easy
+debugging, such as sessions, request parameters, cookies, filter chain, routes, queries, etc.
+
+Even more, it contains links to open files directly in your editor including your backtrace lines.
+
+
+## Installation
+
+In your Gemfile:
+
+    gem 'rails-footnotes', :git => 'git://github.com/indirect/rails-footnotes.git'
+
+## Configuration
+
+By default, footnotes will only be activated when your Rails app is in development mode. If you want to add alternate logic to enable or disable footnotes, add something like this to config/initializers/footnotes.rb:
+
+    if defined?(Footnotes) & Rails.env.development?
+      Footnotes.run! # first of all
+
+      # ... other init code
+    end
+
+If you are using MacVim as your editor, add this line to your initializer:
+
+    Footnotes::Filter.prefix = 'mvim://open?url=file://%s&line=%d&column=%d'
+
+If you have another editor, simply create a prefix that will result in a link your editor understands. The %s
+is replaced by the name of the file, the first %d is replaced by the line number and the second %d is replaced
+by the column.
+
+By default, footnotes are appended at the end of the page with default stylesheet. If you want to change their
+position, you can define a div with id "footnotes_holder" or define your own stylesheet by turning footnotes
+stylesheet off:
+
+    Footnotes::Filter.no_style = true
+
+Another option is to allow multiple notes to be opened at the same time:
+
+    Footnotes::Filter.multiple_notes = true
+
+If you have New Relic RPM installed, you may want to turn off query explains
+(explains can slows things down)
+
+    Footnotes::Notes::QueriesNote.sql_explain = false
+
+Finally, you can control which notes you want to show. The default are:
+
+    Footnotes::Filter.notes = [:session, :cookies, :params, :filters, :routes, :env, :queries, :log, :general]
+
+
+## Creating your own notes
+
+Create your notes to integrate with Footnotes is easy.
+
+  1. Create a Footnotes::Notes::YourExampleNote class
+
+  2. Implement the necessary methods (check abstract_note.rb file in lib/notes)
+
+  3. Append your example note in Footnotes::Filter.notes array (usually at the end of your environment file or in an initializer):
+
+    For example, to create a note that shows info about the user logged in your application you just have to do:
+
+        module Footnotes
+          module Notes
+            class CurrentUserNote < AbstractNote
+              # This method always receives a controller
+              #
+              def initialize(controller)
+                @current_user = controller.instance_variable_get("@current_user")
+              end
+
+              # Returns the title that represents this note.
+              #
+              def title
+                "Current user: #{@current_user.name}"
+              end
+
+              # This Note is only valid if we actually found an user
+              # If it's not valid, it won't be displayed
+              #
+              def valid?
+                @current_user
+              end
+
+              # The fieldset content
+              #
+              def content
+                escape(@current_user.inspect)
+              end
+            end
+          end
+        end
+
+    Then put in your environment:
+
+        Footnotes::Filter.notes += [:current_user]
+
+
+
+#### Version 3.6.7
+
+This plugin was maintained until version 3.6.7 by [Keenan Brock][kb] (keenan@thebrocks.net), along with contributors [Leon Li][ll], [Ivan Storck][is], and [Kris Chamber][kc].
+
+[kb]: http://github.com/kbrock
+[ll]: http://github.com/scorpio
+[is]: http://github.com/ivanoats
+[kc]: http://github.com/kristopher
+
+#### Version 3.6
+
+This plugin was maintained until version 3.6 by [José Valim][jv] (jose@plataformatec.com.br).
+Copyright (c) 2009 José Valim.
+
+[jv]: http://blog.plataformatec.com.br/
+
+#### Version 2.0
+
+This plugin was created and maintained until version 2.0 by Duane Johnson. Copyright (c) 2006 [InquiryLabs](http://blog.inquirylabs.com/), Inc.

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Run tests for Footnotes.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+task :default => :test
+
+desc 'Generate documentation for Footnotes.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Footnotes'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('MIT-LICENSE')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'metric_fu'
+  MetricFu::Configuration.run do |config|
+      #skipping: churn, :stats
+      config.metrics  = [:saikuro, :flog, :flay, :reek, :roodi, :rcov]
+      # config.graphs   = [:flog, :flay, :reek, :roodi, :rcov]
+      config.rcov[:rcov_opts] << "-Itest"
+  end
+rescue LoadError
+end

data/lib/rails-footnotes/backtracer.rb

@@ -0,0 +1,36 @@
+module Footnotes
+  module Extensions
+    module Exception
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :clean_backtrace, :links
+        end
+      end
+
+      def add_links_to_backtrace(lines)
+        lines.collect do |line|
+          expanded = line.gsub('#{RAILS_ROOT}', Rails.root)
+          if match = expanded.match(/^(.+):(\d+):in/) || match = expanded.match(/^(.+):(\d+)\s*$/)
+            file = File.expand_path(match[1])
+            line_number = match[2]
+            html = %[<a href="#{Footnotes::Filter.prefix(file, line_number, 1)}">#{line}</a>]
+          else
+            line
+          end
+        end
+      end
+
+      def clean_backtrace_with_links
+        unless ::Footnotes::Filter.prefix.blank?
+          add_links_to_backtrace(clean_backtrace_without_links)
+        else
+          clean_backtrace_without_links
+        end
+      end
+    end
+  end
+end
+
+if Rails.version < '3.0'
+  Exception.send :include, Footnotes::Extensions::Exception
+end

data/lib/rails-footnotes/footnotes.rb

@@ -0,0 +1,365 @@
+module Footnotes
+  class BeforeFilter
+    # Method called to start the notes
+    # It's a before filter prepend in the controller
+    def self.filter(controller)
+      Footnotes::Filter.start!(controller)
+    end
+  end
+
+  class AfterFilter
+    # Method that calls Footnotes to attach its contents
+    def self.filter(controller)
+      filter = Footnotes::Filter.new(controller)
+      filter.add_footnotes!
+      filter.close!(controller)
+    end
+  end
+
+  class Filter
+    @@no_style = false
+    @@multiple_notes = false
+    @@klasses = []
+
+    # Default link prefix is textmate
+    @@prefix = 'txmt://open?url=file://%s&line=%d&column=%d'
+
+    # Edit notes
+    @@notes = [ :controller, :view, :layout, :partials, :stylesheets, :javascripts ]
+    # Show notes
+    @@notes += [ :assigns, :session, :cookies, :params, :filters, :routes, :env, :queries, :log, :general ]
+
+    # Change queries for rpm note when available
+    # if defined?(NewRelic)
+    #  @@notes.delete(:queries)
+    #  @@notes << :rpm
+    # end
+
+    # :no_style       => If you don't want the style to be appended to your pages
+    # :notes          => Class variable that holds the notes to be processed
+    # :prefix         => Prefix appended to FootnotesLinks
+    # :multiple_notes => Set to true if you want to open several notes at the same time
+    cattr_accessor :no_style, :notes, :prefix, :multiple_notes
+
+    class << self
+
+      # Calls the class method start! in each note
+      # Sometimes notes need to set variables or clean the environment to work properly
+      # This method allows this kind of setup
+      #
+      def start!(controller)
+        @@klasses = []
+
+        each_with_rescue(@@notes.flatten) do |note|
+          klass = "Footnotes::Notes::#{note.to_s.camelize}Note".constantize
+          klass.start!(controller) if klass.respond_to?(:start!)
+          @@klasses << klass
+        end
+      end
+
+      # Process notes, discarding only the note if any problem occurs
+      #
+      def each_with_rescue(notes)
+        delete_me = []
+
+        notes.each do |note|
+          begin
+            yield note
+          rescue Exception => e
+            # Discard note if it has a problem
+            log_error("Footnotes #{note.to_s.camelize}Note Exception", e)
+            delete_me << note
+            next
+          end
+        end
+
+        delete_me.each{ |note| notes.delete(note) }
+        return notes
+      end
+
+      # Logs the error using specified title and format
+      #
+      def log_error(title, exception)
+        Rails.logger.error "#{title}: #{exception}\n#{exception.backtrace.join("\n")}"
+      end
+
+      # If none argument is sent, simply return the prefix.
+      # Otherwise, replace the args in the prefix.
+      #
+      def prefix(*args)
+        if args.empty?
+          @@prefix
+        else
+          format(@@prefix, *args)
+        end
+      end
+
+    end
+
+    def initialize(controller)
+      @controller = controller
+      @template = controller.instance_variable_get(:@template)
+      @body = controller.response.body
+      @notes = []
+    end
+
+    def add_footnotes!
+      add_footnotes_without_validation! if valid?
+    rescue Exception => e
+      # Discard footnotes if there are any problems
+      self.class.log_error("Footnotes Exception", e)
+    end
+
+    # Calls the class method close! in each note
+    # Sometimes notes need to finish their work even after being read
+    # This method allows this kind of work
+    #
+    def close!(controller)
+      each_with_rescue(@@klasses) do |klass|
+        klass.close!(controller)
+      end
+    end
+
+    protected
+      def valid?
+        performed_render? && valid_format? && valid_content_type? &&
+          @body.is_a?(String) && !component_request? && !xhr? &&
+          !footnotes_disabled?
+      end
+
+      def add_footnotes_without_validation!
+        initialize_notes!
+        insert_styles unless @@no_style
+        insert_footnotes
+      end
+
+      def initialize_notes!
+        each_with_rescue(@@klasses) do |klass|
+          note = klass.new(@controller)
+          @notes << note if note.respond_to?(:valid?) && note.valid?
+        end
+      end
+
+      def performed_render?
+        @controller.instance_variable_get(:@performed_render) || # rails 2.x
+          (@controller.respond_to?(:performed?) && @controller.performed?) # rails3, will break on redirect??
+      end
+
+      def valid_format?
+        if @template # Rails 2.x
+          [:html,:rhtml,:xhtml,:rxhtml].include?(@template.send(template_format_method.to_sym).to_sym)
+        else # Rails 3
+          @controller.response.content_type == 'text/html'
+        end
+      end
+
+      def template_format_method
+        if @template.respond_to?(:template_format)
+          return 'template_format'
+        else
+          return 'format'
+        end
+      end
+
+      def valid_content_type?
+        c = @controller.response.headers['Content-Type'].to_s
+        (c.empty? || c =~ /html/)
+      end
+
+      def component_request?
+        @controller.instance_variable_get(:@parent_controller)
+      end
+
+      def xhr?
+        @controller.request.xhr?
+      end
+
+      def footnotes_disabled?
+        @controller.params[:footnotes] == "false"
+      end
+
+      #
+      # Insertion methods
+      #
+
+      def insert_styles
+        #TODO More customizable(reset.css, from file etc.)
+        insert_text :before, /<\/head>/i, <<-HTML
+        <!-- Footnotes Style -->
+        <style type="text/css">
+          #footnotes_debug {font-size: 11px; font-weight: normal; margin: 2em 0 1em 0; text-align: center; color: #444; line-height: 16px;}
+          #footnotes_debug th, #footnotes_debug td {color: #444; line-height: 18px;}
+          #footnotes_debug a {color: #9b1b1b; font-weight: inherit; text-decoration: none; line-height: 18px;}
+          #footnotes_debug table {text-align: center;}
+          #footnotes_debug table td {padding: 0 5px;}
+          #footnotes_debug tbody {text-align: left;}
+          #footnotes_debug .name_values td {vertical-align: top;}
+          #footnotes_debug legend {background-color: #fff;}
+          #footnotes_debug fieldset {text-align: left; border: 1px dashed #aaa; padding: 0.5em 1em 1em 1em; margin: 1em 2em; color: #444; background-color: #FFF;}
+          /* Aditional Stylesheets */
+          #{@notes.map(&:stylesheet).compact.join("\n")}
+        </style>
+        <!-- End Footnotes Style -->
+        HTML
+      end
+
+      def insert_footnotes
+        # Fieldsets method should be called first
+        content = fieldsets
+
+        footnotes_html = <<-HTML
+        <!-- Footnotes -->
+        <div style="clear:both"></div>
+        <div id="footnotes_debug">
+          #{links}
+          #{content}
+          <script type="text/javascript">
+            var Footnotes = function() {
+
+              function hideAll(){
+                #{close unless @@multiple_notes}
+              }
+              
+              function hideAllAndToggle(id) {
+                hideAll();
+                toggle(id)
+
+                location.href = '#footnotes_debug';
+              }  
+              
+              function toggle(id){
+                var el = document.getElementById(id);
+                if (el.style.display == 'none') {
+                  Footnotes.show(el);
+                } else {
+                  Footnotes.hide(el);
+                }
+              }
+            
+              function show(element) {
+                element.style.display = 'block'
+              }
+            
+              function hide(element) {
+                element.style.display = 'none'
+              }
+
+              return {
+                show: show,
+                hide: hide,
+                toggle: toggle,
+                hideAllAndToggle: hideAllAndToggle
+              }
+            }();
+            /* Additional Javascript */
+            #{@notes.map(&:javascript).compact.join("\n")}
+          </script>
+        </div>
+        <!-- End Footnotes -->
+        HTML
+
+        placeholder = /<div[^>]+id=['"]footnotes_holder['"][^>]*>/i
+        if @controller.response.body =~ placeholder
+          insert_text :after, placeholder, footnotes_html
+        else
+          insert_text :before, /<\/body>/i, footnotes_html
+        end
+      end
+
+      # Process notes to gets their links in their equivalent row
+      #
+      def links
+        links = Hash.new([])
+        order = []
+        each_with_rescue(@notes) do |note|
+          order << note.row
+          links[note.row] += [link_helper(note)]
+        end
+
+        html = ''
+        order.uniq!
+        order.each do |row|
+          html << "#{row.is_a?(String) ? row : row.to_s.camelize}: #{links[row].join(" | \n")}<br />"
+        end
+        html
+      end
+
+      # Process notes to get their content
+      #
+      def fieldsets
+        content = ''
+        each_with_rescue(@notes) do |note|
+          next unless note.has_fieldset?
+          content << <<-HTML
+            <fieldset id="#{note.to_sym}_debug_info" style="display: none">
+              <legend>#{note.legend}</legend>
+              <div>#{note.content}</div>
+            </fieldset>
+          HTML
+        end
+        content
+      end
+
+      # Process notes to get javascript code to close them.
+      # This method is only used when multiple_notes is false.
+      #
+      def close
+        javascript = ''
+        each_with_rescue(@notes) do |note|
+          next unless note.has_fieldset?
+          javascript << close_helper(note)
+        end
+        javascript
+      end
+
+      #
+      # Helpers
+      #
+
+      # Helper that creates the javascript code to close the note
+      #
+      def close_helper(note)
+        "Footnotes.hide(document.getElementById('#{note.to_sym}_debug_info'));\n"
+      end
+
+      # Helper that creates the link and javascript code when note is clicked
+      #
+      def link_helper(note)
+        onclick = note.onclick
+        unless href = note.link
+          href = '#'
+          onclick ||= "Footnotes.hideAllAndToggle('#{note.to_sym}_debug_info');return false;" if note.has_fieldset?
+        end
+
+        "<a href=\"#{href}\" onclick=\"#{onclick}\">#{note.title}</a>"
+      end
+
+      # Inserts text in to the body of the document
+      # +pattern+ is a Regular expression which, when matched, will cause +new_text+
+      # to be inserted before or after the match.  If no match is found, +new_text+ is appended
+      # to the body instead. +position+ may be either :before or :after
+      #
+      def insert_text(position, pattern, new_text)
+        index = case pattern
+          when Regexp
+            if match = @controller.response.body.match(pattern)
+              match.offset(0)[position == :before ? 0 : 1]
+            else
+              @controller.response.body.size
+            end
+          else
+            pattern
+          end
+        newbody = @controller.response.body
+        newbody.insert index, new_text
+        @controller.response.body = newbody
+      end
+
+      # Instance each_with_rescue method
+      # 
+      def each_with_rescue(*args, &block)
+        self.class.each_with_rescue(*args, &block)
+      end
+
+  end
+end