blueprint-html2slim 1.0.0 → 1.3.0

data/bin/slimtool

@@ -0,0 +1,238 @@
+#!/usr/bin/env ruby
+require 'thor'
+require 'pathname'
+require_relative '../lib/blueprint/html2slim'
+
+class SlimToolCLI < Thor
+  def self.exit_on_failure?
+    true
+  end
+
+  class_option :help, aliases: '-h', type: :boolean, desc: 'Show help'
+
+  desc 'fix FILE [FILE2 ...]', 'Fix common Slim syntax issues'
+  option :fix_slashes, type: :boolean, default: true, desc: 'Fix forward slashes that should be text (e.g., span /month)'
+  option :fix_multiline, type: :boolean, default: true, desc: 'Fix multiline text blocks using pipe notation'
+  option :backup, aliases: '-b', type: :boolean, desc: 'Create .bak backup before fixing'
+  option :dry_run, aliases: '-n', type: :boolean, desc: 'Preview changes without modifying files'
+  def fix(*files)
+    if files.empty?
+      puts 'Error: No files specified'
+      puts 'Usage: slimtool fix FILE [FILE2 ...]'
+      exit 1
+    end
+
+    require_relative '../lib/blueprint/html2slim/slim_fixer'
+    fixer = Blueprint::Html2Slim::SlimFixer.new(options)
+
+    files.each do |file|
+      if File.exist?(file)
+        result = fixer.fix_file(file)
+        if result[:success]
+          puts "Fixed: #{file}"
+          puts "  Issues fixed: #{result[:fixes].join(", ")}" if result[:fixes].any?
+        else
+          puts "Error fixing #{file}: #{result[:error]}"
+        end
+      else
+        puts "File not found: #{file}"
+      end
+    end
+  end
+
+  desc 'extract FILE', 'Extract content sections from Slim file'
+  option :keep, type: :array, desc: 'Keep only specified sections (e.g., main, article, .content)'
+  option :remove, type: :array, desc: 'Remove specified sections (e.g., head, nav, footer, script)'
+  option :output, aliases: '-o', desc: 'Output file path (default: FILE_extracted.slim)'
+  option :remove_wrapper, type: :boolean, desc: 'Remove single outer wrapper element if present'
+  option :outline, type: :numeric, desc: 'Extract outline up to depth N (e.g., 2 = top two levels only)'
+  option :selector, type: :string, desc: 'CSS selector for fragment extraction (#id, .class, element)'
+  def extract(file)
+    unless File.exist?(file)
+      puts "Error: File not found: #{file}"
+      exit 1
+    end
+
+    require_relative '../lib/blueprint/html2slim/slim_extractor'
+    extractor = Blueprint::Html2Slim::SlimExtractor.new(options)
+
+    result = extractor.extract_file(file)
+    if result[:success]
+      output_path = options[:output] || file.sub(/\.slim$/, '_extracted.slim')
+      puts "Extracted content to: #{output_path}"
+      puts "  Removed: #{result[:removed].join(", ")}" if result[:removed]&.any?
+      puts "  Kept: #{result[:kept].join(", ")}" if result[:kept]&.any?
+    else
+      puts "Error extracting from #{file}: #{result[:error]}"
+    end
+  end
+
+  desc 'validate FILE [FILE2 ...]', 'Validate Slim syntax and check for issues'
+  option :strict, type: :boolean, desc: 'Enable strict mode (check tabs, inline styles, etc.)'
+  option :check_rails, type: :boolean, desc: 'Check Rails conventions (helpers, CSRF, asset pipeline)'
+  def validate(*files)
+    if files.empty?
+      puts 'Error: No files specified'
+      puts 'Usage: slimtool validate FILE [FILE2 ...]'
+      exit 1
+    end
+
+    require_relative '../lib/blueprint/html2slim/slim_validator'
+    validator = Blueprint::Html2Slim::SlimValidator.new(options)
+
+    total_errors = 0
+    total_warnings = 0
+
+    files.each do |file|
+      if File.exist?(file)
+        result = validator.validate_file(file)
+        if result[:valid]
+          puts "✓ #{file} - Valid"
+        else
+          puts "✗ #{file} - Invalid"
+          result[:errors]&.each { |error| puts "  ERROR: #{error}" }
+          total_errors += result[:errors]&.size || 0
+        end
+
+        if result[:warnings]&.any?
+          result[:warnings].each { |warning| puts "  WARNING: #{warning}" }
+          total_warnings += result[:warnings].size
+        end
+      else
+        puts "File not found: #{file}"
+        total_errors += 1
+      end
+    end
+
+    puts "\nValidation complete: #{total_errors} error(s), #{total_warnings} warning(s)"
+    exit(1) if total_errors.positive?
+  end
+
+  desc 'railsify FILE [FILE2 ...]', 'Convert static Slim to Rails conventions'
+  option :add_helpers, type: :boolean, default: true, desc: 'Convert links to Rails helpers (requires --mappings)'
+  option :use_assets, type: :boolean, default: true, desc: 'Convert CDN assets to Rails asset pipeline'
+  option :add_csrf, type: :boolean, desc: 'Add CSRF meta tags to head section'
+  option :backup, aliases: '-b', type: :boolean, desc: 'Create .bak backup before converting'
+  option :dry_run, aliases: '-n', type: :boolean, desc: 'Preview changes without modifying files'
+  option :mappings, type: :string, desc: 'JSON/YAML file with URL-to-helper mappings (required for link conversion)'
+  def railsify(*files)
+    if files.empty?
+      puts 'Error: No files specified'
+      puts 'Usage: slimtool railsify FILE [FILE2 ...]'
+      exit 1
+    end
+
+    require_relative '../lib/blueprint/html2slim/slim_railsifier'
+    railsifier = Blueprint::Html2Slim::SlimRailsifier.new(options)
+
+    files.each do |file|
+      if File.exist?(file)
+        result = railsifier.railsify_file(file)
+        if result[:success]
+          puts "Railsified: #{file}"
+          puts "  Conversions: #{result[:conversions].join(", ")}" if result[:conversions]&.any?
+        else
+          puts "Error converting #{file}: #{result[:error]}"
+        end
+      else
+        puts "File not found: #{file}"
+      end
+    end
+  end
+
+  desc 'extract-links FILE [FILE2 ...]', 'Find and report all hardcoded links'
+  option :output, aliases: '-o', desc: 'Save results to file (auto-detect format by extension)'
+  option :format, default: 'json', enum: %w[json yaml text], desc: 'Output format (json, yaml, or text)'
+  def extract_links(*files)
+    if files.empty?
+      puts 'Error: No files specified'
+      puts 'Usage: slimtool extract-links FILE [FILE2 ...]'
+      exit 1
+    end
+
+    require_relative '../lib/blueprint/html2slim/link_extractor'
+    extractor = Blueprint::Html2Slim::LinkExtractor.new(options)
+
+    all_links = {}
+
+    files.each do |file|
+      if File.exist?(file)
+        result = extractor.extract_links(file)
+        if result[:success]
+          all_links[file] = result[:links] if result[:links].any?
+        else
+          puts "Error extracting from #{file}: #{result[:error]}"
+        end
+      else
+        puts "File not found: #{file}"
+      end
+    end
+
+    if all_links.any?
+      if options[:output]
+        extractor.save_links(all_links, options[:output])
+        puts "Extracted links saved to: #{options[:output]}"
+      else
+        extractor.display_links(all_links)
+      end
+
+      total = all_links.values.flatten.size
+      puts "\nTotal: #{total} hardcoded link(s) found in #{all_links.keys.size} file(s)"
+    else
+      puts 'No hardcoded links found'
+    end
+  end
+
+  desc 'version', 'Show version'
+  def version
+    require_relative '../lib/blueprint/html2slim/version'
+    puts "slimtool #{Blueprint::Html2Slim::VERSION}"
+  end
+
+  def self.start(given_args = ARGV, config = {})
+    # Show general help for no args or 'help' without specific command
+    if given_args.empty? || (given_args == ['help']) || (given_args == ['-h']) || (given_args == ['--help'])
+      puts 'Slim Template Manipulation Tool'
+      puts ''
+      puts 'Usage: slimtool COMMAND [OPTIONS] FILE [FILE2 ...]'
+      puts ''
+      puts 'Commands:'
+      puts '  fix           Fix common Slim syntax issues'
+      puts '  extract       Extract content sections from Slim files'
+      puts '  validate      Validate Slim syntax'
+      puts '  railsify      Convert to Rails conventions'
+      puts '  extract-links Extract hardcoded links from templates'
+      puts '  version       Show version'
+      puts '  help          Show this help message'
+      puts ''
+      puts 'Examples:'
+      puts '  # Fix text starting with slash'
+      puts '  slimtool fix pricing.slim'
+      puts ''
+      puts '  # Extract main content, removing navigation'
+      puts '  slimtool extract index.slim --remove head,nav,footer'
+      puts ''
+      puts '  # Extract high-level structure only'
+      puts '  slimtool extract page.slim --outline 2'
+      puts ''
+      puts '  # Extract specific section by CSS selector'
+      puts '  slimtool extract page.slim --selector "#content"'
+      puts ''
+      puts '  # Validate with strict style checking'
+      puts '  slimtool validate *.slim --strict --check-rails'
+      puts ''
+      puts '  # Convert to Rails helpers with custom mappings'
+      puts '  slimtool railsify template.slim --mappings urls.json'
+      puts ''
+      puts '  # Find all hardcoded links'
+      puts '  slimtool extract-links views/**/*.slim -o links.json'
+      puts ''
+      puts 'Run "slimtool COMMAND --help" for more information on a command.'
+      exit 0
+    else
+      super
+    end
+  end
+end
+
+SlimToolCLI.start(ARGV)

