floatable-rails 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d7ba3f4dd67001b178b9cc2ce798c344f93f1f6048835797d50ab30e3b8b233
-  data.tar.gz: 6ac0062262bb636e6e53db639f9cf5ae4efa3abeace90203c93691ccf205b6cc
+  metadata.gz: 9288ca577a553f70abaa3928fe8dd0ac842f080a3ac4408e478fcac5c2d27c2f
+  data.tar.gz: 2947208f0c7d70d327da7ddd8d89504c92526bc142240c82ce8409af85902d63
 SHA512:
-  metadata.gz: 0f446eb455149fd63b77525932f3d61e978f898c687e373218b538e06f307fce16e289073616c4e41b75de9ba55f60b718a1928506399f1793c77d4df0408c97
-  data.tar.gz: 0cfa54163524653e4f0624c17f6677c0ba686e1ef904d168dd7868076ab21a2913d0c3974c9be6801767acaaab2dc83586dfba309128755122b0b1fb071fc298
+  metadata.gz: 158ba1e2e4b3d4a17891907c5cd5af51b428707add8b9d42950dea39d897689961b07e5d02f290bcef9ded34cf8587d99bf3f4e095367ba37151f5bf4088cfee
+  data.tar.gz: 746df7f292f50792d22366625b04d60e5a9ba5c09335a3bd0f68f6fc421d84ce81bf6bec8369c6924ca9e472e1e735de34cac12ea0f02fac12416ee5370b2a9a

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.1.4
+
+- Fix Slim marker insertion to avoid interfering with block rendering.
+
+## 0.1.3
+
+- Add `instrumentation_enabled` config to toggle HTML instrumentation separately from script injection.
+- Switch ERB/Slim instrumentation to view markers and assign Base64-encoded ids instead of line numbers.
+- Remove `data-floatable-content` population from tag instrumentation.
+- Log middleware backtraces and re-raise errors in development/test.
+
 ## 0.1.2
 
 - Fix Slim instrumentation for doctype/header structure, filters, and control-flow continuations.

data/README.md

@@ -47,6 +47,10 @@ Floatable::Rails.configure do |config|
     Rails.env.development? || ENV["FLOATABLE_ENABLED"] == "1"
   end
 
+  # Disable HTML instrumentation (data attributes, view markers).
+  # Script injection still follows `config.enabled`.
+  config.instrumentation_enabled = true
+
   # Metadata passed as data attributes on the script tag.
   config.script_workspace = "your-floatable-workspace"
   config.script_repository = "your-floatable-repo"

data/lib/floatable/rails/engine.rb

@@ -1,8 +1,8 @@
 require "rails"
 require "floatable/rails/helpers"
 require "floatable/rails/tag_instrumentation"
-require "floatable/rails/erb_line_instrumentation"
-require "floatable/rails/slim_line_instrumentation"
+require "floatable/rails/erb_view_instrumentation"
+require "floatable/rails/slim_view_instrumentation"
 require "floatable/rails/response_middleware"
 
 module Floatable
@@ -17,14 +17,14 @@ module Floatable
         end
       end
 
-      initializer "floatable.rails.erb_line_instrumentation" do
+      initializer "floatable.rails.erb_view_instrumentation" do
         ActiveSupport.on_load(:action_view) do
           ::ActionView::Template::Handlers::ERB.prepend(::Floatable::Rails::ErbHandlerPatch)
-          ::ActionView::Template::Handlers::ERB.erb_implementation = ::Floatable::Rails::ErubiWithFloatableLines
+          ::ActionView::Template::Handlers::ERB.erb_implementation = ::Floatable::Rails::ErubiWithFloatableViewMarkers
         end
       end
 
-      initializer "floatable.rails.slim_line_instrumentation" do
+      initializer "floatable.rails.slim_view_instrumentation" do
         ActiveSupport.on_load(:action_view) do
           next unless defined?(::Slim::RailsTemplate)
 
@@ -32,7 +32,6 @@ module Floatable
         end
       end
 
-
       initializer "floatable.rails.controller_helpers" do
         ActiveSupport.on_load(:action_controller_base) do
           helper ::Floatable::Rails::Helpers

