auto-l18n 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9eaeb61d41c636035f955c83afb385e40a020e4806bcc2553b965032b3966c64
+  data.tar.gz: c062d54dd2f5b7e639eeb9304e31993aa0a7485703a4236868d86a731ccc1518
+SHA512:
+  metadata.gz: ae940be66b33102dce802addaa5f2d3abacde2f3e934383b8ab0a663329a5672c3ef84065d5020332de26cca3f43831a2e214c61ffecfcae661b34d2e2249d0c
+  data.tar.gz: 31b3b158aa2d1978828874f1d30e7815e5e8b868e599beb3e93fb1c7f68335476386c03d198e3506ce967208f66dec2e985c4e03570fa3ff860fcc434928da01

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-10-26
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Nicolas Reiner
+
+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,257 @@
+# Auto::L18n
+
+Automatically find and replace hardcoded text in Rails ERB view files with I18n translation calls. Auto::L18n scans your HTML/ERB files, detects hardcoded strings, and can automatically replace them with proper I18n `t()` calls while generating the corresponding locale YAML files.
+
+## Features
+
+- 🔍 **Smart Detection** - Finds hardcoded text in ERB code, HTML content, attributes, and optionally JavaScript
+- 🔄 **Automatic Replacement** - Replaces hardcoded strings with I18n translation calls
+- 📝 **Locale File Generation** - Automatically creates/updates YAML locale files
+- 🎯 **Intelligent Filtering** - Skips existing I18n calls, comments, and code-like patterns
+- 🔧 **Highly Configurable** - Control what gets extracted and how
+- 💻 **CLI & Programmatic API** - Use from command line or Ruby code
+- 🧪 **Dry Run Mode** - Preview changes before applying them
+- 💾 **Automatic Backups** - Creates backup files before modifying originals
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'auto-l18n'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself:
+
+```bash
+gem install auto-l18n
+```
+
+## Quick Start
+
+### Find hardcoded text in a file:
+
+```ruby
+require 'auto/l18n'
+
+texts = Auto::L18n.find_text("app/views/posts/show.html.erb")
+texts.each { |t| puts "- #{t}" }
+```
+
+### Replace hardcoded text with I18n calls:
+
+```ruby
+# Preview changes (dry run)
+result = Auto::L18n.auto_internationalize(
+  "app/views/posts/show.html.erb",
+  namespace: "views.posts.show",
+  dry_run: true
+)
+
+puts "Would replace #{result[:total_replaced]} strings"
+
+# Apply changes
+result = Auto::L18n.auto_internationalize(
+  "app/views/posts/show.html.erb",
+  namespace: "views.posts.show"
+)
+```
+
+### Command Line:
+
+```bash
+# Find hardcoded text
+ruby exe/auto-l18n app/views/posts/show.html.erb
+
+# Replace with I18n calls (dry run)
+ruby exe/auto-l18n app/views/posts/show.html.erb \
+  --replace --namespace views.posts.show --dry-run
+
+# Actually apply changes
+ruby exe/auto-l18n app/views/posts/show.html.erb \
+  --replace --namespace views.posts.show
+```
+
+## Example Transformation
+
+**Before:**
+```erb
+<h1>Welcome to our blog</h1>
+<p>Please <%= "sign in" %> to continue.</p>
+<button title="Click here">Submit</button>
+```
+
+**After:**
+```erb
+<h1><%= t('views.posts.welcome_to_our_blog') %></h1>
+<p>Please <%= t('views.posts.sign_in') %> to continue.</p>
+<button title="<%= t('views.posts.click_here') %>">Submit</button>
+```
+
+**Generated locale file (config/locales/en.yml):**
+```yaml
+en:
+  views:
+    posts:
+      welcome_to_our_blog: "Welcome to our blog"
+      sign_in: "sign in"
+      click_here: "Click here"
+```
+
+## Documentation
+
+- **[Quick Start Guide](QUICKSTART.md)** - Get up and running quickly
+- **[API Documentation](API.md)** - Complete API reference and examples
+- **[Demo Script](demo.rb)** - Run `ruby demo.rb` to see it in action
+
+## Main Methods
+
+### `Auto::L18n.find_text(path, options = {})`
+
+Find all hardcoded text in a file.
+
+```ruby
+# Simple usage
+texts = Auto::L18n.find_text("app/views/posts/show.html.erb")
+
+# With structured output (includes metadata)
+findings = Auto::L18n.find_text("app/views/posts/show.html.erb", structured: true)
+findings.each do |f|
+  puts "#{f.text} (#{f.type}) at line #{f.line}"
+end
+
+# With options
+texts = Auto::L18n.find_text("app/views/posts/show.html.erb",
+  min_length: 3,
+  scan_js: true,
+  ignore_patterns: ['\d+', 'http']
+)
+```
+
+### `Auto::L18n.exchange_text_for_l18n_placeholder(path, options = {})`
+
+Replace hardcoded text in a single file with I18n calls.
+
+```ruby
+result = Auto::L18n.exchange_text_for_l18n_placeholder(
+  "app/views/posts/show.html.erb",
+  namespace: "views.posts.show",
+  locale_path: "config/locales/en.yml",
+  dry_run: true  # Preview first!
+)
+```
+
+### `Auto::L18n.auto_internationalize(path, options = {})`
+
+Main method that handles the complete workflow (find + replace).
+
+```ruby
+# Single file
+result = Auto::L18n.auto_internationalize(
+  "app/views/posts/show.html.erb",
+  namespace: "views.posts.show"
+)
+
+# Entire directory
+result = Auto::L18n.auto_internationalize(
+  "app/views",
+  recursive: true,
+  namespace: "views",
+  dry_run: true
+)
+```
+
+## CLI Options
+
+```bash
+ruby exe/auto-l18n [options] [file]
+
+Options:
+  -d, --directory=DIR      Search files in DIR
+  -r, --recursive          Search recursively
+  --ext=EXTS              File extensions (default: .html.erb)
+  --replace               Replace hardcoded text with I18n calls
+  --locale-path=PATH      Locale file path (default: config/locales/en.yml)
+  --namespace=NS          Translation key namespace (e.g., views.posts)
+  --dry-run               Preview changes without modifying files
+  --no-backup             Don't create backup files
+  -h, --help              Show help
+```
+
+## What Gets Extracted
+
+✅ ERB string literals: `<%= "text" %>`  
+✅ HTML text nodes: `<p>text</p>`  
+✅ HTML attributes: `alt`, `title`, `placeholder`, `aria-label`, etc.  
+✅ JavaScript strings (optional): `"text"`, `'text'`, `` `text` ``  
+✅ Data attribute JSON values  
+
+## What Gets Skipped
+
+❌ Existing I18n calls: `t('key')`, `I18n.t('key')`  
+❌ Comments: `<!-- -->`, `<%# %>`  
+❌ Short strings (< 2 chars by default)  
+❌ Pure punctuation/symbols  
+❌ File paths and code syntax  
+❌ Custom patterns via `ignore_patterns`  
+
+## Configuration Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `namespace` | Prefix for translation keys | nil |
+| `locale_path` | Path to locale YAML file | `"config/locales/en.yml"` |
+| `locale` | Locale code | `"en"` |
+| `dry_run` | Preview without modifying | `false` |
+| `backup` | Create .backup files | `true` |
+| `min_length` | Minimum string length | `2` |
+| `ignore_patterns` | Regex patterns to exclude | `[]` |
+| `extra_attrs` | Additional HTML attributes | `[]` |
+| `scan_erb_code` | Extract from ERB blocks | `true` |
+| `scan_js` | Extract from JavaScript | `false` |
+| `recursive` | Process subdirectories | `false` |
+| `file_pattern` | File pattern for directories | `"*.html.erb"` |
+
+## Usage
+
+After installing the gem, you can use either the Ruby API or the CLI.
+
+- Ruby API: see the Quick Start examples above or `QUICKSTART.md`.
+- CLI: run `auto-l18n --help` for options, for example:
+
+```bash
+# Find hardcoded text in a file
+auto-l18n app/views/posts/show.html.erb
+
+# Replace with I18n calls (dry run)
+auto-l18n app/views/posts/show.html.erb \
+  --replace --namespace views.posts.show --dry-run
+
+# Apply changes
+auto-l18n app/views/posts/show.html.erb \
+  --replace --namespace views.posts.show
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/NicolasReiner/auto-l18n. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/NicolasReiner/auto-l18n/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Auto::L18n project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/NicolasReiner/auto-l18n/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/exe/auto-l18n

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "pathname"
+
+# Load the library
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "auto/l18n"
+
+options = {
+  directory: nil,
+  recursive: false,
+  exts: [".html.erb"],
+  mode: "find", # find or replace
+  locale_path: "config/locales/en.yml",
+  namespace: nil,
+  dry_run: false,
+  backup: true
+}
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: bundle exec auto-l18n [options] [file]"
+
+  opts.on("-dDIR", "--directory=DIR", "Search files in DIR instead of a single file") do |d|
+    options[:directory] = d
+  end
+
+  opts.on("-r", "--recursive", "When used with --directory, search recursively") do
+    options[:recursive] = true
+  end
+
+  opts.on("--ext=EXTS", "Comma-separated list of extensions to scan (default: .html.erb)") do |e|
+    options[:exts] = e.split(",").map(&:strip)
+  end
+
+  opts.on("--replace", "Replace hardcoded text with I18n calls (default is to only find)") do
+    options[:mode] = "replace"
+  end
+
+  opts.on("--locale-path=PATH", "Path to locale file (default: config/locales/en.yml)") do |path|
+    options[:locale_path] = path
+  end
+
+  opts.on("--namespace=NS", "Namespace for translation keys (e.g., views.posts)") do |ns|
+    options[:namespace] = ns
+  end
+
+  opts.on("--dry-run", "Preview changes without modifying files") do
+    options[:dry_run] = true
+  end
+
+  opts.on("--no-backup", "Don't create backup files") do
+    options[:backup] = false
+  end
+
+  opts.on("-h", "--help", "Show this help message") do
+    puts opts
+    exit
+  end
+end
+
+parser.parse!(ARGV)
+
+paths = []
+
+  if options[:directory]
+  dir = Pathname.new(options[:directory])
+  unless dir.directory?
+    STDERR.puts "Directory not found: #{dir}"
+    exit 1
+  end
+
+  if options[:recursive]
+    all = Dir.glob(File.join(dir.to_s, "**", "*"), File::FNM_DOTMATCH).select { |p| File.file?(p) }
+  else
+    all = Dir.children(dir.to_s).map { |c| File.join(dir.to_s, c) }.select { |p| File.file?(p) }
+  end
+
+  # Filter by extensions
+  exts = options[:exts].map { |x| x.start_with?('.') ? x : ".#{x}" }
+  paths = all.select { |p| exts.include?(File.extname(p)) || exts.any? { |e| p.end_with?(e) } }
+elsif ARGV[0]
+  # single file path provided
+  file = ARGV[0]
+  unless File.file?(file)
+    STDERR.puts "File not found: #{file}"
+    exit 1
+  end
+  paths = [file]
+else
+  # default: current directory, non-recursive
+  all = Dir.children(Dir.pwd).map { |c| File.join(Dir.pwd, c) }.select { |p| File.file?(p) }
+  exts = options[:exts].map { |x| x.start_with?('.') ? x : ".#{x}" }
+  paths = all.select { |p| exts.include?(File.extname(p)) || exts.any? { |e| p.end_with?(e) } }
+end
+
+if paths.empty?
+  puts "No files found to scan."
+  exit 0
+end
+
+if options[:mode] == "find"
+  # Original behavior: find and list hardcoded text
+  total = 0
+  paths.each do |p|
+    found = Auto::L18n.find_text(p)
+    next if found.empty?
+
+    total += found.size
+    puts "\nFile: #{p}"
+    found.each do |s|
+      puts "  - #{s}"
+    end
+  end
+
+  puts "\nFound #{total} text occurrence#{'s' if total != 1}."
+else
+  # New behavior: replace hardcoded text with I18n calls
+  puts options[:dry_run] ? "DRY RUN MODE - No files will be modified\n" : "Replacing hardcoded text...\n"
+  
+  total_replaced = 0
+  total_keys = 0
+  
+  paths.each do |p|
+    result = Auto::L18n.exchange_text_for_l18n_placeholder(p, {
+      locale_path: options[:locale_path],
+      namespace: options[:namespace],
+      dry_run: options[:dry_run],
+      backup: options[:backup]
+    })
+    
+    next if result[:replaced] == 0
+    
+    total_replaced += result[:replaced]
+    total_keys += result[:added_keys]
+    
+    puts "\nFile: #{p}"
+    puts "  Replaced: #{result[:replaced]} occurrence(s)"
+    puts "  Added keys: #{result[:added_keys]}"
+    
+    if options[:dry_run] && result[:keys]
+      puts "  Keys that would be added:"
+      result[:keys].each { |k| puts "    - #{k}" }
+    end
+  end
+  
+  puts "\n#{options[:dry_run] ? 'Would replace' : 'Replaced'} #{total_replaced} occurrence(s) across #{paths.size} file(s)."
+  puts "#{options[:dry_run] ? 'Would add' : 'Added'} #{total_keys} translation key(s) to #{options[:locale_path]}."
+  puts "\nBackup files created with .backup extension." if !options[:dry_run] && options[:backup] && total_replaced > 0
+end

data/lib/auto/l18n/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Auto
+  module L18n
+    VERSION = "0.1.0"
+  end
+end

data/lib/auto/l18n.rb

@@ -0,0 +1,652 @@
+# frozen_string_literal: true
+
+require_relative "l18n/version"
+require "fileutils"
+begin
+  require "nokogiri"
+rescue LoadError
+  # We'll raise a clear error when trying to use HTML parsing if Nokogiri isn't available.
+end
+
+module Auto
+  module L18n
+    class Error < StandardError; end
+    
+    # Represents a hardcoded text finding with metadata
+    Finding = Struct.new(:text, :type, :source, :line, :context, keyword_init: true)
+    
+    # Extract visible hardcoded text from an HTML/ERB file.
+    # This focuses on view files (e.g. .html.erb). It will:
+    #  - Extract hardcoded strings from ERB Ruby code
+    #  - Strip ERB tags with placeholders to preserve structure
+    #  - Skip I18n translation calls
+    #  - Remove HTML comments
+    #  - Parse the remaining HTML and collect visible text nodes and attribute values
+    #  - Optionally scan JavaScript for hardcoded strings
+    #  - Return structured findings with location metadata
+    #
+    # @param path [String] Path to the file to analyze
+    # @param options [Hash] Configuration options
+    # @option options [Boolean] :structured (false) Return Finding objects instead of strings
+    # @option options [Integer] :min_length (2) Minimum string length to consider
+    # @option options [Array<String>] :ignore_patterns ([]) Regex patterns to exclude
+    # @option options [Array<String>] :extra_attrs ([]) Additional HTML attributes to extract
+    # @option options [Boolean] :scan_erb_code (true) Extract strings from ERB Ruby code blocks
+    # @option options [Boolean] :scan_js (false) Extract strings from JavaScript blocks
+    #
+    # @return [Array<String>, Array<Finding>] Unique hardcoded strings or Finding objects
+    def self.find_text(path, options = {})
+      raise ArgumentError, "path must be a String" unless path.is_a?(String)
+      return [] unless File.file?(path)
+
+      unless defined?(Nokogiri)
+        raise Error, "Nokogiri is required for HTML parsing. Add `nokogiri` to your Gemfile or gemspec."
+      end
+
+      # Default options
+      opts = {
+        structured: false,
+        min_length: 2,
+        ignore_patterns: [],
+        extra_attrs: [],
+        scan_erb_code: true,
+        scan_js: false
+      }.merge(options)
+
+      raw = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
+      
+      # Track line numbers for better reporting
+      line_map = build_line_map(raw)
+      
+      results = []
+
+      # Helper to validate and record candidate text
+      record = lambda do |str, type:, source:, original_position: nil|
+        return if str.nil?
+        
+        # Normalize whitespace
+        s = str.gsub(/\s+/, " ").strip
+        return if s.empty?
+        return if s.length < opts[:min_length]
+        
+        # Skip our own placeholders
+        return if s.include?('⟦ERB') || s.include?('⟦I18N⟧')
+        
+        # Skip if matches ignore patterns
+        opts[:ignore_patterns].each do |pattern|
+          return if s =~ /#{pattern}/
+        end
+        
+        # Skip pure punctuation or symbols
+        return if s =~ /\A[\W_]*\z/
+        
+        # Skip placeholder patterns (be more specific to avoid false positives)
+        return if s.include?('#{') || s.include?('%{')
+        # Only skip if multiple curly braces (likely interpolation)
+        return if s.scan(/\{/).size > 1 && s.scan(/\}/).size > 1
+        
+        # Skip file paths
+        return if s =~ %r{\A\.?/?[\w\-]+(/[\w\-\.]+)+\z}
+        
+        # Skip code-like syntax
+        return if s =~ /[;=>]{2,}/ || s =~ /function\s*\(/ || s =~ /\b(?:var|const|let)\s+\w+/
+        
+        # Normalize quotes for comparison
+        normalized = s.tr('""''', %q{"''"})
+        
+        # Try to estimate line number
+        line = estimate_line(original_position, line_map) if original_position
+        
+        if opts[:structured]
+          results << Finding.new(
+            text: normalized,
+            type: type,
+            source: source,
+            line: line,
+            context: s # keep original for display
+          )
+        else
+          results << normalized
+        end
+      end
+
+      # PHASE 1: Extract hardcoded strings from ERB Ruby code blocks
+      if opts[:scan_erb_code]
+        raw.scan(/<%=?\s*(.*?)%>/m).each do |match|
+          code = match[0]
+          position = raw.index("<%") # Approximate position
+          
+          # Skip if it's an I18n call
+          next if code =~ /\b(?:I18n\.)?(?:t|translate)\s*\(/
+          
+          # Extract double-quoted strings
+          code.scan(/"((?:[^"\\]|\\.)*)"/m).each do |string_match|
+            unescaped = string_match[0].gsub(/\\(.)/, '\1')
+            record.call(
+              unescaped,
+              type: :erb_string,
+              source: "ERB block",
+              original_position: position
+            )
+          end
+          
+          # Extract single-quoted strings
+          code.scan(/'((?:[^'\\]|\\.)*)'/).each do |string_match|
+            unescaped = string_match[0].gsub(/\\(.)/, '\1')
+            record.call(
+              unescaped,
+              type: :erb_string,
+              source: "ERB block",
+              original_position: position
+            )
+          end
+        end
+      end
+
+      # PHASE 2: Prepare HTML for Nokogiri parsing
+      # 1) Remove ERB comments
+      cleaned_erb = raw.gsub(/<%#.*?%>/m, " ⟦ERB_COMMENT⟧ ")
+      
+      # 2) Skip I18n translation calls - replace with placeholder
+      # Matches: t("key"), t('key'), I18n.t("key"), translate("key"), etc.
+      cleaned_erb = cleaned_erb.gsub(/<%=?\s*(?:I18n\.)?(?:t|translate)\s*\([^)]+\)\s*%>/m, " ⟦I18N⟧ ")
+      
+      # 3) Remove remaining ERB tags with unique placeholder to preserve spacing
+      cleaned_erb = cleaned_erb.gsub(/<%=?\s*.*?%>/m, " ⟦ERB⟧ ")
+
+      # 4) Remove HTML comments
+      cleaned_erb = cleaned_erb.gsub(/<!--.*?-->/m, " ")
+
+      # 5) Parse with Nokogiri
+      fragment = Nokogiri::HTML::DocumentFragment.parse(cleaned_erb)
+
+      # Standard attributes to extract
+      standard_attrs = %w[alt title placeholder aria-label aria-placeholder aria-description label]
+      # Additional attributes for form inputs and buttons
+      value_attrs = %w[value]
+      all_attrs = (standard_attrs + value_attrs + opts[:extra_attrs]).uniq
+
+      # PHASE 3: Extract from JavaScript blocks (optional)
+      if opts[:scan_js]
+        fragment.css('script').each do |script_node|
+          js_content = script_node.content
+          
+          # Extract double-quoted strings
+          js_content.scan(/"((?:[^"\\]|\\.)*)"/m).each do |string_match|
+            unescaped = string_match[0].gsub(/\\(.)/, '\1')
+            record.call(
+              unescaped,
+              type: :js_string,
+              source: "JavaScript block",
+              original_position: nil
+            )
+          end
+          
+          # Extract single-quoted strings
+          js_content.scan(/'((?:[^'\\]|\\.)*)'/).each do |string_match|
+            unescaped = string_match[0].gsub(/\\(.)/, '\1')
+            record.call(
+              unescaped,
+              type: :js_string,
+              source: "JavaScript block",
+              original_position: nil
+            )
+          end
+          
+          # Extract template literals (backticks) - basic support
+          js_content.scan(/`([^`]*)`/).each do |string_match|
+            record.call(
+              string_match[0],
+              type: :js_template,
+              source: "JavaScript template literal",
+              original_position: nil
+            )
+          end
+        end
+      end
+
+      # PHASE 4: Collect text nodes (visible text)
+      fragment.traverse do |node|
+        # Skip script, style, and template tags
+        next if node.ancestors.any? { |a| %w[script style template].include?(a.name) }
+        
+        if node.text? && !node.content.strip.empty?
+          # Skip if parent has hidden attribute
+          next if node.parent&.[]("hidden")
+          
+          position = find_position_in_original(node.content, raw)
+          record.call(
+            node.content,
+            type: :text_node,
+            source: "text content",
+            original_position: position
+          )
+        end
+      end
+
+      # PHASE 5: Collect attributes
+      selector = all_attrs.map { |attr| "*[#{attr}]" }.join(', ')
+      fragment.css(selector).each do |el|
+        all_attrs.each do |attr|
+          next unless el[attr]
+          
+          # Skip empty values or single characters for 'value' attribute
+          next if attr == 'value' && el[attr].length < 2
+          
+          position = find_position_in_original(el[attr], raw)
+          record.call(
+            el[attr],
+            type: :attribute,
+            source: "#{el.name}[#{attr}]",
+            original_position: position
+          )
+        end
+      end
+
+      # PHASE 6: Extract from data-* JSON attributes
+      fragment.css('[data-config], [data-text], [data-message], [data-label]').each do |el|
+        el.attributes.each do |name, attr|
+          next unless name.start_with?('data-')
+          value = attr.value
+          
+          # Try to parse as JSON
+          begin
+            require 'json'
+            parsed = JSON.parse(value)
+            extract_strings_from_json(parsed).each do |str|
+              record.call(
+                str,
+                type: :data_attribute,
+                source: "#{el.name}[#{name}]",
+                original_position: nil
+              )
+            end
+          rescue JSON::ParserError, LoadError
+            # Not JSON or JSON not available, skip
+          end
+        end
+      end
+
+      # Return unique results
+      if opts[:structured]
+        results.uniq { |f| [f.text, f.type] }
+      else
+        results.uniq
+      end
+    end
+
+    private
+
+    # Build a map of character positions to line numbers
+    def self.build_line_map(content)
+      lines = content.lines
+      map = []
+      pos = 0
+      lines.each_with_index do |line, idx|
+        map << [pos, idx + 1]
+        pos += line.length
+      end
+      map
+    end
+
+    # Estimate line number from character position
+    def self.estimate_line(position, line_map)
+      return nil unless position && line_map
+      line_map.reverse.each do |start_pos, line_num|
+        return line_num if position >= start_pos
+      end
+      1
+    end
+
+    # Find approximate position of a string in the original content
+    def self.find_position_in_original(str, content)
+      # Simple indexOf approach - may not be perfect for duplicates
+      content.index(str)
+    end
+
+    # Recursively extract string values from JSON structures
+    def self.extract_strings_from_json(obj, results = [])
+      case obj
+      when String
+        results << obj unless obj.empty?
+      when Array
+        obj.each { |item| extract_strings_from_json(item, results) }
+      when Hash
+        obj.each_value { |value| extract_strings_from_json(value, results) }
+      end
+      results
+    end
+
+      # Exchange hardcoded text for I18n placeholders
+    # 
+    # This method replaces hardcoded strings in a file with I18n translation calls
+    # and adds the translations to a locale file (default: en.yml).
+    #
+    # @param path [String] Path to the file to process
+    # @param options [Hash] Configuration options
+    # @option options [String] :locale_path Path to locale file (default: config/locales/en.yml)
+    # @option options [String] :locale (en) Locale code
+    # @option options [String] :namespace Namespace prefix for translation keys (e.g., 'views.posts')
+    # @option options [Boolean] :dry_run (false) Preview changes without modifying files
+    # @option options [Integer] :min_length (2) Minimum string length to consider
+    # @option options [Array<String>] :ignore_patterns ([]) Regex patterns to exclude
+    # @option options [Boolean] :backup (true) Create backup files before modifying
+    #
+    # @return [Hash] Summary of changes made
+    def self.exchange_text_for_l18n_placeholder(path, options = {})
+      raise ArgumentError, "path must be a String" unless path.is_a?(String)
+      raise ArgumentError, "File not found: #{path}" unless File.file?(path)
+
+      # Default options
+      opts = {
+        locale_path: "config/locales/en.yml",
+        locale: "en",
+        namespace: nil,
+        dry_run: false,
+        min_length: 2,
+        ignore_patterns: [],
+        backup: true
+      }.merge(options)
+
+      # Find all hardcoded text with structured data
+      findings = find_text(path, opts.merge(structured: true))
+
+      return { replaced: 0, added_keys: 0, message: "No hardcoded text found" } if findings.empty?
+
+      # Load or create locale file
+      locale_data = load_locale_file(opts[:locale_path], opts[:locale])
+      
+      # Track changes
+      replacements = []
+      new_keys = []
+      
+      # Read original file content
+      content = File.read(path, encoding: "UTF-8")
+      modified_content = content.dup
+      
+      # Process findings in reverse order by position to maintain string positions
+      sorted_findings = findings.sort_by { |f| -(f.line || 0) }
+      
+      sorted_findings.each_with_index do |finding, idx|
+        # Generate translation key
+        key = generate_translation_key(finding.text, finding.type, opts[:namespace], idx)
+        
+        # Add to locale file
+        set_nested_key(locale_data, key, finding.text, opts[:locale])
+        new_keys << key
+        
+        # Replace in content based on type
+        replacement = case finding.type
+        when :erb_string
+          # Replace strings in ERB blocks
+          replace_erb_string(modified_content, finding.text, key)
+        when :text_node
+          # Replace HTML text nodes
+          replace_text_node(modified_content, finding.context, key)
+        when :attribute
+          # Replace attribute values
+          replace_attribute(modified_content, finding.context, key)
+        when :js_string, :js_template
+          # Replace JavaScript strings
+          replace_js_string(modified_content, finding.text, key)
+        when :data_attribute
+          # Data attributes are complex, skip for now
+          nil
+        end
+        
+        replacements << { text: finding.text, key: key, type: finding.type } if replacement
+      end
+
+      unless opts[:dry_run]
+        # Create backup
+        if opts[:backup]
+          backup_path = "#{path}.backup"
+          File.write(backup_path, content)
+        end
+        
+        # Write modified file
+        File.write(path, modified_content)
+        
+        # Write locale file
+        write_locale_file(opts[:locale_path], locale_data)
+      end
+
+      {
+        replaced: replacements.size,
+        added_keys: new_keys.size,
+        keys: new_keys,
+        replacements: replacements,
+        dry_run: opts[:dry_run]
+      }
+    end
+
+    # Automatically internationalize a file or directory
+    #
+    # This is the main entry point that combines finding and replacing hardcoded text.
+    # It will:
+    # 1. Find all hardcoded text in the file(s)
+    # 2. Replace them with I18n translation calls
+    # 3. Add translations to locale file
+    #
+    # @param path [String] Path to file or directory to process
+    # @param options [Hash] Configuration options (see exchange_text_for_l18n_placeholder)
+    # @option options [Boolean] :recursive (false) Process directories recursively
+    # @option options [String] :file_pattern (*.html.erb) File pattern to match in directories
+    #
+    # @return [Hash] Summary of all changes
+    def self.auto_internationalize(path, options = {})
+      raise ArgumentError, "path must be a String" unless path.is_a?(String)
+      raise ArgumentError, "Path not found: #{path}" unless File.exist?(path)
+
+      opts = {
+        recursive: false,
+        file_pattern: "*.html.erb"
+      }.merge(options)
+
+      results = []
+
+      if File.directory?(path)
+        # Process directory
+        pattern = opts[:recursive] ? "**/#{opts[:file_pattern]}" : opts[:file_pattern]
+        Dir.glob(File.join(path, pattern)).each do |file|
+          next unless File.file?(file)
+          
+          puts "Processing: #{file}" unless opts[:dry_run]
+          result = exchange_text_for_l18n_placeholder(file, opts)
+          results << { file: file, result: result }
+        end
+      else
+        # Process single file
+        result = exchange_text_for_l18n_placeholder(path, opts)
+        results << { file: path, result: result }
+      end
+
+      # Summary
+      total_replaced = results.sum { |r| r[:result][:replaced] }
+      total_keys = results.sum { |r| r[:result][:added_keys] }
+
+      {
+        files_processed: results.size,
+        total_replaced: total_replaced,
+        total_keys: total_keys,
+        details: results
+      }
+    end
+
+    private
+
+    # Generate a translation key from text
+    def self.generate_translation_key(text, type, namespace, index)
+      # Sanitize text to create a valid key
+      base_key = text.downcase
+        .gsub(/[^\w\s-]/, '') # Remove non-word chars except spaces and hyphens
+        .gsub(/\s+/, '_')      # Replace spaces with underscores
+        .gsub(/_+/, '_')       # Collapse multiple underscores
+        .gsub(/^_|_$/, '')     # Remove leading/trailing underscores
+        .slice(0, 50)          # Limit length
+      
+      # Add index if key would be too generic
+      base_key = "text_#{index}" if base_key.empty? || base_key.length < 3
+      
+      # Build full key with namespace
+      parts = []
+      parts << namespace if namespace
+      parts << base_key
+      
+      parts.join('.')
+    end
+
+    # Load locale file (YAML)
+    def self.load_locale_file(path, locale)
+      if File.exist?(path)
+        require 'yaml'
+        YAML.load_file(path) || { locale => {} }
+      else
+        { locale => {} }
+      end
+    end
+
+    # Write locale file (YAML)
+    def self.write_locale_file(path, data)
+      require 'yaml'
+      
+      # Ensure directory exists
+      FileUtils.mkdir_p(File.dirname(path))
+      
+      # Write with nice formatting
+      File.write(path, data.to_yaml)
+    end
+
+    # Set a nested key in a hash (e.g., "views.posts.title" => "Title")
+    def self.set_nested_key(hash, key_path, value, locale)
+      keys = key_path.split('.')
+      
+      # Ensure locale root exists
+      hash[locale] ||= {}
+      
+      # Navigate/create nested structure
+      current = hash[locale]
+      keys[0..-2].each do |key|
+        current[key] ||= {}
+        current = current[key]
+      end
+      
+      # Set the value
+      current[keys.last] = value
+    end
+
+    # Replace a string in ERB code blocks
+    def self.replace_erb_string(content, text, key)
+      # Match both single and double quoted strings
+      escaped_text = Regexp.escape(text)
+      
+      # Try double quotes first
+      pattern = /"#{escaped_text}"/
+      if content =~ pattern
+        content.gsub!(pattern, "t('#{key}')")
+        return true
+      end
+      
+      # Try single quotes
+      pattern = /'#{escaped_text}'/
+      if content =~ pattern
+        content.gsub!(pattern, "t('#{key}')")
+        return true
+      end
+      
+      false
+    end
+
+    # Replace text in HTML text nodes
+    def self.replace_text_node(content, text, key)
+      # Escape special regex characters but preserve the text structure
+      escaped = Regexp.escape(text)
+      
+      # Look for the text outside of ERB tags
+      pattern = /(?<![<%=])(\s*)#{escaped}(\s*)(?!%>)/
+      
+      if content =~ pattern
+        content.gsub!(pattern, "\\1<%= t('#{key}') %>\\2")
+        return true
+      end
+      
+      false
+    end
+
+    # Replace attribute values
+    def self.replace_attribute(content, text, key)
+      escaped = Regexp.escape(text)
+      
+      # Match attribute="text" or attribute='text'
+      pattern = /(\w+)=["']#{escaped}["']/
+      
+      if content =~ pattern
+        content.gsub!(pattern, "\\1=\"<%= t('#{key}') %>\"")
+        return true
+      end
+      
+      false
+    end
+
+    # Replace JavaScript strings
+    def self.replace_js_string(content, text, key)
+      escaped = Regexp.escape(text)
+      
+      # Try double quotes
+      pattern = /"#{escaped}"/
+      if content =~ pattern
+        content.gsub!(pattern, "\"<%= t('#{key}') %>\"")
+        return true
+      end
+      
+      # Try single quotes
+      pattern = /'#{escaped}'/
+      if content =~ pattern
+        content.gsub!(pattern, "'<%= t('#{key}') %>'")
+        return true
+      end
+      
+      false
+    end
+
+    # Build a map of character positions to line numbers
+    def self.build_line_map(content)
+      lines = content.lines
+      map = []
+      pos = 0
+      lines.each_with_index do |line, idx|
+        map << [pos, idx + 1]
+        pos += line.length
+      end
+      map
+    end
+
+    # Estimate line number from character position
+    def self.estimate_line(position, line_map)
+      return nil unless position && line_map
+      line_map.reverse.each do |start_pos, line_num|
+        return line_num if position >= start_pos
+      end
+      1
+    end
+
+    # Find approximate position of a string in the original content
+    def self.find_position_in_original(str, content)
+      # Simple indexOf approach - may not be perfect for duplicates
+      content.index(str)
+    end
+
+    # Recursively extract string values from JSON structures
+    def self.extract_strings_from_json(obj, results = [])
+      case obj
+      when String
+        results << obj unless obj.empty?
+      when Array
+        obj.each { |item| extract_strings_from_json(item, results) }
+      when Hash
+        obj.each_value { |value| extract_strings_from_json(value, results) }
+      end
+      results
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: auto-l18n
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nicolas Reiner
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-10-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.15'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.15'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: This gem provides a set of tools to streamline the process of adding
+  and managing translations in Rails applications.
+email:
+- nici.ferd@gmail.com
+executables:
+- auto-l18n
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/auto-l18n
+- lib/auto/l18n.rb
+- lib/auto/l18n/version.rb
+homepage: https://github.com/NicolasReiner/auto-l18n
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/NicolasReiner/auto-l18n
+  source_code_uri: https://github.com/NicolasReiner/auto-l18n
+  changelog_uri: https://github.com/NicolasReiner/auto-l18n/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/NicolasReiner/auto-l18n/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: A gem to help with automatic localization for Rails applications.
+test_files: []