rails-footnotes 3.6.3

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

@@ -0,0 +1,178 @@
+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) }
+          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)
+          rows = []
+          hash.each do |key, value|
+            rows << [ key.to_sym.inspect, escape(value.inspect) ]
+          end
+          mount_table(rows.unshift(['Name', 'Value']), :class => 'name_value')
+        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,44 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class AssignsNote < AbstractNote
+      @@ignored_assigns = %w( @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, assigned_value(key) ]
+        end
+        mount_table(rows.unshift(['Name', 'Value']), :class => 'name_values')
+      end
+
+      protected
+
+        def assigns
+          return @assigns if @assigns
+
+          @assigns = @controller.instance_variables
+          @assigns -= @controller.protected_instance_variables
+          @assigns -= ignored_assigns
+        end
+
+        def assigned_value(key)
+          escape(@controller.instance_variable_get(key).inspect)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+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
+        escape(Footnotes::Filter.prefix(controller_filename, controller_line_number + 1, 3))
+      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
+          controller_name=@controller.class.to_s.underscore
+          controller_name='application' if controller_name=='application_controller'
+          if ActionController::Routing.respond_to? :controller_paths
+            ActionController::Routing.controller_paths.each do |controller_path|
+              full_controller_path = File.join(File.expand_path(controller_path), "#{controller_name}.rb")
+              return full_controller_path if File.exists?(full_controller_path)
+            end
+            raise "File not found"
+          else
+            File.join(File.expand_path(RAILS_ROOT), 'app', 'controllers', "#{controller_name}.rb").sub('/controllers/controllers/', '/controllers/')
+          end
+        end
+
+        def controller_text
+          @controller_text ||= IO.read(controller_filename)
+        end
+
+        def action_index
+          (controller_text =~ /def\s+#{@controller.action_name}[\s\(]/)
+        end
+
+        def controller_line_number
+          lines_from_index(controller_text, action_index) || 0
+        end
+
+        def lines_from_index(string, index)
+          return nil if string.blank? || index.blank?
+
+          lines = string.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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+
+module Footnotes
+  module Notes
+    class EnvNote < AbstractNote
+      def initialize(controller)
+        @env = controller.request.env.dup
+      end
+
+      def content
+        # Replace HTTP_COOKIE for a link
+        @env['HTTP_COOKIE'] = '<a href="#" style="color:#009" onclick="Footnotes.hideAllAndToggle(\'cookies_debug_info\');return false;">See cookies on its tab</a>'
+
+        # Create the env table
+        mount_table(@env.to_a.sort.unshift([:key, :value]))
+      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]))
+      end
+
+      protected
+        # Get controller filter chain
+        #
+        def parse_filters
+          return @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