rails6-footnotes 5.0.0

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

@@ -0,0 +1,60 @@
+module Footnotes
+  module Notes
+    class RoutesNote < AbstractNote
+      def initialize(controller)
+        @controller = controller
+        @parsed_routes = parse_routes
+      end
+
+      def legend
+        "Routes for #{@controller.class.to_s}"
+      end
+
+      def content
+        mount_table(@parsed_routes.unshift([:path, :name, :options, :requirements]), :summary => "Debug information for #{title}")
+      end
+
+      protected
+        def parse_routes
+          routes_with_name = Rails.application.routes.named_routes.to_a.flatten
+
+          return Rails.application.routes.filtered_routes(:controller => @controller.controller_path).collect do |route|
+            # Catch routes name if exists
+            i = routes_with_name.index(route)
+            name = i ? routes_with_name[i-1].to_s : ''
+
+            # Catch segments requirements
+            req = route.conditions
+            [escape(name), route.conditions.keys.join, route.requirements.reject{|key,value| key == :controller}.inspect, req.inspect]
+          end
+        end
+    end
+  end
+
+  module Extensions
+    module Routes
+
+      def __hash_diff(hash_self, other)
+        # ActiveSupport::Deprecation.warn "Hash#diff is no longer used inside of Rails,
+        # and is being deprecated with no replacement. If you're using it to compare hashes for the purpose of testing, please use MiniTest's diff instead."
+        hash_self.dup.delete_if { |k, v| other[k] == v }.merge!(other.dup.delete_if { |k, v| hash_self.has_key?(k) })
+      end
+
+      # Filter routes according to the filter sent
+      #
+      def filtered_routes(filter = {})
+        return [] unless filter.is_a?(Hash)
+        return routes.reject do |r|
+          filter_diff = __hash_diff(filter, r.requirements)
+          route_diff  = __hash_diff(r.requirements, filter)
+
+          (filter_diff == filter) || (filter_diff != route_diff)
+        end
+      end
+    end
+  end
+end
+
+if Footnotes::Notes::RoutesNote.included?
+  ActionDispatch::Routing::RouteSet.send :include, Footnotes::Extensions::Routes
+end

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