data/lib/floatable/rails/erb_view_instrumentation.rb

@@ -0,0 +1,67 @@
+require "pathname"
+
+module Floatable
+  module Rails
+    module ErbHandlerPatch
+      def call(template, source)
+        source ||= template.source
+        template_source = source.b
+
+        erb = template_source.gsub(self.class::ENCODING_TAG, "")
+        encoding = $2
+
+        erb.force_encoding valid_encoding(source.dup, encoding)
+        erb.encode!
+        erb.chomp! if strip_trailing_newlines
+
+        options = {
+          escape: (self.class.escape_ignore_list.include? template.type),
+          trim: (self.class.erb_trim_mode == "-"),
+          filename: template.identifier
+        }
+
+        self.class.erb_implementation.new(erb, options).src
+      end
+    end
+
+    class ErubiWithFloatableViewMarkers < ::ActionView::Template::Handlers::ERB::Erubi
+      def initialize(input, properties = {})
+        view_path = floatable_views_path(properties[:filename])
+
+        if view_path.present?
+          properties = properties.dup
+          bufvar = properties[:bufvar] || "@output_buffer"
+          postamble = properties[:postamble] || bufvar
+
+          properties[:preamble] =
+            "#{properties[:preamble]}" \
+            "@output_buffer.safe_append='<!-- #{::Floatable::Rails::VIEW_COMMENT_BEGIN} #{view_path} -->' if Thread.current[:floatable_enabled];"
+
+          properties[:postamble] =
+            "@output_buffer.safe_append='<!-- #{::Floatable::Rails::VIEW_COMMENT_END} #{view_path} -->' if Thread.current[:floatable_enabled];" \
+            "#{postamble}"
+        end
+
+        super
+      end
+
+      private
+
+      def floatable_views_path(filename)
+        return nil if filename.nil?
+
+        str = filename.to_s
+        return nil unless str.include?("/app/views/") || str.start_with?("app/views/")
+
+        return str if str.start_with?("app/views/")
+
+        app_root = ::Rails.root.to_s
+        return str unless app_root.present?
+
+        Pathname.new(str).relative_path_from(Pathname.new(app_root)).to_s
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/floatable/rails/response_middleware.rb

@@ -1,7 +1,5 @@
 require "nokogiri"
-require "erb"
-require "json"
-require "floatable/rails/erb_line_instrumentation"
+require "base64"
 
 module Floatable
   module Rails
@@ -12,7 +10,9 @@ module Floatable
 
       def call(env)
         enabled = floatable_enabled?(env)
-        Thread.current[:floatable_enabled] = enabled
+        instrument = enabled && ::Floatable::Rails.instrumentation_enabled?
+        Thread.current[:floatable_enabled] = instrument
+
         status = headers = body = nil
         begin
           status, headers, body = @app.call(env)
@@ -20,14 +20,14 @@ module Floatable
           Thread.current[:floatable_enabled] = nil
         end
 
-        return [ status, headers, body ] unless html_response?(status, headers)
         return [ status, headers, body ] unless enabled
+        return [ status, headers, body ] unless html_response?(status, headers)
 
         raw = +""
         body.each { |chunk| raw << chunk.to_s }
         body.close if body.respond_to?(:close)
 
-        instrumented = instrument_html(raw, env)
+        instrumented = instrument ? instrument_html(raw) : raw
         final_html = inject_script(instrumented)
 
         headers["Content-Length"] = final_html.bytesize.to_s if headers["Content-Length"]
@@ -35,6 +35,14 @@ module Floatable
         [ status, headers, [ final_html ] ]
       rescue => e
         ::Rails.logger.error("[Floatable::Rails::ResponseMiddleware] failed: #{e.class} - #{e.message}")
+        if e.backtrace
+          e.backtrace.first(30).each do |line|
+            ::Rails.logger.error("  #{line}")
+          end
+        end
+
+        raise if ::Rails.env.development? || ::Rails.env.test?
+
         status ||= 500
         headers ||= {}
         body ||= []
