ceritium-rails-footnotes 3.4

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

@@ -0,0 +1,163 @@
+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
+
+        def hash_to_xml_attributes(hash)
+          return hash.collect{ |key, value| "#{key.to_s}=\"#{value.gsub('"','\"')}\"" }.join(' ')
+        end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require "#{File.dirname(__FILE__)}/abstract_note"
+require "#{File.dirname(__FILE__)}/controller_note"
+require "#{File.dirname(__FILE__)}/view_note"
+require "#{File.dirname(__FILE__)}/params_note"
+
+module Footnotes
+  module Notes
+    module ComponentsNote
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def to_sym
+          @note_sym ||= "#{self.title.underscore}_component_#{(rand*1000).to_i}".to_sym
+        end
+
+        def title
+          @note_title ||= self.name.match(/^Footnotes::Notes::(\w+)ComponentNote$/)[1]
+        end
+      end
+
+      def initialize(controller)
+        super
+        @controller = controller
+      end
+
+      def row
+        "#{@controller.controller_name.camelize}##{@controller.action_name.camelize} Component"
+      end
+     
+      def legend
+        "#{super} for #{row}"
+      end
+    end
+
+    class ControllerComponentNote < ControllerNote; include ComponentsNote; end
+    class ViewComponentNote < ViewNote; include ComponentsNote; end
+    class ParamsComponentNote < ParamsNote; include ComponentsNote; end
+  end
+
+  module Components
+
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :add_footnotes!, :component
+        Footnotes::Filter.notes.delete(:components)
+        @@component_notes = [ :controller, :view, :params ]
+      end
+    end
+
+    def add_footnotes_with_component!
+      if component_request?
+        initialize_component_notes!
+        Footnotes::Filter.notes.unshift(*@notes)
+      else
+        add_footnotes_without_component!
+        Footnotes::Filter.notes.delete_if {|note| note.class.to_s =~ /(ComponentNote)$/}
+      end
+    end
+
+    protected
+      def initialize_component_notes!
+        @@component_notes.flatten.each do |note|
+          begin
+            note = eval("Footnotes::Notes::#{note.to_s.camelize}ComponentNote").new(@controller) if note.is_a?(Symbol) || note.is_a?(String)
+            @notes << note if note.respond_to?(:valid?) && note.valid?
+          rescue Exception => e
+            # Discard note if it has a problem
+            self.class.log_error("Footnotes #{note.to_s.camelize}ComponentNote Exception", e)
+            next
+          end
+        end
+      end
+
+  end
+end
+
+Footnotes::Filter.__send__ :include, Footnotes::Components if Footnotes::Filter.notes.include?(:components)

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

@@ -0,0 +1,55 @@
+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
+          File.join(File.expand_path(RAILS_ROOT), 'app', 'controllers', "#{@controller.class.to_s.underscore}.rb").sub('/controllers/controllers/', '/controllers/')
+        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
+        escape(@cookies.inspect)
+      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