data/lib/blueprint/html2slim/converter.rb

@@ -17,25 +17,25 @@ module Blueprint
 
       def convert(html_content)
         lines = []
-        
+
         # Handle DOCTYPE declaration
         if html_content =~ /<!DOCTYPE\s+(.+?)>/i
           doctype_content = ::Regexp.last_match(1)
-          if doctype_content =~ /strict/i
-            lines << "doctype strict"
-          elsif doctype_content =~ /transitional/i
-            lines << "doctype transitional"
-          elsif doctype_content =~ /frameset/i
-            lines << "doctype frameset"
-          elsif doctype_content =~ /html$/i
-            lines << "doctype html"
-          else
-            lines << "doctype"
-          end
+          lines << if doctype_content =~ /strict/i
+                     'doctype strict'
+                   elsif doctype_content =~ /transitional/i
+                     'doctype transitional'
+                   elsif doctype_content =~ /frameset/i
+                     'doctype frameset'
+                   elsif doctype_content =~ /html$/i
+                     'doctype html'
+                   else
+                     'doctype'
+                   end
           # Remove DOCTYPE from content for further processing
           html_content = html_content.sub(/<!DOCTYPE\s+.+?>/i, '')
         end
-        
+
         html_content = preprocess_erb(html_content)
         # Use HTML.parse for full documents, DocumentFragment for fragments
         if html_content =~ /<html/i