@@ -57,40 +65,18 @@ module Floatable
         false
       end
 
-      def instrument_html(html, env)
+      def instrument_html(html)
         return html if html.strip.empty?
 
         doctype = html[/\A\s*<!DOCTYPE[^>]*>/i]
         doc = Nokogiri::HTML.parse(html)
+
         doc.css("*").each do |node|
           name = node.name.to_s.downcase
           next if %w[script style].include?(name)
-
-          # Don't override helper-provided metadata
-          has_path = node["data-floatable-path"].present?
-
-          unless node["data-floatable-content"].present?
-            data = {
-              name:  node.name,
-              text:  node.text.to_s.strip.presence,
-              class: node["class"].to_s.presence,
-              id:    node["id"].to_s.presence
-            }.compact
-
-            if data.any?
-              encoded = ERB::Util.url_encode(JSON.generate(data)) rescue nil
-              node["data-floatable-content"] = encoded if encoded
-            end
-          end
-
-          next if has_path
         end
 
-        apply_view_annotations(doc)
-        # Top → down: let descendants inherit path from ancestors when safe
-        propagate_file_metadata_down(doc)
-        # Ensure ids are present and consistent once paths are known
-        assign_floatable_ids(doc)
+        apply_view_markers_and_assign_ids(doc)
 
         rendered = doc.to_html
         return rendered if doctype.nil? || rendered.lstrip.start_with?("<!DOCTYPE")
@@ -101,31 +87,54 @@ module Floatable
         html
       end
 
-      # Top → down: walk the tree and carry the closest ancestor's path
-      # down to all descendants that don't have their own.
-      def propagate_file_metadata_down(doc)
-        doc.children.each do |child|
-          next unless child.element?
-          propagate_file_metadata_down_from_node(child, current_path: nil)
-        end
-      rescue => e
-        ::Rails.logger.debug("[Floatable::Rails] propagate_file_metadata_down failed: #{e.class} - #{e.message}")
-      end
+      def apply_view_markers_and_assign_ids(doc)
+        view_stack = []
+        counters = Hash.new(0)
+
+        doc.traverse do |node|
+          if node.comment?
+            content = node.content.to_s.strip
 
-      def propagate_file_metadata_down_from_node(node, current_path:)
-        # Update context with this node's path if it has it
-        node_path = node["data-floatable-path"].presence || current_path
+            view_comment_begin = ::Floatable::Rails::VIEW_COMMENT_BEGIN
+            if content.start_with?(view_comment_begin)
+              path = content.delete_prefix(view_comment_begin).strip
+              view_stack << (app_views_path?(path) ? path : nil)
+              next
+            end
 
-        # If this node doesn't have path but context does, inherit it
-        if node_path && node["data-floatable-path"].blank?
-          node["data-floatable-path"] = node_path
-        end
+            if content.start_with?(::Floatable::Rails::VIEW_COMMENT_END)
+              view_stack.pop
+              next
+            end
 
-        next_path = layout_path?(node_path) ? nil : node_path
+            next
+          end
 
-        node.element_children.each do |child|
-          propagate_file_metadata_down_from_node(child, current_path: next_path)
+          next unless node.element?
+
+          name = node.name.to_s.downcase
+          next if %w[script style].include?(name)
+
+          current_path = view_stack.reverse.find(&:present?)
+          next if current_path.blank?
+
+          node["data-floatable-path"] ||= current_path
+          if node["data-floatable-id"].blank?
+            counters[current_path] += 1
+            encoded = Base64.urlsafe_encode64(counters[current_path].to_s, padding: false)
+            node["data-floatable-id"] = "#{current_path}:#{encoded}"
+          end
         end
+
+        # Remove all comments, including our markers.
+        doc.xpath("//comment()").remove
+      rescue => e
+        ::Rails.logger.debug("[Floatable::Rails] apply_view_markers_and_assign_ids failed: #{e.class} - #{e.message}")
+      end
+
+      def app_views_path?(path)
+        str = path.to_s
+        str.include?("/app/views/") || str.start_with?("app/views/")
       end
 
       def inject_script(html)
