blueprint-html2slim 1.1.0 → 1.3.0

data/lib/blueprint/html2slim/slim_railsifier.rb

@@ -0,0 +1,254 @@
+require_relative 'slim_manipulator'
+require 'json'
+
+module Blueprint
+  module Html2Slim
+    class SlimRailsifier < SlimManipulator
+      def railsify_file(file_path)
+        content = read_file(file_path)
+        original_content = content.dup
+        conversions = []
+
+        # Load custom mappings if provided
+        @custom_mappings = load_custom_mappings if options[:mappings]
+
+        if options[:add_helpers] != false
+          content, link_conversions = convert_links_to_helpers(content)
+          conversions.concat(link_conversions)
+        end
+
+        if options[:use_assets] != false
+          content, asset_conversions = convert_assets_to_pipeline(content)
+          conversions.concat(asset_conversions)
+        end
+
+        if options[:add_csrf]
+          content, csrf_additions = add_csrf_protection(content)
+          conversions.concat(csrf_additions)
+        end
+
+        if options[:dry_run]
+          if conversions.any?
+            puts "\nChanges that would be made to #{file_path}:"
+            puts "  Conversions: #{conversions.join(", ")}"
+            show_diff(original_content, content) if options[:verbose]
+          else
+            puts "No Rails conversions needed for #{file_path}"
+          end
+        elsif content != original_content
+          write_file(file_path, content)
+        end
+
+        { success: true, conversions: conversions }
+      rescue StandardError => e
+        { success: false, error: e.message }
+      end
+
+      private
+
+      def load_custom_mappings
+        return {} unless options[:mappings] && File.exist?(options[:mappings])
+
+        begin
+          content = File.read(options[:mappings])
+          if options[:mappings].end_with?('.json')
+            JSON.parse(content)
+          elsif options[:mappings].end_with?('.yml', '.yaml')
+            require 'yaml'
+            YAML.load_file(options[:mappings])
+          else
+            # Try to parse as JSON by default
+            JSON.parse(content)
+          end
+        rescue StandardError => e
+          puts "Warning: Failed to load mappings from #{options[:mappings]}: #{e.message}"
+          {}
+        end
+      end
+
+      def convert_links_to_helpers(content)
+        conversions = []
+        lines = content.split("\n")
+
+        lines.map!.with_index do |line, index|
+          if line =~ /^(\s*)a\[href="([^"]+)"([^\]]*)\](.*)/
+            indent = ::Regexp.last_match(1)
+            href = ::Regexp.last_match(2)
+            attrs = ::Regexp.last_match(3)
+            text = ::Regexp.last_match(4).strip
+
+            # Convert known static paths to Rails helpers (only if mappings provided)
+            rails_path = path_to_rails_helper(href)
+            if rails_path
+              conversions << "link at line #{index + 1}"
+              "#{indent}= link_to \"#{text}\", #{rails_path}#{format_link_options(attrs)}"
+            else
+              line
+            end
+          else
+            line
+          end
+        end
+
+        [lines.join("\n"), conversions]
+      end
+
+      def convert_assets_to_pipeline(content)
+        conversions = []
+        lines = content.split("\n")
+
+        lines.map!.with_index do |line, index|
+          # Convert stylesheet links
+          if line =~ /^(\s*)link\[.*href="([^"]+\.css[^"]*)"/
+            indent = ::Regexp.last_match(1)
+            href = ::Regexp.last_match(2)
+
+            if !href.start_with?('http') && !href.start_with?('//')
+              asset_name = File.basename(href, '.*')
+              conversions << "stylesheet at line #{index + 1}"
+              "#{indent}= stylesheet_link_tag '#{asset_name}'"
+            else
+              line
+            end
+          # Convert script tags
+          elsif line =~ /^(\s*)script\[.*src="([^"]+\.js[^"]*)"/
+            indent = ::Regexp.last_match(1)
+            src = ::Regexp.last_match(2)
+
+            if !src.start_with?('http') && !src.start_with?('//')
+              asset_name = File.basename(src, '.*')
+              conversions << "javascript at line #{index + 1}"
+              "#{indent}= javascript_include_tag '#{asset_name}'"
+            else
+              line
+            end
+          # Convert image tags
+          elsif line =~ /^(\s*)img\[src="([^"]+)"([^\]]*)\]/
+            indent = ::Regexp.last_match(1)
+            src = ::Regexp.last_match(2)
+            attrs = ::Regexp.last_match(3)
+
+            if !src.start_with?('http') && !src.start_with?('//')
+              conversions << "image at line #{index + 1}"
+              "#{indent}= image_tag '#{src}'#{format_image_options(attrs)}"
+            else
+              line
+            end
+          else
+            line
+          end
+        end
+
+        [lines.join("\n"), conversions]
+      end
+
+      def add_csrf_protection(content)
+        conversions = []
+        lines = content.split("\n")
+
+        # Find head section and add CSRF meta tags
+        head_index = lines.index { |line| line.strip.start_with?('head') }
+
+        if head_index
+          indent = lines[head_index][/\A */]
+          csrf_tags = [
+            "#{indent}  = csrf_meta_tags"
+          ]
+
+          # Insert after head tag
+          lines.insert(head_index + 1, *csrf_tags)
+          conversions << 'CSRF meta tags'
+        end
+
+        # Add CSRF token to forms
+        lines.map!.with_index do |line, index|
+          if line =~ /^(\s*)form\[.*method="(post|patch|put|delete)"/i
+            # Mark that this form needs CSRF token
+            conversions << "form CSRF at line #{index + 1}"
+            line
+          else
+            line
+          end
+        end
+
+        [lines.join("\n"), conversions]
+      end
+
+      def path_to_rails_helper(href)
+        # Only use custom mappings if provided, no fallbacks
+        return nil unless @custom_mappings
+
+        # Remove leading slash if present for comparison
+        clean_href = href.sub(%r{^/}, '')
+
+        # Try exact match
+        return @custom_mappings[href] if @custom_mappings[href]
+        return @custom_mappings[clean_href] if @custom_mappings[clean_href]
+
+        # Try pattern matching for custom mappings with wildcards
+        @custom_mappings.each do |pattern, helper|
+          if pattern.include?('*')
+            regex_pattern = pattern.gsub('*', '.*')
+            return helper if href.match?(/^#{regex_pattern}$/)
+          end
+        end
+
+        nil # No mapping found
+      end
+
+      def format_link_options(attrs)
+        return '' if attrs.nil? || attrs.strip.empty?
+
+        # Parse remaining attributes
+        options = []
+        attrs.scan(/(\w+)="([^"]+)"/).each do |key, value|
+          next if key == 'href'
+
+          if key == 'class'
+            options << "class: '#{value}'"
+          elsif key == 'id'
+            options << "id: '#{value}'"
+          elsif key.start_with?('data-')
+            data_key = key.sub('data-', '').gsub('-', '_')
+            options << "data: { #{data_key}: '#{value}' }"
+          else
+            options << "#{key}: '#{value}'"
+          end
+        end
+
+        options.empty? ? '' : ", #{options.join(", ")}"
+      end
+
+      def format_image_options(attrs)
+        return '' if attrs.nil? || attrs.strip.empty?
+
+        options = []
+        attrs.scan(/(\w+)="([^"]+)"/).each do |key, value|
+          next if key == 'src'
+
+          options << if key == 'alt'
+                       "alt: '#{value}'"
+                     elsif key == 'class'
+                       "class: '#{value}'"
+                     elsif %w[width height].include?(key)
+                       "#{key}: #{value}"
+                     else
+                       "#{key}: '#{value}'"
+                     end
+        end
+
+        options.empty? ? '' : ", #{options.join(", ")}"
+      end
+
+      def show_diff(original, modified)
+        puts "\n--- Original ---"
+        puts original[0..500]
+        puts '...' if original.length > 500
+        puts "\n+++ Modified +++"
+        puts modified[0..500]
+        puts '...' if modified.length > 500
+        puts
+      end
+    end
+  end
+end

data/lib/blueprint/html2slim/slim_validator.rb

@@ -0,0 +1,170 @@
+require_relative 'slim_manipulator'
+
+module Blueprint
+  module Html2Slim
+    class SlimValidator < SlimManipulator
+      def validate_file(file_path)
+        content = read_file(file_path)
+        structure = parse_slim_structure(content)
+
+        errors = []
+        warnings = []
+
+        # Check for syntax errors
+        syntax_errors = check_syntax_errors(structure)
+        errors.concat(syntax_errors)
+
+        # Check for common issues that might cause problems
+        potential_issues = check_potential_issues(structure)
+        warnings.concat(potential_issues)
+
+        # Rails-specific checks if requested
+        if options[:check_rails]
+          rails_issues = check_rails_conventions(structure)
+          warnings.concat(rails_issues)
+        end
+
+        # Try to parse with Slim if available
+        if defined?(Slim)
+          begin
+            Slim::Template.new { content }
+          rescue StandardError => e
+            errors << "Slim parsing error: #{e.message}"
+          end
+        end
+
+        {
+          valid: errors.empty?,
+          errors: errors,
+          warnings: warnings
+        }
+      rescue StandardError => e
+        {
+          valid: false,
+          errors: ["Failed to read or validate file: #{e.message}"],
+          warnings: []
+        }
+      end
+
+      private
+
+      def check_syntax_errors(structure)
+        errors = []
+        indent_stack = [-1]
+
+        structure.each_with_index do |item, _index|
+          line = item[:stripped]
+          indent = item[:indent_level]
+          line_num = item[:line_number]
+
+          # Check indentation consistency
+          if indent > indent_stack.last + 1
+            errors << "Line #{line_num}: Invalid indentation jump (expected #{indent_stack.last + 1}, got #{indent})"
+          end
+
+          # Update indent stack
+          indent_stack.pop while indent_stack.last > indent
+          indent_stack << indent if indent > indent_stack.last
+
+          # Check for invalid syntax patterns
+          if line.start_with?('/') && !line.match?(%r{^/[!|\s]})
+            msg = "Line #{line_num}: Forward slash will be interpreted as comment. "
+            errors << "#{msg}Use pipe notation for text: | #{line}"
+          end
+
+          # Check for text after element that starts with slash
+          if line =~ %r{^([a-z#.][^\s]*)\s+(/[^/].*)$}i
+            errors << "Line #{line_num}: Forward slash will be interpreted as comment. Use pipe notation for text"
+          end
+
+          # Check for unclosed brackets in attributes
+          if line.include?('[') && !line.include?(']')
+            errors << "Line #{line_num}: Unclosed attribute bracket"
+          elsif line.include?(']') && !line.include?('[')
+            errors << "Line #{line_num}: Unexpected closing bracket"
+          end
+
+          # Check for invalid Ruby code markers
+          errors << "Line #{line_num}: Ruby code marker without code" if line =~ /^[=-]\s*$/
+
+          # Check for mixed tabs and spaces (if strict mode)
+          if options[:strict] && item[:line].match?(/\t/)
+            errors << "Line #{line_num}: Contains tabs (use spaces for indentation)"
+          end
+        end
+
+        errors
+      end
+
+      def check_potential_issues(structure)
+        warnings = []
+
+        structure.each do |item|
+          line = item[:stripped]
+          line_num = item[:line_number]
+
+          # Warn about text that might be misinterpreted
+          warnings << "Line #{line_num}: Text containing '/' might need pipe notation" if line =~ %r{^\w+.*\s/\w+}
+
+          # Warn about very long lines
+          warnings << "Line #{line_num}: Line exceeds 120 characters" if item[:line].length > 120
+
+          # Warn about deprecated Slim syntax
+          warnings << "Line #{line_num}: Single quote for text interpolation is deprecated" if line.start_with?("'")
+
+          # Warn about potential multiline text issues
+          if line =~ /^[a-z#.][^\s]*\s+[^=\-|].{50,}/i
+            warnings << "Line #{line_num}: Long inline text might be better as multiline with pipe notation"
+          end
+
+          # Warn about inline styles (if strict)
+          if options[:strict] && line.include?('style=')
+            warnings << "Line #{line_num}: Inline styles detected (consider using classes)"
+          end
+        end
+
+        warnings
+      end
+
+      def check_rails_conventions(structure)
+        warnings = []
+
+        structure.each do |item|
+          line = item[:stripped]
+          line_num = item[:line_number]
+
+          # Check for static asset links that should use Rails helpers
+          if line =~ /link.*href=["'].*\.(css|scss)/
+            warnings << "Line #{line_num}: Consider using stylesheet_link_tag for CSS files"
+          end
+
+          if line =~ /script.*src=["'].*\.js/
+            warnings << "Line #{line_num}: Consider using javascript_include_tag for JS files"
+          end
+
+          # Check for static image paths
+          if line =~ %r{img.*src=["'](?!http|//)}
+            warnings << "Line #{line_num}: Consider using image_tag helper for images"
+          end
+
+          # Check for forms without Rails helpers
+          if line.start_with?('form') && !line.include?('form_for') && !line.include?('form_with')
+            warnings << "Line #{line_num}: Consider using Rails form helpers (form_for, form_with)"
+          end
+
+          # Check for missing CSRF token in forms
+          if line =~ /^form\[.*method=["'](post|patch|put|delete)/i
+            warnings << "Line #{line_num}: Ensure CSRF token is included in form"
+          end
+
+          # Check for hardcoded URLs
+          if line =~ %r{href=["']/(users|posts|articles|products)}
+            warnings << "Line #{line_num}: Consider using Rails path helpers instead of hardcoded URLs"
+          end
+        end
+
+        warnings
+      end
+    end
+  end
+end

data/lib/blueprint/html2slim/version.rb

@@ -1,5 +1,5 @@
 module Blueprint
   module Html2Slim
-    VERSION = '1.1.0'.freeze
+    VERSION = '1.3.0'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blueprint-html2slim
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Vladimir Elchinov
@@ -127,6 +127,7 @@ email:
 - info@railsblueprint.com
 executables:
 - html2slim
+- slimtool
 extensions: []
 extra_rdoc_files: []
 files:
@@ -135,8 +136,15 @@ files:
 - README.md
 - bin/html2slim
 - bin/index.html
+- bin/slimtool
 - lib/blueprint/html2slim.rb
 - lib/blueprint/html2slim/converter.rb
+- lib/blueprint/html2slim/link_extractor.rb
+- lib/blueprint/html2slim/slim_extractor.rb
+- lib/blueprint/html2slim/slim_fixer.rb
+- lib/blueprint/html2slim/slim_manipulator.rb
+- lib/blueprint/html2slim/slim_railsifier.rb
+- lib/blueprint/html2slim/slim_validator.rb
 - lib/blueprint/html2slim/version.rb
 homepage: https://github.com/railsblueprint/html2slim
 licenses: