scharfie-rails-footnotes 3.4.2

data/.gitignore

@@ -0,0 +1 @@
+*~

data/CHANGELOG

@@ -0,0 +1,56 @@
+TODO:
+  * Create ProfilerNote
+  * Javascript injection for partials
+
+== Footnotes v3.4
+Author: José Valim (jose.valim@gmail.com)
+Site: http://josevalim.blogspot.com/
+  * 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.
+Author: Duane Johnson (duane.johnson@gmail.com)
+Site: 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

@@ -0,0 +1,147 @@
+Rails Footnotes
+License: MIT
+Version: 3.4.1
+
+You can also read this README in pretty html at the GitHub project Wiki page
+
+  http://github.com/josevalim/rails-footnotes/wikis/home
+
+
+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
+------------
+
+Install Rails Footnotes is very easy. If you are running on Rails 2.3 just run
+the following:
+
+   gem sources -a http://gems.github.com
+   sudo gem install josevalim-rails-footnotes
+
+In RAILS_ROOT/config/environments/development.rb (yes, you want it only in development):
+
+  config.gem "josevalim-rails-footnotes",  :lib => "rails-footnotes", :source => "http://gems.github.com"
+
+If you want it as plugin, just do:
+
+   script/plugin install git://github.com/josevalim/rails-footnotes.git
+
+If you are running on Rails 2.2 or Rails 2.1 you should do:
+
+    cd myapp
+    git clone git://github.com/josevalim/rails-footnotes.git
+    cd vendor/plugins/rails-footnotes
+    git checkout VERSION_NUMBER
+    rm -rf ./.git
+
+Where you should replace VERSION_NUMBER for "v3.3.2" for Rails 2.2 and "v3.2.2"
+for Rails 2.1 (without the quotes).
+
+Configuration
+-------------
+
+If you are not using Textmate as text editor, in your environment.rb or
+in an initializer do:
+
+  if defined?(Footnotes)
+    Footnotes::Filter.prefix = 'txmt://open?url=file://%s&line=%d&column=%d'
+  end
+
+Where you are going to choose a prefix compatible with your text editor. 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. You can also enable this behaviour in other
+editors following the steps in the link below:
+
+  http://josevalim.blogspot.com/2008/06/textmate-protocol-behavior-on-any.html
+
+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
+
+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
+
+        # The name that will appear as legend in fieldsets
+        #
+        def legend
+          "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]
+
+
+Bugs and Feedback
+-----------------
+
+If you discover any bugs, please send an e-mail to jose.valim@gmail.com
+If you just want to give some positive feedback or drop a line, that's fine too! =)
+
+Copyright (c) 2009 José Valim
+http://www.pagestacker.com/
+http://josevalim.blogspot.com/
+
+
+Version 2.0
+-----------
+
+Until version 2.0, this plugin was created and maintained by:
+
+Duane Johnson (duane.johnson@gmail.com)
+http://blog.inquirylabs.com/

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "scharfie-rails-footnotes"
+    gem.summary = %Q{Textmate footnotes for rails}
+    gem.description = %Q{Textmate footnotes for rails}
+    gem.email = "tastyhat@jamesstuart.org"
+    gem.homepage = "http://github.com/scharfie/rails-footnotes"
+    gem.authors = ["Scharfie"]
+    gem.add_development_dependency "thoughtbot-shoulda"
+    gem.add_development_dependency "mocha"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "scharfie-rails-footnotes #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), 'lib', 'rails-footnotes')
+

data/lib/rails-footnotes.rb

@@ -0,0 +1,20 @@
+if RAILS_ENV == 'development'
+  dir = File.dirname(__FILE__)
+  require File.join(dir, 'rails-footnotes', 'footnotes')
+  require File.join(dir, 'rails-footnotes', 'backtracer')
+
+  # Load all notes
+  #
+  Dir[File.join(dir, 'rails-footnotes', 'notes', '*.rb')].each do |note|
+    require note
+  end
+
+  # 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.
+  #
+  class ActionController::Base
+    prepend_before_filter Footnotes::Filter
+    after_filter Footnotes::Filter
+  end
+end

data/lib/rails-footnotes/assets/footnotes.css