@@ -148,79 +157,6 @@ module Floatable
         ::Rails.logger.error("[Floatable::Rails::ResponseMiddleware] inject_script failed: #{e.class} - #{e.message}")
         html
       end
-
-      def assign_floatable_ids(doc)
-        doc.css("*[data-floatable-path]").each do |node|
-          line = node["data-floatable-line"].presence
-          next unless line
-
-          desired = "#{node["data-floatable-path"]}:#{line}"
-          node["data-floatable-id"] = desired if node["data-floatable-id"] != desired
-        end
-      rescue => e
-        ::Rails.logger.debug("[Floatable::Rails] assign_floatable_ids failed: #{e.class} - #{e.message}")
-      end
-
-      def layout_path?(path)
-        str = path.to_s
-        str.include?("/app/views/layouts/") || str.start_with?("app/views/layouts/")
-      end
-
-      def app_views_path?(path)
-        str = path.to_s
-        str.include?("/app/views/") || str.start_with?("app/views/")
-      end
-
-      def apply_view_annotations(doc)
-        view_stack = []
-        line_prefix = ::Floatable::Rails::ErbLineInstrumentation::LINE_MARKER_PREFIX
-        expr_line_prefix = ::Floatable::Rails::ErbLineInstrumentation::EXPR_LINE_MARKER_PREFIX
-        line_comment_re = /\A#{Regexp.escape(line_prefix)}\d+\z/
-        expr_comment_re = /\A#{Regexp.escape(expr_line_prefix)}\d+\z/
-        doc.traverse do |node|
-          if node.comment?
-            content = node.content.to_s.strip
-            if content.start_with?("BEGIN ")
-              path = content.delete_prefix("BEGIN ").strip
-              view_stack << path if app_views_path?(path)
-              next
-            end
-
-            if content.start_with?("END ")
-              path = content.delete_prefix("END ").strip
-              view_stack.pop if view_stack.last == path
-              next
-            end
-
-            next
-          end
-
-          next unless node.element?
-
-          current_path = view_stack.last
-          node["data-floatable-path"] ||= current_path if current_path.present?
-
-          line = floatable_line_from_previous_siblings(node, line_prefix, expr_line_prefix, line_comment_re, expr_comment_re)
-          node["data-floatable-line"] = line if line.to_i > 0 && current_path.present?
-        end
-
-        doc.xpath("//comment()").remove
-      rescue => e
-        ::Rails.logger.debug("[Floatable::Rails] apply_view_annotations failed: #{e.class} - #{e.message}")
-      end
-
-      def floatable_line_from_previous_siblings(node, line_prefix, expr_line_prefix, line_comment_re, expr_comment_re)
-        prev = node.previous_sibling
-        while prev
-          if prev.comment?
-            content = prev.content.to_s.strip
-            return content.delete_prefix(expr_line_prefix).to_i if content.match?(expr_comment_re)
-            return content.delete_prefix(line_prefix).to_i if content.match?(line_comment_re)
-          end
-          prev = prev.previous_sibling
-        end
-        nil
-      end
     end
   end
 end

data/lib/floatable/rails/slim_view_instrumentation.rb