@@ -0,0 +1,27 @@
+module Footnotes
+  module Notes
+    class SessionNote < AbstractNote
+      def initialize(controller)
+        session = controller.session
+        if session
+          if session.respond_to? :to_hash
+            # rails >= 2.3
+            session = session.to_hash
+          else
+            #rails < 2.3
+            session = session.data
+          end
+        end
+        @session = (session || {}).symbolize_keys
+      end
+
+      def title
+        "Session (#{@session.length})"
+      end
+
+      def content
+        mount_table_for_hash(@session, :summary => "Debug information for #{title}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require "rails-footnotes/notes/files_note"
+
+module Footnotes
+  module Notes
+    class StylesheetsNote < FilesNote
+      def title
+        "Stylesheets (#{@files.length})"
+      end
+
+      protected
+        def scan_text(text)
+          text.scan(/<link[^>]+href\s*=\s*['"]([^>?'"]+\.css)/im).flatten
+        end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Footnotes
+  module Notes
+    class ViewNote < AbstractNote
+      cattr_accessor :template
+
+      def self.start!(controller)
+        @subscriber ||= ActiveSupport::Notifications.subscribe('render_template.action_view') do |*args|
+          event = ActiveSupport::Notifications::Event.new *args
+          self.template = {:file => event.payload[:identifier], :duration => event.duration}
+        end
+      end
+
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def row
+        :edit
+      end
+
+      def title
+        "View (#{"%.3f" % self.template[:duration]}ms)"
+      end
+
+      def link
+        escape(Footnotes::Filter.prefix(filename, 1, 1))
+      end
+
+      def valid?
+        prefix? && filename && File.exists?(filename)
+      end
+
+      protected
+
+        def filename
+          @filename ||= self.class.template[:file]
+        end
+
+    end
+  end
+end

data/lib/rails-footnotes/version.rb

@@ -0,0 +1,3 @@
+module Footnotes
+  VERSION = "5.0.0"
+end

data/lib/rails6-footnotes.rb

@@ -0,0 +1 @@
+require_relative "./rails-footnotes"

data/rails-footnotes.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rails-footnotes/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rails6-footnotes"
+  s.version     = Footnotes::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Roman V. Babenko", "José Valim", "Keenan Brock", "Duane Johnson", "Adrien Siami", "André Arko"]
+  s.email       = ["andre@arko.net"]
+  s.homepage    = "http://github.com/indirect/rails-footnotes"
+  s.summary     = %q{Every Rails page has footnotes that gives information about your application and links back to your editor.}
+  s.description = %q{Every Rails page has footnotes that gives information about your application and links back to your editor.}
+
+  s.add_dependency "rails", "~> 6.0"
+  s.required_ruby_version = "~> 3.0"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/abstract_note_spec.rb

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+describe Footnotes::Notes::AbstractNote do
+  before do
+    @note = Footnotes::Notes::AbstractNote.new
+    @notes = Footnotes::Filter.notes
+    Footnotes::Filter.notes = [:abstract]
+  end
+
+  after do
+    Footnotes::Filter.notes = @notes
+  end
+
+  it {expect(described_class).to respond_to :start!}
+  it {expect(described_class).to respond_to :close!}
+  it {expect(described_class).to respond_to :title}
+
+  it {should respond_to :to_sym}
+
+  describe '#to_sym' do
+    subject { super().to_sym }
+    it {should eql :abstract}
+  end
+
+  it { expect(described_class).to be_included }
+  specify do
+    Footnotes::Filter.notes = []
+    expect(described_class).not_to be_included
+  end
+
+  it { should respond_to :row }
+  it { should respond_to :legend }
+  it { should respond_to :link }
+  it { should respond_to :onclick }
+  it { should respond_to :stylesheet }
+  it { should respond_to :javascript }
+
+  it { should respond_to :valid? }
+  it { should be_valid }
+
+  it { should respond_to :has_fieldset? }
+  it { should_not have_fieldset }
+
+  specify { Footnotes::Filter.prefix = ''; should_not be_prefix }
+  specify do
+    Footnotes::Filter.prefix = 'txmt://open?url=file://%s&line=%d&column=%d'
+    should be_prefix
+  end
+
+  #TODO should be moved to builder
+  #helpers
+  specify { expect(subject.escape('<')).to eql '&lt;' }
+  specify { expect(subject.escape('&')).to eql '&amp;' }
+  specify { expect(subject.escape('>')).to eql '&gt;' }
+
+  specify { expect(subject.mount_table([])).to be_blank }
+  specify { expect(subject.mount_table([['h1', 'h2', 'h3']], :class => 'table')).to be_blank }
+
+  specify {
+    tab = <<-TABLE
+          <table class="table" >
+            <thead><tr><th>H1</th></tr></thead>
+            <tbody><tr><td>r1c1</td></tr></tbody>
+          </table>
+          TABLE
+
+    expect(subject.mount_table([['h1'],['r1c1']], :class => 'table')).to eql tab
+  }
+
+  specify {
+    tab = <<-TABLE
+          <table >
+            <thead><tr><th>H1</th><th>H2</th><th>H3</th></tr></thead>
+            <tbody><tr><td>r1c1</td><td>r1c2</td><td>r1c3</td></tr></tbody>
+          </table>
+          TABLE
+    expect(subject.mount_table([['h1', 'h2', 'h3'],['r1c1', 'r1c2', 'r1c3']])).to eql tab
+  }
+
+  specify {
+    tab = <<-TABLE
+          <table >
+            <thead><tr><th>H1</th><th>H2</th><th>H3</th></tr></thead>
+            <tbody><tr><td>r1c1</td><td>r1c2</td><td>r1c3</td></tr><tr><td>r2c1</td><td>r2c2</td><td>r2c3</td></tr></tbody>
+          </table>
+          TABLE
+    subject.mount_table([['h1', 'h2', 'h3'], ['r1c1', 'r1c2', 'r1c3'], ['r2c1', 'r2c2', 'r2c3']])
+  }
+end

data/spec/app/assets/config/manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css

data/spec/app/assets/javascripts/foobar.js

@@ -0,0 +1 @@
+// Foobar

data/spec/app/views/files/index.html.erb

@@ -0,0 +1 @@
+FILES INDEX

data/spec/app/views/layouts/application.html.erb

@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+  <head>
+    <%= javascript_include_tag 'foobar' %>
+    <%= javascript_include_tag 'http://google.com/whatever.js' %>
+    <%= stylesheet_link_tag 'foobar' %>
+    <%= stylesheet_link_tag 'http://google.com/whatever.css' %>
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/spec/app/views/partials/_foo.html.erb

@@ -0,0 +1 @@
+bar

data/spec/app/views/partials/index.html.erb

@@ -0,0 +1 @@
+<%= render 'foo' %>

data/spec/controllers/files_note_controller_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+class FilesController < ApplicationController
+  def index
+  end
+end
+
+describe FilesController, type: :controller do
+  render_views
+
+  before :all do
+    Footnotes.enabled = true
+  end
+
+  after :all do
+    Footnotes.enabled = false
+  end
+
+  it 'includes stylesheets assets in the response' do
+    get :index
+    expect(response.body).to include("FILES INDEX")
+    js_debug = first('fieldset#javascripts_debug_info div', visible: false)
+    expect(js_debug).to have_selector('li a', visible: false, count: 1)
+    expect(js_debug).to have_selector('li a', text: /foobar\.js/, visible: false)
+    link = js_debug.first('a', visible: false)
+    expect(link['href']).to eq("txmt://open?url=file://#{Rails.root.join('app', 'assets', 'javascripts', 'foobar.js')}&line=1&column=1")
+  end
+
+  it 'includes css assets in the response' do
+    get :index
+    css_debug = first('fieldset#stylesheets_debug_info div', visible: false)
+    expect(css_debug).to have_selector('li a', visible: false, count: 1)
+    expect(css_debug).to have_selector('li a', text: /foobar\.css/, visible: false)
+    link = css_debug.first('a', visible: false)
+    expect(link['href']).to eq("txmt://open?url=file://#{Rails.root.join('app', 'assets', 'stylesheets', 'foobar.css')}&line=1&column=1")
+  end
+
+end

data/spec/controllers/footnotes_controller_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+class FootnotesController < ActionController::Base
+
+  def foo
+    render inline: HTML_DOCUMENT, content_type: 'text/html'
+  end
+
+  def foo_holder
+    render inline: '<html><body><div id="footnotes_holder"></div></body></html>'
+  end
+
+  def foo_js
+    render inline: '<script></script>', content_type: 'text/javascript'
+  end
+
+  def foo_download
+    send_file Rails.root.join('fixtures', 'html_download.html'), :disposition => 'attachment'
+  end
+
+end
+
+describe FootnotesController, type: :controller do
+
+  shared_examples 'has_footnotes' do
+    it 'includes footnotes' do
+      get :foo
+      expect(response.body).to have_selector('#footnotes_debug')
+    end
+  end
+
+  shared_examples 'has_no_footnotes' do
+    it 'does not include footnotes' do
+      expect(response.body).not_to have_selector('#footnotes_debug')
+    end
+  end
+
+  it 'does not alter the page by default' do
+    get :foo
+    expect(response.body).to eq(HTML_DOCUMENT)
+  end
+
+  context 'with footnotes' do
+
+    before :all do
+      Footnotes.enabled = true
+    end
+
+    after :all do
+      Footnotes.enabled = false
+    end
+
+    describe 'by default' do
+      include_context 'has_footnotes'
+
+      before do
+        get :foo
+      end
+
+      it 'includes footnotes in the last div in body' do
+        expect(all('body > :last-child')[0][:id]).to eq('footnotes_debug')
+      end
+
+      it 'includes footnotes in the footnoted_holder div if present' do
+        get :foo_holder
+        expect(response.body).to have_selector('#footnotes_holder > #footnotes_debug')
+      end
+
+      it 'does not alter a html file download' do
+        get :foo_download
+        expect(response.body).to eq(File.open(Rails.root.join('fixtures', 'html_download.html')).read)
+      end
+    end
+
+    describe 'when request is xhr' do
+      include_context 'has_no_footnotes'
+      before do
+        get :foo, xhr: true
+      end
+    end
+
+    describe 'when content type is javascript' do
+      include_context 'has_no_footnotes'
+      before do
+        get :foo_js
+      end
+    end
+
+    describe 'when footnotes is disabled' do
+      include_context 'has_no_footnotes'
+      before do
+        Footnotes.enabled = false
+        get :foo
+      end
+    end
+
+    describe 'with a proc' do
+
+      it 'yields the controller' do
+        c = nil
+        Footnotes.enabled = lambda { |controller| c = controller}
+        get :foo
+        expect(c).to be_kind_of(ActionController::Base)
+      end
+
+      context 'returning true' do
+        include_context 'has_footnotes'
+
+        before do
+          Footnotes.enabled = lambda { true }
+          get :foo
+        end
+      end
+
+      context 'returning false' do
+        include_context 'has_no_footnotes'
+
+        before do
+          Footnotes.enabled = lambda { false }
+          get :foo
+        end
+      end
+
+    end
+
+  end
+
+end