@@ -0,0 +1,26 @@
+#footnotes_debug {
+  font-family: Myriad Pro, Helvetica, Arial, sans-serif;
+  color:       #ccc;
+  font-size:   12px;
+  text-align:  left;
+  margin:  10px 0 0;
+  padding: 5px 10px;
+  background: #f5f5f5;        
+}
+
+#footnotes_debug a {
+  color: #24242;
+  padding: 4px;
+  text-decoration: none; color: #444; line-height: 18px;
+}
+
+#footnotes_debug table {text-align: center;}
+#footnotes_debug table td {padding: 0 5px;}
+#footnotes_debug tbody {text-align: left;}
+#footnotes_debug legend {background-color: #FFF;}
+#footnotes_debug fieldset {
+  text-align: left; 
+  border: 1px dashed #aaa;
+  padding: 0.5em 1em 1em 1em; margin: 10px; color: #444; background-color: #FFF;
+  font-family: Inconsolata, Monaco, monospace;
+}

data/lib/rails-footnotes/assets/footnotes.js

@@ -0,0 +1,38 @@
+var Footnotes = function() {
+  function hideAll() {}
+  
+  function hideAllAndToggle(id) {
+    var el = get(id)
+    var display = el.style.display
+    Footnotes.hideAll();
+    toggle(id, display)
+  }  
+  
+  function get(id) {
+    return document.getElementById(id);
+  }
+  
+  function toggle(id, display) {
+    var el = get(id)
+    if (display == null) { display = el.style.display }
+    display == 'none' ? show(el) : hide(el)
+    location.href = '#footnotes_debug';
+  }
+
+  function show(element) {
+    element.style.display = 'block'
+  }
+
+  function hide(element) {
+    element.style.display = 'none'
+  }
+
+  return {
+    show: show,
+    hide: hide,
+    get:  get,
+    toggle: toggle,
+    hideAllAndToggle: hideAllAndToggle,
+    multipleNotes: false
+  }
+}();

data/lib/rails-footnotes/backtracer.rb

@@ -0,0 +1,34 @@
+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
+
+Exception.send :include, Footnotes::Extensions::Exception

data/lib/rails-footnotes/footnotes.rb

@@ -0,0 +1,297 @@
+module Footnotes
+  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, :stylesheets, :javascripts ]
+    # Show notes
+    @@notes += [ :session, :cookies, :params, :filters, :routes, :env, :queries, :log, :general ]
+
+    # :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
+      # Method called to start the notes
+      # It's a before filter prepend in the controller
+      #
+      def before(controller)
+        Footnotes::Filter.start!(controller)
+      end
+
+      # Method that calls Footnotes to attach its contents
+      #
+      def after(controller)
+        filter = Footnotes::Filter.new(controller)
+        filter.add_footnotes!
+        filter.close!(controller)
+      end
+
+      # 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_DEFAULT_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?
+      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)
+      end
+
+      def valid_format?
+        [:html,:rhtml,:xhtml,:rxhtml].include?(@template.template_format.to_sym)
+      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 read_asset(filename)
+        File.read(File.join(File.dirname(__FILE__), 'assets', filename))
+      end
+
+      #
+      # Insertion methods
+      #
+
+      def insert_styles
+        insert_text :before, /<\/head>/i, <<-HTML
+        <!-- Footnotes Style -->
+        <style type="text/css">
+          #{read_asset('footnotes.css')}
+          /* 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
+        hideAll = @@multiple_notes ? nil : %[Footnotes.hideAll = function() { #{close} }]
+
+        footnotes_html = <<-HTML
+        <!-- Footnotes -->
+        <div style="clear:both"></div>
+        <div id="footnotes_debug">
+          #{links}
+          #{content}
+          <script type="text/javascript">
+            #{read_asset('footnotes.js')}
+            #{hideAll}
+            /* Additional Javascript */
+            #{@notes.map(&:javascript).compact.join("\n")}
+          </script>
+        </div>
+        <!-- End Footnotes -->
+        HTML
+
+        if @body =~ %r{<div[^>]+id=['"]footnotes_holder['"][^>]*>}
+          # Insert inside the "footnotes_holder" div if it exists
+          insert_text :after, %r{<div[^>]+id=['"]footnotes_holder['"][^>]*>}, footnotes_html
+        else
+          # Otherwise, try to insert as the last part of the html body
+          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 = @body.match(pattern)
+              match.offset(0)[position == :before ? 0 : 1]
+            else
+              @body.size
+            end
+          else
+            pattern
+          end
+        @body.insert index, new_text
+      end
+
+      # Instance each_with_rescue method
+      # 
+      def each_with_rescue(*args, &block)
+        self.class.each_with_rescue(*args, &block)
+      end
+
+  end
+end