@@ -68,7 +68,7 @@ module Blueprint
       def preprocess_erb(content)
         # Convert ERB blocks to span elements to preserve hierarchy
         # This approach is inspired by the original html2slim gem
-        
+
         # Keep ERB tags in attributes unchanged by temporarily replacing them
         erb_in_attrs = []
         content = content.gsub(/(<[^>]*)(<%=?.+?%>)([^>]*>)/) do
@@ -79,65 +79,79 @@ module Blueprint
           erb_in_attrs << erb
           "#{before}#{placeholder}#{after}"
         end
-        
+
         # Handle multi-line ERB blocks first (with m flag for multiline)
         content = content.gsub(/<%\s*\n(.*?)\n\s*-?%>/m) do
-          code_lines = ::Regexp.last_match(1).strip.split("\n")
-          # Convert to multiple single-line ERB comments
-          code_lines.map { |line| "<!--ERB_CODE:#{line.strip}-->" }.join("\n")
+          code_block = ::Regexp.last_match(1).strip
+          # Mark as multiline block for special handling
+          "<!--ERB_MULTILINE_CODE:#{code_block.gsub("-->", "__ARROW__")}-->"
+        end
+
+        # Handle multiline ERB output blocks (e.g., <%= form_with(...) spanning multiple lines %>)
+        content = content.gsub(/<%=\s*\n(.*?)\n\s*-?%>/m) do
+          code_block = ::Regexp.last_match(1).strip
+          # Check if it ends with do block
+          if code_block =~ /\bdo\s*(\|[^|]*\|)?\s*$/
+            # Convert to single line for block processing
+            single_line = code_block.gsub(/\s+/, ' ')
+            "<%= #{single_line} %>" # Keep for block processing
+          else
+            # Mark as multiline output for special handling
+            "<!--ERB_MULTILINE_OUTPUT:#{code_block.gsub("-->", "__ARROW__")}-->"
+          end
         end
-        
+
         # Convert simple ERB output tags that don't create blocks
         # This prevents them from being caught by the block regex
         content = content.gsub(/<%=\s*([^%]+?)\s*%>/) do
           code = ::Regexp.last_match(1).strip
           # Skip if it's a do block
           if code =~ /\bdo\s*(\|[^|]*\|)?\s*$/