@@ -0,0 +1,80 @@
+require "pathname"
+
+module Floatable
+  module Rails
+    module SlimViewMarkerInstrumenter
+      # Inserts view markers once per template render, gated by Thread.current[:floatable_enabled].
+      def self.instrument(source, view_path)
+        lines = source.to_s.split("\n", -1)
+        return source.to_s if lines.empty?
+
+        first_non_empty = lines.index { |l| !l.strip.empty? } || 0
+
+        # Keep optional Slim headers (doctype) at the very top if present.
+        doctype_idx =
+          if lines[first_non_empty]&.lstrip&.match?(/\A(doctype\b|!!!\b)/)
+            first_non_empty
+          end
+
+        # Insert before the first real line to avoid nesting inside blocks.
+        insert_at = doctype_idx ? (doctype_idx + 1) : first_non_empty
+        insert_at = [ insert_at, lines.length ].min
+
+        marker_indent =
+          if insert_at < lines.length
+            lines[insert_at].to_s[/\A[ \t]*/] || ""
+          else
+            lines[first_non_empty].to_s[/\A[ \t]*/] || ""
+          end
+
+        begin_marker = [
+          "#{marker_indent}- (@output_buffer.safe_concat('<!-- #{::Floatable::Rails::VIEW_COMMENT_BEGIN} #{view_path} -->') if Thread.current[:floatable_enabled] && defined?(@output_buffer)); nil"
+        ]
+        end_marker = [
+          "#{marker_indent}- (@output_buffer.safe_concat('<!-- #{::Floatable::Rails::VIEW_COMMENT_END} #{view_path} -->') if Thread.current[:floatable_enabled] && defined?(@output_buffer)); nil"
+        ]
+
+        out = []
+        lines.each_with_index do |line, idx|
+          out.concat(begin_marker) if idx == insert_at
+          out << line
+        end
+
+        out.concat(begin_marker) if insert_at == lines.length
+
+        out.concat(end_marker)
+        out.join("\n")
+      end
+    end
+
+    module SlimHandlerPatch
+      def call(template, source = nil)
+        return super unless template.format == :html
+
+        view_path = floatable_views_path(template.identifier)
+        return super if view_path.nil?
+
+        instrumented = SlimViewMarkerInstrumenter.instrument(source || template.source, view_path)
+        super(template, instrumented)
+      end
+
+      private
+
+      def floatable_views_path(filename)
+        return nil if filename.nil?
+
+        str = filename.to_s
+        return nil unless str.include?("/app/views/") || str.start_with?("app/views/")
+
+        return str if str.start_with?("app/views/")
+
+        app_root = ::Rails.root.to_s
+        return str unless app_root.present?
+
+        Pathname.new(str).relative_path_from(Pathname.new(app_root)).to_s
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/floatable/rails/tag_instrumentation.rb

@@ -1,6 +1,5 @@
 require "pathname"
-require "json"
-require "erb"
+require "base64"
 
 module Floatable
   module Rails
@@ -13,17 +12,11 @@ module Floatable
           if file
             options[:"data-floatable-path"] ||= floatable_relative_path(file)
             if line
-              options[:"data-floatable-line"] ||= line
-              options[:"data-floatable-id"] ||= "#{options[:"data-floatable-path"]}:#{options[:"data-floatable-line"]}"
+              encoded = Base64.urlsafe_encode64(line.to_s, padding: false)
+              options[:"data-floatable-id"] ||= "#{options[:"data-floatable-path"]}:#{encoded}"
             end
           end
 
-          options[:"data-floatable-content"] ||= floatable_content_attr(
-            tag_name: name,
-            options: options,
-            content_text: block_given? ? nil : content_or_options_with_block
-          )
-
           # Re-shape args for super if we mutated them
           if content_or_options_with_block.is_a?(Hash) && options
             content_or_options_with_block = options
@@ -42,17 +35,11 @@ module Floatable
           if file
             options[:"data-floatable-path"] ||= floatable_relative_path(file)
             if line
-              options[:"data-floatable-line"] ||= line
-              options[:"data-floatable-id"] ||= "#{options[:"data-floatable-path"]}:#{options[:"data-floatable-line"]}"
+              encoded = Base64.urlsafe_encode64(line.to_s, padding: false)
+              options[:"data-floatable-id"] ||= "#{options[:"data-floatable-path"]}:#{encoded}"
             end
           end
 
-          options[:"data-floatable-content"] ||= floatable_content_attr(
-            tag_name: name,
-            options: options,
-            content_text: nil
-          )
-
           return super(name, options, open, escape)
         end
 
@@ -64,27 +51,12 @@ module Floatable
       def floatable_enabled_for_view?
         return false unless respond_to?(:request)
 
-        ::Floatable::Rails.enabled_for?(request)
+        ::Floatable::Rails.instrumentation_enabled? && ::Floatable::Rails.enabled_for?(request)
       rescue => e
         ::Rails.logger.error("[Floatable::Rails::TagInstrumentation] enabled? failed: #{e.class} - #{e.message}")
         false
       end
 
-      def floatable_content_attr(tag_name:, options:, content_text:)
-        data = {
-          name: tag_name.to_s,
-          text: content_text.to_s.presence,
-          class: options[:class].to_s.presence,
-          id: options[:id].to_s.presence
-        }.compact
-
-        return if data.empty?
-
-        ERB::Util.url_encode(JSON.generate(data))
-      rescue
-        nil
-      end
-
       def ensure_options_hash(content_or_options_with_block, options)
         if content_or_options_with_block.is_a?(Hash) && options.nil?
           content_or_options_with_block

data/lib/floatable/rails/version.rb

@@ -1,5 +1,5 @@
 module Floatable
   module Rails
-    VERSION = "0.1.2"
+    VERSION = "0.1.4"
   end
 end

data/lib/floatable/rails.rb

@@ -2,9 +2,11 @@ require "erb"
 require "floatable/rails/version"
 require "floatable/rails/engine"
 
-# lib/floatable/rails.rb
 module Floatable
   module Rails
+    VIEW_COMMENT_BEGIN = "FLOATABLE_VIEW_BEGIN".freeze
+    VIEW_COMMENT_END = "FLOATABLE_VIEW_END".freeze
+
     # Avoid namespace resolution issues for apps that define module Floatable.
     # In that case, `Rails::Application` resolves to `Floatable::Rails::Application`,
     # so provide a compatible alias.
@@ -13,6 +15,8 @@ module Floatable
     class Configuration
       # Proc: ->(request) { true/false }
       attr_accessor :enabled
+      # Toggle for HTML instrumentation (data attributes, view markers)
+      attr_accessor :instrumentation_enabled
       # URL for the Floatable toolbar script
       attr_accessor :script_src
       # Metadata
@@ -28,6 +32,8 @@ module Floatable
           ::Rails.env.development? || ENV["FLOATABLE_ENABLED"] == "1"
         end
 
+        @instrumentation_enabled = true
+
         # Default script for dev; override in host app
         @script_src = "https://assets.floatable.dev/js/toolbar.js"
 
@@ -59,6 +65,10 @@ module Floatable
         false
       end
 
+      def instrumentation_enabled?
+        config.instrumentation_enabled != false
+      end
+
       def script_src
         config.script_src
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: floatable-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Tobias Almstrand
@@ -37,10 +37,10 @@ files:
 - Rakefile
 - lib/floatable/rails.rb
 - lib/floatable/rails/engine.rb
-- lib/floatable/rails/erb_line_instrumentation.rb
+- lib/floatable/rails/erb_view_instrumentation.rb
 - lib/floatable/rails/helpers.rb
 - lib/floatable/rails/response_middleware.rb
-- lib/floatable/rails/slim_line_instrumentation.rb
+- lib/floatable/rails/slim_view_instrumentation.rb
 - lib/floatable/rails/tag_instrumentation.rb
 - lib/floatable/rails/version.rb
 homepage: https://floatable.dev

data/lib/floatable/rails/erb_line_instrumentation.rb

