rails3-footnotes 4.0.0.pre

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

@@ -0,0 +1,179 @@
+module Footnotes
+  module Notes
+    # This is the abstract class for notes.
+    # You can overwrite all instance public methods to create your notes.
+    #
+    class AbstractNote
+
+      # Class methods. Do NOT overwrite them.
+      #
+      class << self
+        # Returns the symbol that represents this note.
+        # It's the name of the class, underscored and without _note.
+        #
+        # For example, for ControllerNote it will return :controller.
+        #
+        def to_sym
+          @note_sym ||= self.title.underscore.to_sym
+        end
+
+        # Returns the title that represents this note.
+        # It's the name of the class without Note.
+        #
+        # For example, for ControllerNote it will return Controller.
+        #
+        def title
+          @note_title ||= self.name.match(/^Footnotes::Notes::(\w+)Note$/)[1]
+        end
+
+        # Return true if Note is included in notes array.
+        #
+        def included?
+          Footnotes::Filter.notes.include?(self.to_sym)
+        end
+
+        # Action to be called to start the Note.
+        # This is applied as a before_filter.
+        #
+        def start!(controller = nil)
+        end
+
+        # Action to be called after the Note was used.
+        # This is applied as an after_filter.
+        #
+        def close!(controller = nil)
+        end
+      end
+
+      # Initialize notes.
+      # Always receives a controller.
+      #
+      def initialize(controller = nil)
+      end
+
+      # Returns the symbol that represents this note.
+      #
+      def to_sym
+        self.class.to_sym
+      end
+
+      # Specifies in which row should appear the title.
+      # The default is :show.
+      #
+      def row
+        :show
+      end
+
+      # Returns the title to be used as link.
+      # The default is the note title.
+      #
+      def title
+        self.class.title
+      end
+
+      # If has_fieldset? is true, create a fieldset with the value returned as legend.
+      # By default, returns the title of the class (defined above).
+      #
+      def legend
+        self.class.title
+      end
+
+      # If content is defined, has_fieldset? returns true and the value of content
+      # is displayed when the Note is clicked. See has_fieldset? below for more info.
+      #
+      # def content
+      # end
+
+      # Set href field for Footnotes links.
+      # If it's nil, Footnotes will use '#'.
+      # 
+      def link
+      end
+
+      # Set onclick field for Footnotes links.
+      # If it's nil, Footnotes will make it open the fieldset.
+      # 
+      def onclick
+      end
+
+      # Insert here any additional stylesheet.
+      # This is directly inserted into a <style> tag.
+      #
+      def stylesheet
+      end
+
+      # Insert here any additional javascript.
+      # This is directly inserted into a <script> tag.
+      #
+      def javascript
+      end
+
+      # Specifies when should create a note for it.
+      # By default, it's valid.
+      #
+      def valid?
+        true
+      end
+
+      # Specifies when should create a fieldset for it, considering it's valid.
+      #
+      def has_fieldset?
+        self.respond_to?(:content)
+      end
+
+      # Some helpers to generate notes.
+      #
+      protected
+        # Return if Footnotes::Filter.prefix exists or not.
+        # Some notes only work with prefix set.
+        #
+        def prefix?
+          !Footnotes::Filter.prefix.blank?
+        end
+
+        # Escape HTML special characters.
+        #
+        def escape(text)
+          text.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
+        end
+
+        # Gets a bidimensional array and create a table.
+        # The first array is used as label.
+        #
+        def mount_table(array, options = {})
+          header = array.shift
+          return '' if array.empty?
+
+          header = header.collect{|i| escape(i.to_s.humanize) }
+#          array = array.collect { |a| a.collect { |b| c = b.to_s; escape(c) unless c == ""}}
+          rows = array.collect{|i| "<tr><td>#{i.join('</td><td>')}</td></tr>" }
+
+          <<-TABLE
+          <table #{hash_to_xml_attributes(options)}>
+            <thead><tr><th>#{header.join('</th><th>')}</th></tr></thead>
+            <tbody>#{rows.join}</tbody>
+          </table>
+          TABLE
+        end
+
+        # Mount table for hash, using name and value and adding a name_value class
+        # to the generated table.
+        #
+        def mount_table_for_hash(hash, options={})
+          rows = []
+          hash.each do |key, value|
+            rows << [ key.to_sym.inspect, escape(value.inspect) ]
+          end
+          mount_table(rows.unshift(['Name', 'Value']), {:class => 'name_value'}.merge(options))
+        end
+
+        def hash_to_xml_attributes(hash)
+          newstring = ""
+          hash.each do |key, value|
+            newstring << "#{key.to_s}=\"#{value.gsub('"','\"')}\" "
+          end 
+          return newstring
+        end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class AssignsNote < AbstractNote
+      @@ignored_assigns = [
+                            :@real_format,
+                            :@before_filter_chain_aborted,
+                            :@performed_redirect,
+                            :@performed_render,
+                            :@_params,
+                            :@_response,
+                            :@url,
+                            :@template,
+                            :@_request,
+                            :@db_rt_before_render,
+                            :@db_rt_after_render,
+                            :@view_runtime
+                          ]
+      cattr_accessor :ignored_assigns, :instance_writter => false
+
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def title
+        "Assigns (#{assigns.size})"
+      end
+
+      def valid?
+        assigns
+      end
+
+      def content
+        rows = []
+        assigns.each do |key|
+          rows << [ key, escape(assigned_value(key)) ]
+        end
+        mount_table(rows.unshift(['Name', 'Value']), :class => 'name_values', :summary => "Debug information for #{title}")
+      end
+
+      protected
+
+        def assigns
+          assign = []
+          ignored = @@ignored_assigns
+          
+          @controller.instance_variables.each {|x| assign << x.intern }
+          @controller.protected_instance_variables.each {|x| ignored << x.intern } if @controller.respond_to? :protected_instance_variables
+           
+          assign -= ignored            
+          return assign
+        end
+
+        def assigned_value(key)
+          @controller.instance_variable_get(key).inspect
+        end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class ControllerNote < AbstractNote
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def row
+        :edit
+      end
+
+      def link
+        if controller_filename && controller_line_number
+          escape(Footnotes::Filter.prefix(controller_filename, controller_line_number + 1, 3))
+        end
+      end
+
+      def valid?
+        prefix?
+      end
+
+      protected
+        # Some controller classes come with the Controller:: module and some don't
+        # (anyone know why? -- Duane)
+        def controller_filename
+          return @controller_filename if defined?(@controller_filename)
+          controller_name=@controller.class.to_s.underscore
+          controller_name='application' if controller_name=='application_controller'
+          if ActionController::Routing.respond_to? :controller_paths
+            @controller_filename=nil
+            ActionController::Routing.controller_paths.each do |controller_path|
+              full_controller_path = File.join(File.expand_path(controller_path), "#{controller_name}.rb")
+              @controller_filename=full_controller_path if File.exists?(full_controller_path)
+            end
+            #raise "File not found"
+          else
+            @controller_filename=File.join(File.expand_path(Rails.root), 'app', 'controllers', "#{controller_name}.rb").sub('/controllers/controllers/', '/controllers/')
+          end
+          @controller_filename
+        end
+
+        def controller_text
+          if controller_filename
+            @controller_text ||= IO.read(controller_filename)
+          end
+        end
+
+        def action_index
+          (controller_text =~ /def\s+#{@controller.action_name}[\s\(]/) if controller_text
+        end
+
+        def controller_line_number
+          lines_from_index(controller_text, action_index) || 0 if controller_text
+        end
+
+        def lines_from_index(string, index)
+          return nil if string.blank? || index.blank?
+
+          lines = string.respond_to?(:to_a) ? string.to_a : string.lines.to_a
+          running_length = 0
+          lines.each_with_index do |line, i|
+            running_length += line.length
+            if running_length > index
+              return i
+            end
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class CookiesNote < AbstractNote
+      def initialize(controller)
+        @cookies = (controller.__send__(:cookies) || {}).symbolize_keys
+      end
+
+      def title
+        "Cookies (#{@cookies.length})"
+      end
+
+      def content
+        mount_table_for_hash(@cookies, :summary => "Debug information for #{title}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class EnvNote < AbstractNote
+      def initialize(controller)
+        @env = controller.request.env.dup
+      end
+
+      def content
+        env_data = @env.to_a.sort.unshift([:key, :value]).map do |k,v|
+          case k
+          when 'HTTP_COOKIE'
+            # Replace HTTP_COOKIE for a link
+            [k, '<a href="#" style="color:#009" onclick="Footnotes.hideAllAndToggle(\'cookies_debug_info\');return false;">See cookies on its tab</a>']
+          else
+            [k, escape(v.to_s)]
+          end
+        end
+
+        # Create the env table
+        mount_table(env_data)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class FilesNote < AbstractNote
+      def initialize(controller)
+        @files = scan_text(controller.response.body)
+        parse_files!
+      end
+
+      def row
+        :edit
+      end
+
+      def content
+        if @files.empty?
+          ""
+        else
+          "<ul><li>#{@files.join("</li><li>")}</li></ul>"
+        end
+      end
+
+      def valid?
+        prefix?
+      end
+
+      protected
+        def scan_text(text)
+          []
+        end
+
+        def parse_files!
+          @files.collect! do |filename|
+            if filename =~ %r{^/}
+              full_filename = File.join(File.expand_path(Rails.root), 'public', filename)
+              %[<a href="#{Footnotes::Filter.prefix(full_filename, 1, 1)}">#{filename}</a>]
+            else
+              %[<a href="#{filename}">#{filename}</a>]
+            end
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class FiltersNote < AbstractNote
+      def initialize(controller)
+        @controller = controller
+        @parsed_filters = parse_filters
+      end
+
+      def legend
+        "Filter chain for #{@controller.class.to_s}"
+      end
+
+      def content
+        mount_table(@parsed_filters.unshift([:name, :type, :actions]), :summary => "Debug information for #{title}")
+      end
+
+      protected
+        # Get controller filter chain
+        #
+        def parse_filters
+          return [] # TODO @controller.class.filter_chain.collect do |filter|
+#            [parse_method(filter.method), filter.type.inspect, controller_filtered_actions(filter).inspect]
+#          end
+        end
+
+        # This receives a filter, creates a mock controller and check in which
+        # actions the filter is performed
+        #
+        def controller_filtered_actions(filter)
+          mock_controller = Footnotes::Extensions::MockController.new
+
+          return @controller.class.action_methods.select { |action|
+            mock_controller.action_name = action
+
+            #remove conditions (this would call a Proc on the mock_controller)
+            filter.options.merge!(:if => nil, :unless => nil) 
+
+            filter.__send__(:should_run_callback?, mock_controller)   
+          }.map(&:to_sym)
+        end
+        
+        def parse_method(method = '')
+          escape(method.inspect.gsub(RAILS_ROOT, ''))
+        end
+    end
+  end
+
+  module Extensions
+    class MockController < Struct.new(:action_name); end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class GeneralNote < AbstractNote
+      def title
+        'General Debug'
+      end
+
+      def legend
+        'General (id="general_debug_info")'
+      end
+
+      def content
+        'You can use this tab to debug other parts of your application, for example Javascript.'
+      end
+    end
+  end
+end

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,28 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class LayoutNote < AbstractNote
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def row
+        :edit
+      end
+
+      def link
+        escape(Footnotes::Filter.prefix(filename, 1, 1))
+      end
+
+      def valid?
+        prefix? && nil#@controller.active_layout TODO doesn't work with Rails 3
+      end
+
+      protected
+        def filename
+          File.join(File.expand_path(Rails.root), 'app', 'layouts', "#{@controller.active_layout.to_s.underscore}").sub('/layouts/layouts/', '/views/layouts/')
+        end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class LogNote < AbstractNote
+      @@log = []
+      
+      def self.log(message)
+        @@log << message
+      end
+      
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def title
+        "Log (#{log.count("\n")})"
+      end
+
+      def content
+        escape(log.gsub(/\e\[.+?m/, '')).gsub("\n", '<br />')
+      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
+      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/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
+        mount_table_for_hash(@params, :summary => "Debug information for #{title}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require "#{File.dirname(__FILE__)}/log_note"
+
+module Footnotes
+  module Notes
+    class PartialsNote < LogNote
+      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]]
+        end
+        mount_table(rows.unshift(%w(Partial Time Count)), :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, "#{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