-            "<%= #{code} %>"  # Keep original, will be processed later
+            "<%= #{code} %>" # Keep original, will be processed later
           else
             %(<!--ERB_OUTPUT:#{code}-->)
           end
         end
-        
+
         # Convert ERB blocks that create structure (do...end, if...end, etc.)
         # to span elements so their content becomes proper children
-        content = content.gsub(/<%(-|=)?\s*((\s*(case|if|for|unless|until|while) .+?)|.+?do\s*(\|[^|]*\|)?\s*)-?%>/) do
+        content = content.gsub(/<%(-|=)?\s*((\s*(case|if|for|unless|until|while) .+?)|.+?do\s*(\|[^|]*\|)?\s*)-?%>/m) do
           type = ::Regexp.last_match(1)
           code = ::Regexp.last_match(2).strip
           # Preserve whether it was = or - in the code attribute
           prefix = type == '=' ? '=' : ''
-          %(<span erb-code="#{prefix}#{code.gsub('"', '&quot;')}">)
+          %(<span erb-code="#{prefix}#{code.gsub('"', "&quot;")}">)
         end
-        
+
         # Handle else
         content = content.gsub(/<%-?\s*else\s*-?%>/, %(</span><span erb-code="else">))
-        
+
         # Handle elsif
         content = content.gsub(/<%-?\s*(elsif .+?)\s*-?%>/) do
           code = ::Regexp.last_match(1).strip
-          %(</span><span erb-code="#{code.gsub('"', '&quot;')}">)
+          %(</span><span erb-code="#{code.gsub('"', "&quot;")}">)
         end
-        
+
         # Handle when
         content = content.gsub(/<%-?\s*(when .+?)\s*-?%>/) do
           code = ::Regexp.last_match(1).strip
-          %(</span><span erb-code="#{code.gsub('"', '&quot;')}">)
+          %(</span><span erb-code="#{code.gsub('"', "&quot;")}">)
         end
-        
+
         # Handle end statements - close the span
         content = content.gsub(/<%\s*(end|}|end\s+-)\s*%>/, %(</span>))
-        
+
         # Convert any remaining ERB code tags to comments
         content = content.gsub(/<%-?\s*(.+?)\s*%>/) do
           code = ::Regexp.last_match(1).strip
           %(<!--ERB_CODE:#{code}-->)
         end
-        
+
         # Restore ERB tags in attributes
         erb_in_attrs.each_with_index do |erb, i|
           content = content.gsub("ERB_IN_ATTR_#{i}", erb)
         end
-        
+
         content
       end
 
@@ -161,24 +175,24 @@ module Blueprint
         # Check if this is an ERB span element
         if node.name == 'span' && node['erb-code']
           erb_code = node['erb-code'].gsub('&quot;', '"')
-          
+
           # Determine if it's output (=) or code (-)
-          if erb_code =~ /^(if|unless|case|for|while|elsif|else|when)\b/
-            lines << "#{indent}- #{erb_code}"
-          elsif erb_code.start_with?('=')
-            # It was originally <%= ... %>, use = prefix
-            lines << "#{indent}= #{erb_code[1..-1].strip}"
-          else
-            # It was originally <% ... %>, use - prefix
-            lines << "#{indent}- #{erb_code}"
-          end
-          
+          lines << if erb_code =~ /^(if|unless|case|for|while|elsif|else|when)\b/
+                     "#{indent}- #{erb_code}"
+                   elsif erb_code.start_with?('=')
+                     # It was originally <%= ... %>, use = prefix
+                     "#{indent}= #{erb_code[1..-1].strip}"
+                   else
+                     # It was originally <% ... %>, use - prefix
+                     "#{indent}- #{erb_code}"
+                   end
+
           # Process children with increased depth
           node.children.each do |child|
             child_lines = process_node(child, depth + 1)
             lines.concat(child_lines) unless child_lines.empty?
           end
-          
+
           return lines
         end
 
@@ -206,6 +220,10 @@ module Blueprint
             text = process_inline_text(text.strip)
             if text.empty?
               lines << "#{indent}#{tag_line}"
+            elsif text.start_with?('/')
+              # Text starting with / needs pipe notation to avoid being treated as comment
+              lines << "#{indent}#{tag_line}"
+              lines << "#{" " * ((depth + 1) * @indent_size)}| #{text}"
             else
               lines << "#{indent}#{tag_line} #{text}"
             end
@@ -227,7 +245,7 @@ module Blueprint
         # Strip and split classes, filtering out empty strings
         classes = node['class']&.strip&.split(/\s+/)&.reject(&:empty?) || []
         attributes = collect_attributes(node)
-        
+
         # Treat empty id as no id
         id = nil if id && id.strip.empty?
 
@@ -299,14 +317,36 @@ module Blueprint
         # Extract indentation level if present
         extra_indent = 0
         if comment_text =~ /:INDENT:(\d+)$/
-          extra_indent = $1.to_i
+          extra_indent = ::Regexp.last_match(1).to_i
           comment_text = comment_text.sub(/:INDENT:\d+$/, '')
         end
-        
+
         total_depth = depth + extra_indent
         indent = ' ' * (total_depth * @indent_size)
 
-        if comment_text.start_with?('ERB_OUTPUT_BLOCK:')
+        if comment_text.start_with?('ERB_MULTILINE_CODE:')
+          erb_content = comment_text.sub('ERB_MULTILINE_CODE:', '').gsub('__ARROW__', '-->')
+          # Use ruby: block for multiline code
+          lines = ["#{indent}ruby:"]
+          erb_content.lines.each do |line|
+            lines << "#{indent}  #{line.rstrip}"
+          end
+          lines
+        elsif comment_text.start_with?('ERB_MULTILINE_OUTPUT:')
+          erb_content = comment_text.sub('ERB_MULTILINE_OUTPUT:', '').gsub('__ARROW__', '-->')
+          # For multiline output, use line continuation
+          lines = erb_content.lines.map(&:rstrip)
+          if lines.length == 1
+            ["#{indent}= #{lines[0]}"]
+          else
+            result = ["#{indent}= #{lines[0]} \\"]
+            lines[1..-2].each do |line|
+              result << "#{indent}    #{line} \\"
+            end
+            result << "#{indent}    #{lines[-1]}" if lines.length > 1
+            result
+          end
+        elsif comment_text.start_with?('ERB_OUTPUT_BLOCK:')
           erb_content = comment_text.sub('ERB_OUTPUT_BLOCK:', '')
           ["#{indent}= #{erb_content}"]
         elsif comment_text.start_with?('ERB_OUTPUT:')

data/lib/blueprint/html2slim/link_extractor.rb

@@ -0,0 +1,203 @@
+require_relative 'slim_manipulator'
+require 'json'
+require 'yaml'
+
+module Blueprint
+  module Html2Slim
+    class LinkExtractor < SlimManipulator
+      def extract_links(file_path)
+        content = read_file(file_path)
+        structure = parse_slim_structure(content)
+
+        links = []
+
+        structure.each do |item|
+          line = item[:stripped]
+          line_num = item[:line_number]
+
+          # Extract links from anchor tags
+          if line =~ /^(\s*)a\[.*href=["']([^"']+)["']/
+            href = ::Regexp.last_match(2)
+            # Identify hardcoded links (not Rails helpers, not variables)
+            if is_hardcoded_link?(href)
+              links << {
+                line: line_num,
+                type: 'anchor',
+                href: href,
+                full_line: line,
+                suggested_helper: suggest_rails_helper(href)
+              }
+            end
+          end
+
+          # Extract links from form actions
+          if line =~ /^(\s*)form\[.*action=["']([^"']+)["']/
+            action = ::Regexp.last_match(2)
+            if is_hardcoded_link?(action)
+              links << {
+                line: line_num,
+                type: 'form',
+                href: action,
+                full_line: line,
+                suggested_helper: suggest_rails_helper(action)
+              }
+            end
+          end
+
+          # Extract stylesheet links
+          if line =~ /link\[.*href=["']([^"']+\.css[^"']*)["']/
+            href = ::Regexp.last_match(1)
+            if !href.start_with?('http') && !href.start_with?('//')
+              links << {
+                line: line_num,
+                type: 'stylesheet',
+                href: href,
+                full_line: line,
+                suggested_helper: "stylesheet_link_tag '#{File.basename(href, ".*")}'"
+              }
+            end
+          end
+
+          # Extract script sources
+          if line =~ /script\[.*src=["']([^"']+\.js[^"']*)["']/
+            src = ::Regexp.last_match(1)
+            if !src.start_with?('http') && !src.start_with?('//')
+              links << {
+                line: line_num,
+                type: 'javascript',
+                href: src,
+                full_line: line,
+                suggested_helper: "javascript_include_tag '#{File.basename(src, ".*")}'"
+              }
+            end
+          end
+
+          # Extract image sources
+          next unless line =~ /img\[.*src=["']([^"']+)["']/
+
+          src = ::Regexp.last_match(1)
+          next unless !src.start_with?('http') && !src.start_with?('//') && !src.include?('<%')
+
+          links << {
+            line: line_num,
+            type: 'image',
+            href: src,
+            full_line: line,
+            suggested_helper: "image_tag '#{src}'"
+          }
+        end
+
+        { success: true, links: links }
+      rescue StandardError => e
+        { success: false, error: e.message }
+      end
+
+      def save_links(all_links, output_path)
+        format = options[:format] || 'json'
+
+        case format
+        when 'json'
+          File.write(output_path, JSON.pretty_generate(all_links))
+        when 'yaml'
+          File.write(output_path, all_links.to_yaml)
+        when 'text'
+          content = []
+          all_links.each do |file, links|
+            content << "File: #{file}"
+            links.each do |link|
+              content << "  Line #{link[:line]} (#{link[:type]}): #{link[:href]}"
+              content << "    Suggested: #{link[:suggested_helper]}" if link[:suggested_helper]
+            end
+            content << ''
+          end
+          File.write(output_path, content.join("\n"))
+        end
+      end
+
+      def display_links(all_links)
+        all_links.each do |file, links|
+          puts "\n#{file}:"
+          links.each do |link|
+            puts "  Line #{link[:line]} (#{link[:type]}): #{link[:href]}"
+            puts "    → Suggested: #{link[:suggested_helper]}" if link[:suggested_helper]
+          end
+        end
+      end
+
+      private
+
+      def is_hardcoded_link?(href)
+        # It's hardcoded if it's not a Rails helper or ERB expression
+        return false if href.include?('_path') || href.include?('_url')
+        return false if href.include?('<%') || href.include?('#{')
+        return false if href.start_with?('@') || href.start_with?(':')
+
+        # It's hardcoded if it's a static file or path
+        href.match?(/\.(html|htm|php|jsp|asp)$/) ||
+          href.match?(%r{^/\w+}) ||
+          href == '#' ||
+          href.match?(/^[a-z]+\.html$/i)
+      end
+
+      def suggest_rails_helper(href)
+        # Exact matches for common pages
+        common_mappings = {
+          'index.html' => 'root_path',
+          'home.html' => 'root_path',
+          'login.html' => 'login_path',
+          'signin.html' => 'login_path',
+          'signup.html' => 'signup_path',
+          'register.html' => 'new_user_registration_path',
+          'about.html' => 'about_path',
+          'contact.html' => 'contact_path',
+          'privacy.html' => 'privacy_path',
+          'terms.html' => 'terms_path',
+          'dashboard.html' => 'dashboard_path',
+          'profile.html' => 'profile_path',
+          'settings.html' => 'settings_path'
+        }
+
+        # Check for exact match
+        clean_href = href.sub(%r{^/}, '')
+        return common_mappings[clean_href] if common_mappings[clean_href]
+
+        # Handle resource patterns
+        case href
+        when %r{^/?users?/(\d+|:id)}
+          'user_path(@user)'
+        when %r{^/?users?$}, '/users'
+          'users_path'
+        when %r{^/?posts?/(\d+|:id)}
+          'post_path(@post)'
+        when %r{^/?posts?$}, '/posts'
+          'posts_path'
+        when %r{^/?articles?/(\d+|:id)}
+          'article_path(@article)'
+        when %r{^/?articles?$}, '/articles'
+          'articles_path'
+        when %r{^/?products?/(\d+|:id)}
+          'product_path(@product)'
+        when %r{^/?products?$}, '/products'
+          'products_path'
+        when /^#/
+          nil # Anchor links don't need conversion
+        else
+          # Generic suggestion based on path
+          path = href.sub(%r{^/}, '').sub(/\.\w+$/, '')
+          return nil if path.empty?
+
+          # Convert path to Rails helper format
+          path_parts = path.split('/')
+          if path_parts.last =~ /^\d+$/
+            # Looks like a show action
+            resource = path_parts[-2]
+            "#{resource.singularize}_path(@#{resource.singularize})"
+          else
+            # Looks like an index or named route
+            "#{path.gsub("/", "_").gsub("-", "_")}_path"
+          end
+        end
+      end
+    end
+  end
+end