@@ -1,166 +0,0 @@
-require "pathname"
-
-module Floatable
-  module Rails
-    module ErbLineInstrumentation
-      LINE_MARKER_PREFIX = "FLOATABLE_LINE:".freeze
-      EXPR_LINE_MARKER_PREFIX = "FLOATABLE_EXPR_LINE:".freeze
-    end
-
-    module ErbHandlerPatch
-      def call(template, source)
-        source ||= template.source
-        template_source = source.b
-
-        erb = template_source.gsub(self.class::ENCODING_TAG, "")
-        encoding = $2
-
-        erb.force_encoding valid_encoding(source.dup, encoding)
-        erb.encode!
-        erb.chomp! if strip_trailing_newlines
-
-        options = {
-          escape: (self.class.escape_ignore_list.include? template.type),
-          trim: (self.class.erb_trim_mode == "-"),
-          filename: template.identifier
-        }
-
-        if ActionView::Base.respond_to?(:annotate_rendered_view_with_filenames) &&
-            ActionView::Base.annotate_rendered_view_with_filenames &&
-            template.format == :html
-          options[:preamble] = "@output_buffer.safe_append='<!-- BEGIN #{template.short_identifier}\n-->';"
-          options[:postamble] = "@output_buffer.safe_append='<!-- END #{template.short_identifier} -->';@output_buffer"
-        end
-
-        self.class.erb_implementation.new(erb, options).src
-      end
-    end
-
-    class ErubiWithFloatableLines < ::ActionView::Template::Handlers::ERB::Erubi
-      LINE_MARKER_PREFIX = ErbLineInstrumentation::LINE_MARKER_PREFIX
-      EXPR_LINE_MARKER_PREFIX = ErbLineInstrumentation::EXPR_LINE_MARKER_PREFIX
-
-      def initialize(input, properties = {})
-        @floatable_line = 1
-        @floatable_view_path = floatable_views_path(properties[:filename])
-        @floatable_in_views = @floatable_view_path.present?
-        if @floatable_in_views
-          properties = properties.dup
-          bufvar = properties[:bufvar] || "@output_buffer"
-          postamble = properties[:postamble] || bufvar
-          properties[:preamble] = "#{properties[:preamble]}@output_buffer.safe_append='<!-- BEGIN #{@floatable_view_path} -->' if Thread.current[:floatable_enabled];"
-          properties[:postamble] = "@output_buffer.safe_append='<!-- END #{@floatable_view_path} -->' if Thread.current[:floatable_enabled];#{postamble}"
-        end
-        super
-      end
-
-      private
-
-      def add_text(text)
-        return if text.empty?
-
-        if text == "\n"
-          @newline_pending += 1
-          return
-        end
-
-        full_text = ("\n" * @newline_pending) + text
-        with_buffer do
-          src << ".safe_append="
-          if @floatable_in_views
-            src << "(Thread.current[:floatable_enabled] ? "
-            src << floatable_text_literal(full_text)
-            src << " : "
-            src << plain_text_literal(full_text)
-            src << ")"
-          else
-            src << plain_text_literal(full_text)
-          end
-        end
-        @newline_pending = 0
-        @floatable_line += full_text.count("\n")
-      end
-
-      def add_expression(indicator, code)
-        flush_newline_if_pending(src)
-        if @floatable_in_views
-          with_buffer do
-            src << ".safe_append='#{expr_line_marker(@floatable_line)}' if Thread.current[:floatable_enabled];"
-          end
-        end
-        super
-        @floatable_line += code.count("\n")
-      end
-
-      def add_code(code)
-        flush_newline_if_pending(src)
-        super
-        @floatable_line += code.count("\n")
-      end
-
-      def flush_newline_if_pending(src)
-        return if @newline_pending <= 0
-
-        full_text = "\n" * @newline_pending
-        with_buffer do
-          src << ".safe_append="
-          if @floatable_in_views
-            src << "(Thread.current[:floatable_enabled] ? "
-            src << floatable_text_literal(full_text)
-            src << " : "
-            src << plain_text_literal(full_text)
-            src << ")"
-          else
-            src << plain_text_literal(full_text)
-          end
-        end
-        @floatable_line += @newline_pending
-        @newline_pending = 0
-      end
-
-      def line_marker(line)
-        "<!--#{LINE_MARKER_PREFIX}#{line}-->"
-      end
-
-      def expr_line_marker(line)
-        "<!--#{EXPR_LINE_MARKER_PREFIX}#{line}-->"
-      end
-
-      def floatable_text_literal(text)
-        marked = add_line_markers(text, @floatable_line)
-        plain_text_literal(marked)
-      end
-
-      def plain_text_literal(text)
-        "'" + text.gsub(/['\\]/, '\\\\\&') + @text_end
-      end
-
-      def add_line_markers(text, start_line)
-        lines = text.split("\n", -1)
-        out = +""
-        lines.each_with_index do |line_text, idx|
-          out << line_marker(start_line + idx) << line_text
-          out << "\n" if idx < lines.length - 1
-        end
-        out
-      end
-
-      def floatable_views_path(filename)
-        return nil if filename.nil?
-
-        str = filename.to_s
-        if str.include?("/app/views/") || str.start_with?("app/views/")
-          return str if str.start_with?("app/views/")
-
-          app_root = ::Rails.root.to_s
-          return str unless app_root.present?
-
-          return Pathname.new(str).relative_path_from(Pathname.new(app_root)).to_s
-        end
-        nil
-      rescue
-        nil
-      end
-    end
-  end
-end

data/lib/floatable/rails/slim_line_instrumentation.rb

@@ -1,106 +0,0 @@
-require "pathname"
-
-module Floatable
-  module Rails
-    module SlimLineInstrumenter
-      def self.instrument(source, view_path)
-        lines = source.to_s.split("\n", -1)
-        first_non_empty = lines.index { |line| !line.strip.empty? }
-        doctype_index = if first_non_empty && lines[first_non_empty].lstrip.match?(/\A(doctype\b|!!!\b)/)
-          first_non_empty
-        end
-        html_index = nil
-        if doctype_index
-          html_index = lines[(doctype_index + 1)..].to_a.index { |line| !line.strip.empty? && line.lstrip.match?(/\Ahtml\b/) }
-          html_index = html_index ? html_index + doctype_index + 1 : nil
-        end
-        header_index = html_index || doctype_index
-        marker_indent = ""
-        if header_index
-          next_non_empty = lines[(header_index + 1)..].to_a.find { |line| !line.strip.empty? }
-          marker_indent = next_non_empty ? (next_non_empty[/\A[ \t]*/] || "") : ((lines[header_index][/\A[ \t]*/] || "") + "  ")
-        end
-        out = []
-        begin_marker = "#{marker_indent}== (Thread.current[:floatable_enabled] && defined?(@output_buffer)) ? '<!-- BEGIN #{view_path} -->' : ''"
-        end_marker = "#{marker_indent}== (Thread.current[:floatable_enabled] && defined?(@output_buffer)) ? '<!-- END #{view_path} -->' : ''"
-        out << begin_marker if header_index.nil?
-        filter_indent = nil
-
-        lines.each_with_index do |line, idx|
-          if header_index && idx < header_index
-            out << line
-            next
-          end
-
-          if header_index && idx == header_index
-            out << line
-            out << begin_marker
-            next
-          end
-
-          indent = line[/\A[ \t]*/] || ""
-          indent_level = indent.size
-          stripped = line.lstrip
-          if stripped.empty?
-            out << line
-            next
-          end
-
-          if stripped.match?(/\A-\s*(else|elsif|when|rescue|ensure)\b/)
-            out << line
-            next
-          end
-
-          if filter_indent && indent_level > filter_indent
-            out << line
-            next
-          end
-
-          filter_indent = nil if filter_indent && indent_level <= filter_indent
-
-          if stripped.match?(/\A[a-zA-Z_][\w-]*:\s*\z/) && !stripped.start_with?("-", "=", "|")
-            filter_indent = indent_level
-            out << line
-            next
-          end
-
-          out << "#{indent}== (Thread.current[:floatable_enabled] && defined?(@output_buffer)) ? '<!--#{ErbLineInstrumentation::LINE_MARKER_PREFIX}#{idx + 1}-->' : ''"
-          out << line
-        end
-
-        out << end_marker
-        out.join("\n")
-      end
-    end
-
-    module SlimHandlerPatch
-      def call(template, source = nil)
-        return super unless template.format == :html
-
-        view_path = floatable_views_path(template.identifier)
-        return super if view_path.nil?
-
-        instrumented = SlimLineInstrumenter.instrument(source || template.source, view_path)
-        super(template, instrumented)
-      end
-
-      private
-
-      def floatable_views_path(filename)
-        return nil if filename.nil?
-
-        str = filename.to_s
-        return nil unless str.include?("/app/views/") || str.start_with?("app/views/")
-
-        return str if str.start_with?("app/views/")
-
-        app_root = ::Rails.root.to_s
-        return str unless app_root.present?
-
-        Pathname.new(str).relative_path_from(Pathname.new(app_root)).to_s
-      rescue
-        nil
-      end
-    end
-  end
-end