blueprint-html2slim 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 460bb27c7423062c1fe30a58b2f432f370361e1134a933ca550644e5f8d05b99
+  data.tar.gz: d0cace18262a72410fe46ac69ae055523aec83f51d2da1c6fb8cd7cda137544c
+SHA512:
+  metadata.gz: '08bd9ceb42074244e5323c01120dff8bf91c1daaedee6574b9e09a994b286996ac3bad0e7f4a0e104066890e87943348c4dcfe11ea954fd4ee492149366059c5'
+  data.tar.gz: 59b01b4f8f0d86ca4cab804e246149d37dbc57ccb2345687b181b79dd0e878ee7f3e4c72a4c41921b8e2f73b343f005d817247b9cd15920dd0401e732dc4fad9

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.0.0] - 2024-01-01
+
+### Added
+- Initial release of blueprint-html2slim
+- HTML to Slim conversion
+- ERB template support
+- Smart file naming conventions
+- Backup option for source files
+- Recursive directory processing
+- Dry-run mode
+- Custom output path support

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Blueprint HTML2Slim Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,136 @@
+# Blueprint HTML2Slim
+
+A Ruby gem providing a command-line tool to convert HTML and ERB files to Slim format.
+
+## Requirements
+
+- Ruby 2.7 - 3.4 (compatible with latest Ruby versions)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'blueprint-html2slim'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install blueprint-html2slim
+```
+
+## Usage
+
+### Programmatic Usage (Ruby)
+
+```ruby
+require 'blueprint/html2slim'
+
+# Create a converter instance
+converter = Blueprint::Html2Slim::Converter.new
+
+# Convert HTML string
+html = '<div class="container"><h1>Hello</h1></div>'
+slim = converter.convert(html)
+puts slim
+# Output: .container
+#           h1 Hello
+
+# Convert ERB string
+erb = '<%= form_for @user do |f| %>
+  <div class="field">
+    <%= f.text_field :name %>
+  </div>
+<% end %>'
+slim = converter.convert(erb)
+# Output: = form_for @user do |f|
+#           .field
+#             = f.text_field :name
+
+# With custom indentation (default is 2)
+converter = Blueprint::Html2Slim::Converter.new(indent_size: 4)
+```
+
+### Command Line Usage
+
+Convert a single file:
+```bash
+html2slim index.html
+# Creates: index.html.slim
+```
+
+Convert with custom output:
+```bash
+html2slim -o custom.slim index.html
+```
+
+Convert multiple files:
+```bash
+html2slim file1.html file2.erb file3.html.erb
+```
+
+Convert and backup original files:
+```bash
+html2slim -b index.html
+# Creates: index.html.slim
+# Renames: index.html -> index.html.bak
+```
+
+Convert files in a directory recursively:
+```bash
+html2slim -r ./views
+```
+
+Convert to target directory (preserves structure):
+```bash
+html2slim -t dist/ -r src/
+# Converts src/views/index.html to dist/views/index.html.slim
+```
+
+Delete source files after conversion:
+```bash
+html2slim -d old_templates/*.erb
+# Converts and deletes the original .erb files
+```
+
+Dry run (preview what would be converted):
+```bash
+html2slim -n file.html
+```
+
+## Naming Convention
+
+- `file.html` → `file.html.slim`
+- `file.html.erb` → `file.html.slim`
+- `file.erb` → `file.slim`
+
+## Options
+
+- `-o, --output FILE` - Output file path (only for single file conversion)
+- `-r, --recursive` - Process directories recursively
+- `-n, --dry-run` - Show what would be converted without actually converting
+- `-d, --delete` - Delete source files after successful conversion
+- `-t, --target-dir DIR` - Target directory for converted files (preserves directory structure)
+- `-f, --force` - Overwrite existing files without prompting
+- `-b, --backup` - Backup source files with .bak extension
+- `-i, --indent SIZE` - Indentation size in spaces (default: 2)
+- `-h, --help` - Show help message
+- `-v, --version` - Show version
+
+## Features
+
+- Converts HTML tags to Slim syntax
+- Handles HTML attributes, IDs, and classes
+- Preserves ERB tags (<%= %> and <% %>)
+- Supports nested elements
+- Handles void elements correctly
+- Preserves comments
+- Smart output file naming
+- Optional source file backup

data/bin/html2slim

@@ -0,0 +1,216 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'pathname'
+require_relative '../lib/blueprint/html2slim'
+
+class Html2SlimCLI < Thor
+  class_option :help, aliases: '-h', type: :boolean, desc: 'Show help'
+
+  desc 'FILE [FILE2 ...]', 'Convert HTML/ERB files to Slim format'
+  option :output, aliases: '-o', desc: 'Output file path (only for single file conversion)'
+  option :recursive, aliases: '-r', type: :boolean, desc: 'Process directories recursively'
+  option :dry_run, aliases: '-n', type: :boolean, desc: 'Show what would be converted without actually converting'
+  option :delete, aliases: '-d', type: :boolean, desc: 'Delete source files after successful conversion'
+  option :target_dir, aliases: '-t', desc: 'Target directory for converted files (preserves structure)'
+  option :force, aliases: '-f', type: :boolean, desc: 'Overwrite existing files without prompting'
+  option :backup, aliases: '-b', type: :boolean, desc: 'Backup source files with .bak extension'
+  option :indent, aliases: '-i', type: :numeric, default: 2, desc: 'Indentation size (spaces)'
+
+  def self.start(given_args = ARGV, config = {})
+    if given_args.empty? || given_args.first == 'help' || given_args.include?('-h') || given_args.include?('--help')
+      puts 'Usage: html2slim [OPTIONS] FILE [FILE2 ...]'
+      puts ''
+      puts 'Options:'
+      puts '  -o, --output FILE    Output file path (only for single file conversion)'
+      puts '  -r, --recursive      Process directories recursively'
+      puts '  -n, --dry-run        Show what would be converted without actually converting'
+      puts '  -d, --delete         Delete source files after successful conversion'
+      puts '  -t, --target-dir DIR Target directory for converted files (preserves structure)'
+      puts '  -f, --force          Overwrite existing files without prompting'
+      puts '  -b, --backup         Backup source files with .bak extension'
+      puts '  -i, --indent SIZE    Indentation size in spaces (default: 2)'
+      puts '  -h, --help           Show this help message'
+      puts '  -v, --version        Show version'
+      puts ''
+      puts 'Examples:'
+      puts '  html2slim index.html'
+      puts '  html2slim -o output.slim input.html'
+      puts '  html2slim -r ./views'
+      puts '  html2slim -b file1.html file2.erb'
+      puts '  html2slim -t dist/ -r src/'
+      puts '  html2slim -d old_views/*.erb  # Convert and delete sources'
+      exit 0
+    elsif given_args.first == 'version' || given_args.include?('-v') || given_args.include?('--version')
+      puts 'html2slim 1.0.0'
+      exit 0
+    else
+      args = given_args.dup
+      options_index = args.index { |arg| arg.start_with?('-') }
+
+      if options_index
+        files = args[0...options_index]
+        args[options_index..] + files
+      else
+        ['process'] + args
+      end
+
+      super(['process'] + given_args, config)
+    end
+  end
+
+  desc '', ''
+  def process(*files)
+    if files.empty?
+      puts 'Error: No files specified'
+      puts 'Usage: html2slim [OPTIONS] FILE [FILE2 ...]'
+      exit 1
+    end
+
+    if options[:output] && files.size > 1
+      puts 'Error: -o/--output can only be used with a single input file'
+      exit 1
+    end
+    
+    if options[:output] && options[:target_dir]
+      puts 'Error: Cannot use both -o/--output and -t/--target-dir together'
+      exit 1
+    end
+    
+    if options[:backup] && options[:delete]
+      puts 'Warning: -b/--backup takes precedence over -d/--delete'
+    end
+
+    converter = Blueprint::Html2Slim::Converter.new(indent_size: options[:indent])
+    processed_count = 0
+    error_count = 0
+
+    files.each do |file_path|
+      if File.directory?(file_path)
+        if options[:recursive]
+          process_directory(file_path, converter)
+        else
+          puts "Skipping directory: #{file_path} (use -r to process recursively)"
+        end
+      elsif File.exist?(file_path)
+        result = process_file(file_path, converter)
+        if result
+          processed_count += 1
+        else
+          error_count += 1
+        end
+      else
+        puts "File not found: #{file_path}"
+        error_count += 1
+      end
+    end
+
+    puts "\nConversion complete: #{processed_count} file(s) processed, #{error_count} error(s)"
+    exit(1) if error_count.positive?
+  end
+
+  default_task :process
+
+  private
+
+  def process_directory(dir_path, converter)
+    patterns = ['**/*.html', '**/*.erb', '**/*.html.erb']
+    patterns.each do |pattern|
+      Dir.glob(File.join(dir_path, pattern)).each do |file|
+        process_file(file, converter, dir_path)
+      end
+    end
+  end
+
+  def process_file(file_path, converter, base_dir = nil)
+    input_path = Pathname.new(file_path)
+
+    # Determine output path
+    output_path = if options[:output]
+                    # For single file with -o option, use the specified output path
+                    Pathname.new(options[:output])
+                  elsif options[:target_dir]
+                    # Calculate relative path from base directory
+                    relative_path = if base_dir
+                                      input_path.relative_path_from(Pathname.new(base_dir))
+                                    else
+                                      input_path.basename
+                                    end
+                    
+                    # Apply smart naming convention to the filename
+                    output_name = case relative_path.to_s
+                                  when /\.html\.erb$/
+                                    relative_path.to_s.sub(/\.html\.erb$/, '.html.slim')
+                                  when /\.erb$/
+                                    relative_path.to_s.sub(/\.erb$/, '.slim')
+                                  when /\.html$/
+                                    relative_path.to_s.sub(/\.html$/, '.html.slim')
+                                  else
+                                    "#{relative_path}.slim"
+                                  end
+                    
+                    Pathname.new(options[:target_dir]).join(output_name)
+                  else
+                    # Smart naming convention in place
+                    case file_path
+                    when /\.html\.erb$/
+                      # .html.erb -> .html.slim
+                      Pathname.new(file_path.sub(/\.html\.erb$/, '.html.slim'))
+                    when /\.erb$/
+                      # .erb -> .slim
+                      Pathname.new(file_path.sub(/\.erb$/, '.slim'))
+                    when /\.html$/
+                      # .html -> .html.slim
+                      Pathname.new(file_path.sub(/\.html$/, '.html.slim'))
+                    else
+                      # Default: add .slim extension
+                      Pathname.new("#{file_path}.slim")
+                    end
+                  end
+
+    if options[:dry_run]
+      puts "Would convert: #{input_path} -> #{output_path}"
+      puts "Would backup: #{input_path} -> #{input_path}.bak" if options[:backup]
+      puts "Would delete: #{input_path}" if options[:delete]
+      return true
+    end
+
+    if output_path.exist? && !options[:force]
+      print "File exists: #{output_path}. Overwrite? (y/n): "
+      response = $stdin.gets.chomp.downcase
+      return false unless response == 'y'
+    end
+
+    begin
+      html_content = File.read(input_path)
+      slim_content = converter.convert(html_content)
+
+      # Create backup if requested
+      if options[:backup]
+        backup_path = Pathname.new("#{file_path}.bak")
+        File.rename(input_path, backup_path)
+        puts "Backed up: #{input_path} -> #{backup_path}"
+      end
+
+      output_path.dirname.mkpath
+      # Ensure content ends with newline when writing to file
+      slim_content += "\n" unless slim_content.end_with?("\n")
+      File.write(output_path, slim_content)
+
+      puts "Converted: #{input_path} -> #{output_path}"
+      
+      # Delete source file if requested (and not backing up)
+      if options[:delete] && !options[:backup]
+        File.delete(input_path)
+        puts "Deleted: #{input_path}"
+      end
+      
+      true
+    rescue StandardError => e
+      puts "Error converting #{input_path}: #{e.message}"
+      false
+    end
+  end
+end
+
+Html2SlimCLI.start(ARGV)