file_tree_visualizer 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9ec7a6ef5ea0597b5efc056da74912985e0ca2f9a784398c13aa83b5e95c5a6
-  data.tar.gz: f3a9a8ee8fb984e8b135fefbe9db34b9e8f5df19ccf787538a754b975b5c9022
+  metadata.gz: 487ea44c103965a0bf633fc0d618c50fb4a0c7d8ddbbee53b61f4d99a959d3f9
+  data.tar.gz: 89a961a923ab5ae1a9f83ada18f1951905e5ccde53219de8ba83fe5bd34b14f1
 SHA512:
-  metadata.gz: f902440430610f789db16ab282b2890e3569fa354691ee74dd1587539ad299aa2b7db9c66890496fd46429e1369da7b5d84db95b6c1614977559ffbef3b99c68
-  data.tar.gz: 9571ce07d3162b7e5477ae40f1a844c61e2ac476780e1665300778e1d811500b1b288e064b376e86a2f2305e1fad3e54a3a2dbbd80c106459f8638d4d96b835c
+  metadata.gz: fd1eddbd5b1ae2b077e521f8ddd09dad953c12679aac80da81253cb18673a2f300d5146f86e244da85888b4872e59e823174c7a35e47f58aaa76cfa859e23cea
+  data.tar.gz: 7e91afaea1510c5c3ea03695666a1edac1390bd1be55c15c5bd9a6092bdc10a35f981bce7289f0a9a1e05ef5f0823c84a4da54161929a42868150dda92d90729

data/Gemfile

@@ -3,3 +3,5 @@
 source "https://rubygems.org"
 
 gemspec
+gem "rake", "~> 13.0"
+gem "minitest", "~> 5.20"

data/README.md

@@ -1,44 +1,75 @@
 # file_tree_visualizer
 
-Gema Ruby para escanear árboles de archivos desde terminal y generar un reporte HTML interactivo 100% offline con los elementos que más espacio ocupan.
+Ruby gem to scan file trees from the terminal and generate a fully offline interactive HTML report with the items that consume the most disk space.
 
-## Qué hace
+## What it does
 
-- Recorre recursivamente una carpeta.
-- Calcula tamaño acumulado por directorio y tamaño por archivo.
-- Genera un reporte HTML con:
-  - Árbol de archivos expandible/colapsable.
-  - Filtros por texto y tamaño mínimo.
-  - Ranking de archivos más pesados.
-  - Sin dependencias externas (funciona sin internet).
+- Recursively scans a directory.
+- Computes cumulative size per directory and size per file.
+- Generates an HTML report with:
+  - Expand/collapse file tree.
+  - Text and minimum-size filters.
+  - Ranking of the largest files.
+  - No external dependencies (works offline).
 
-## Uso rápido (sin instalar la gema)
+## Quick usage (without installing the gem)
 
 ```bash
-ruby bin/file-tree-visualizer /ruta/a/escanear -o reporte.html
+ruby bin/file-tree-visualizer /path/to/scan -o report.html
 ```
 
-## Uso como gema
+## Install from RubyGems
+
+Gem page: https://rubygems.org/gems/file_tree_visualizer
+
+```bash
+gem install file_tree_visualizer
+file-tree-visualizer /path/to/scan -o report.html
+```
+
+Install a specific version:
+
+```bash
+gem install file_tree_visualizer -v 0.1.0
+```
+
+## Local development install
 
 ```bash
 bundle install
 gem build file_tree_visualizer.gemspec
-gem install ./file_tree_visualizer-0.0.3.gem
-file-tree-visualizer /ruta/a/escanear -o reporte.html
+gem install ./file_tree_visualizer-0.1.0.gem
+file-tree-visualizer /path/to/scan -o report.html
 ```
 
-## Opciones
+## Options
 
 ```bash
-file-tree-visualizer [ruta] [opciones]
+file-tree-visualizer [path] [options]
+
+If no `path` is provided, the current directory is scanned by default.
 
-Si no indicas `ruta`, se escanea el directorio actual por defecto.
+During scanning, an interactive terminal shows a progress bar with processed files/directories vs discovered totals.
 
-Durante el escaneo, en terminal interactiva se muestra una barra de progreso con archivos y directorios procesados vs total detectado.
+    -o, --output FILE           Output HTML file (default: file-tree-report.html)
+    -t, --top N                 Number of largest files to keep in ranking (default: 200)
+        --follow-symlinks       Follow symbolic links
+        --no-progress           Disable progress bar
+        --lang LANG             Language for CLI and report (en|es)
+    -h, --help                  Show help
+
+Language resolution priority:
+- `--lang`
+- `LANG` environment variable (for example `es_CL.UTF-8`)
+- fallback to English (`en`)
+```
 
-    -o, --output FILE           Archivo HTML de salida (default: file-tree-report.html)
-    -t, --top N                 Cantidad de archivos pesados a guardar en ranking (default: 200)
-        --follow-symlinks       Sigue enlaces simbólicos
-        --no-progress           Desactiva la barra de progreso
-    -h, --help                  Muestra ayuda
+## Automatic release to RubyGems
+
+- This repository publishes the gem automatically when pushing a tag with format `v*` (for example `v0.0.4`).
+- Before using it, configure the `RUBYGEMS_API_KEY` secret in GitHub Actions.
+
+```bash
+git tag v0.0.4
+git push origin v0.0.4
 ```

data/Rakefile

@@ -1,3 +1,11 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+end
+
+task default: :test

data/file_tree_visualizer.gemspec

@@ -1,33 +1,33 @@
 # frozen_string_literal: true
 
-require_relative "lib/file_tree_visualizer/version"
+require_relative 'lib/file_tree_visualizer/version'
 
 Gem::Specification.new do |spec|
-  spec.name = "file_tree_visualizer"
+  spec.name = 'file_tree_visualizer'
   spec.version = FileTreeVisualizer::VERSION
-  spec.authors = ["jbidwell1"]
-  spec.email = ["devnull@example.com"]
+  spec.authors = ['jbidwell1']
+  spec.email = ['devnull@example.com']
 
-  spec.summary = "CLI Ruby tool to analyze file sizes and generate an interactive HTML report."
-  spec.description = "Scans a directory recursively, computes file/directory sizes, and generates an HTML report rendered with React."
-  spec.homepage = "https://example.com/file_tree_visualizer"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.7"
+  spec.summary = 'CLI Ruby tool to analyze file sizes and generate an interactive HTML report.'
+  spec.description = 'Scans a directory recursively, computes file/directory sizes, and generates an HTML report rendered with React.'
+  spec.homepage = 'https://github.com/JohnBidwellB/file-tree-visualizer'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.7'
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/CHANGELOG.md"
 
   spec.files = Dir.chdir(__dir__) do
     Dir[
-      "README.md",
-      "Gemfile",
-      "Rakefile",
-      "bin/*",
-      "lib/**/*.rb",
-      "file_tree_visualizer.gemspec"
+      'README.md',
+      'Gemfile',
+      'Rakefile',
+      'bin/*',
+      'lib/**/*.rb',
+      'file_tree_visualizer.gemspec'
     ]
   end
-  spec.bindir = "bin"
-  spec.executables = ["file-tree-visualizer"]
-  spec.require_paths = ["lib"]
+  spec.bindir = 'bin'
+  spec.executables = ['file-tree-visualizer']
+  spec.require_paths = ['lib']
 end

data/lib/file_tree_visualizer/cli.rb

@@ -1,42 +1,54 @@
 # frozen_string_literal: true
 
-require "optparse"
+require 'optparse'
 
 module FileTreeVisualizer
   class CLI
-    DEFAULT_OUTPUT = "file-tree-report.html"
+    DEFAULT_OUTPUT = 'file-tree-report.html'
+    DEFAULT_LOCALE = 'en'
 
     def initialize(argv)
       @argv = argv
     end
 
     def run
-      options, parser = parse_options(@argv.dup)
+      options, parser, locale = parse_options(@argv.dup)
       if options[:help]
         puts parser
         return 0
       end
 
+      expanded_path = File.expand_path(options[:path])
+      unless File.directory?(expanded_path)
+        raise ArgumentError,
+              t(locale, 'cli.errors.invalid_directory', path: expanded_path)
+      end
+
       scanner = Scanner.new(top_limit: options[:top], follow_symlinks: options[:follow_symlinks])
-      progress = ProgressRenderer.new(enabled: options[:progress])
+      progress = ProgressRenderer.new(enabled: options[:progress], locale: locale)
       callback = options[:progress] ? progress.method(:render) : nil
-      result = scanner.scan(options[:path], progress: callback)
+      result = scanner.scan(expanded_path, progress: callback)
       progress.finish
-      report = ReportBuilder.new(result: result, source_path: options[:path]).build
+      report = ReportBuilder.new(result: result, source_path: expanded_path, locale: locale).build
 
       output_path = File.expand_path(options[:output])
       File.write(output_path, report)
 
-      puts "Reporte generado en: #{output_path}"
-      puts "Escaneado: #{result.stats[:directories]} directorios, #{result.stats[:files]} archivos, #{result.stats[:skipped]} omitidos."
-      puts "Tamaño total: #{format_bytes(result.stats[:bytes])}"
+      puts t(locale, 'cli.messages.report_generated', path: output_path)
+      puts t(locale, 'cli.messages.scanned',
+             directories: result.stats[:directories],
+             files: result.stats[:files],
+             skipped: result.stats[:skipped])
+      puts t(locale, 'cli.messages.total_size', size: format_bytes(result.stats[:bytes]))
       0
     rescue OptionParser::ParseError, ArgumentError => e
+      locale = error_locale
       warn e.message
-      warn "Usa --help para ver las opciones disponibles."
+      warn t(locale, 'cli.errors.use_help')
       1
     rescue StandardError => e
-      warn "Error inesperado: #{e.message}"
+      locale = error_locale
+      warn t(locale, 'cli.errors.unexpected', message: e.message)
       1
     end
 
@@ -45,9 +57,10 @@ module FileTreeVisualizer
     class ProgressRenderer
       BAR_WIDTH = 28
 
-      def initialize(io: $stdout, enabled: true)
+      def initialize(io: $stdout, enabled: true, locale: DEFAULT_LOCALE)
         @io = io
         @enabled = enabled && io.tty?
+        @locale = locale
         @last_draw_at = nil
         @has_rendered = false
         @spinner_index = 0
@@ -82,7 +95,7 @@ module FileTreeVisualizer
       def render_counting(data)
         spinner = %w[| / - \\][@spinner_index % 4]
         @spinner_index += 1
-        @io.print(format("\rPreparando escaneo %<spinner>s Arch:%<files>d Dir:%<dirs>d",
+        @io.print(format("\r#{I18n.t(@locale, 'cli.progress.preparing')}",
                          spinner: spinner,
                          files: data.fetch(:discovered_files, 0),
                          dirs: data.fetch(:discovered_directories, 0)))
@@ -102,9 +115,9 @@ module FileTreeVisualizer
         empty = BAR_WIDTH - filled
         percent = progress_ratio * 100
 
-        @io.print(format("\rEscaneando [%<bar>s] %<percent>6.2f%% Arch:%<pf>d/%<tf>d Dir:%<pd>d/%<td>d",
-                         bar: ("#" * filled) + ("-" * empty),
-                         percent: percent,
+        @io.print(format("\r#{I18n.t(@locale, 'cli.progress.scanning')}",
+                         bar: ('#' * filled) + ('-' * empty),
+                         percent: format('%6.2f', percent),
                          pf: processed_files,
                          tf: total_files,
                          pd: processed_directories,
@@ -113,46 +126,84 @@ module FileTreeVisualizer
     end
 
     def parse_options(argv)
+      locale = I18n.resolve_locale(cli_value: extract_lang_argument(argv), env_lang: ENV['LANG'])
       options = {
         path: Dir.pwd,
         output: DEFAULT_OUTPUT,
         top: Scanner::DEFAULT_TOP_LIMIT,
         follow_symlinks: false,
         progress: true,
+        lang: nil,
         help: false
       }
 
-      parser = OptionParser.new do |opts|
-        opts.banner = "Uso: file-tree-visualizer [ruta] [opciones]"
-        opts.separator ""
-        opts.separator "Opciones:"
+      parser = build_parser(locale, options)
+      remaining = parser.parse(argv)
+
+      if options[:lang] && !I18n.supported_locale?(options[:lang])
+        raise ArgumentError, t(locale,
+                               'cli.errors.invalid_lang',
+                               lang: options[:lang],
+                               supported: I18n::SUPPORTED_LOCALES.join(', '))
+      end
+
+      locale = I18n.resolve_locale(cli_value: options[:lang], env_lang: ENV['LANG'])
+      parser = build_parser(locale, options)
+
+      options[:path] = File.expand_path(remaining.first || options[:path])
+      raise ArgumentError, t(locale, 'cli.errors.invalid_top') unless options[:top].positive?
+
+      [options, parser, locale]
+    end
+
+    def build_parser(locale, options)
+      OptionParser.new do |opts|
+        opts.banner = t(locale, 'cli.banner')
+        opts.separator ''
+        opts.separator t(locale, 'cli.options_header')
 
-        opts.on("-o", "--output FILE", "Archivo HTML de salida (default: #{DEFAULT_OUTPUT})") do |value|
+        opts.on('-o', '--output FILE', t(locale, 'cli.output_option', default: DEFAULT_OUTPUT)) do |value|
           options[:output] = value
         end
 
-        opts.on("-t", "--top N", Integer, "Cantidad de archivos pesados en ranking (default: #{Scanner::DEFAULT_TOP_LIMIT})") do |value|
+        opts.on('-t', '--top N', Integer, t(locale, 'cli.top_option', default: Scanner::DEFAULT_TOP_LIMIT)) do |value|
           options[:top] = value
         end
 
-        opts.on("--follow-symlinks", "Sigue enlaces simbólicos durante el escaneo") do
+        opts.on('--follow-symlinks', t(locale, 'cli.follow_symlinks_option')) do
           options[:follow_symlinks] = true
         end
 
-        opts.on("--no-progress", "Desactiva la barra de progreso") do
+        opts.on('--no-progress', t(locale, 'cli.no_progress_option')) do
           options[:progress] = false
         end
 
-        opts.on("-h", "--help", "Muestra esta ayuda") do
+        opts.on('--lang LANG', t(locale, 'cli.lang_option')) do |value|
+          options[:lang] = value
+        end
+
+        opts.on('-h', '--help', t(locale, 'cli.help_option')) do
           options[:help] = true
         end
       end
+    end
 
-      remaining = parser.parse(argv)
-      options[:path] = File.expand_path(remaining.first || options[:path])
-      raise ArgumentError, "--top debe ser mayor que 0" unless options[:top].positive?
+    def extract_lang_argument(argv)
+      argv.each_with_index do |arg, index|
+        return arg.split('=', 2).last if arg.start_with?('--lang=')
+        next unless arg == '--lang'
+
+        return argv[index + 1]
+      end
+      nil
+    end
+
+    def t(locale, key, **vars)
+      I18n.t(locale, key, **vars)
+    end
 
-      [options, parser]
+    def error_locale
+      I18n.resolve_locale(cli_value: extract_lang_argument(@argv), env_lang: ENV['LANG'])
     end
 
     def format_bytes(bytes)

data/lib/file_tree_visualizer/i18n.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module FileTreeVisualizer
+  module I18n
+    SUPPORTED_LOCALES = %w[en es].freeze
+
+    TRANSLATIONS = {
+      'en' => {
+        'cli' => {
+          'banner' => 'Usage: file-tree-visualizer [path] [options]',
+          'options_header' => 'Options:',
+          'output_option' => 'Output HTML file (default: %<default>s)',
+          'top_option' => 'Number of largest files in ranking (default: %<default>s)',
+          'follow_symlinks_option' => 'Follow symbolic links during scan',
+          'no_progress_option' => 'Disable progress bar',
+          'lang_option' => 'Language for CLI and report (en|es)',
+          'help_option' => 'Show this help',
+          'messages' => {
+            'report_generated' => 'Report generated at: %<path>s',
+            'scanned' => 'Scanned: %<directories>s directories, %<files>s files, %<skipped>s skipped.',
+            'total_size' => 'Total size: %<size>s'
+          },
+          'errors' => {
+            'invalid_top' => '--top must be greater than 0',
+            'invalid_lang' => "Unsupported language '%<lang>s'. Supported values: %<supported>s",
+            'invalid_directory' => 'Path is not a directory: %<path>s',
+            'use_help' => 'Use --help to see available options.',
+            'unexpected' => 'Unexpected error: %<message>s'
+          },
+          'progress' => {
+            'preparing' => 'Preparing scan %<spinner>s Files:%<files>s Dirs:%<dirs>s',
+            'scanning' => 'Scanning [%<bar>s] %<percent>s%% Files:%<pf>s/%<tf>s Dirs:%<pd>s/%<td>s'
+          }
+        },
+        'report' => {
+          'page_title' => 'File Report',
+          'header_title' => 'Disk usage report',
+          'meta_source_prefix' => 'Source: ',
+          'meta_generated_prefix' => 'Generated: ',
+          'stats' => {
+            'total_size' => 'Total size',
+            'files' => 'Files',
+            'directories' => 'Directories',
+            'skipped' => 'Skipped entries'
+          },
+          'filters' => {
+            'search_label' => 'Search by name/path',
+            'search_placeholder' => 'eg: node_modules, .mp4, backup',
+            'min_size_label' => 'Minimum size (MB)',
+            'min_size_hint' => 'Filters tree nodes and ranking by minimum size.'
+          },
+          'panels' => {
+            'tree' => 'File tree',
+            'top_files' => 'Top largest files'
+          },
+          'table' => {
+            'index' => '#',
+            'size' => 'Size',
+            'path' => 'Path'
+          },
+          'empty' => {
+            'tree' => 'No results with current filters.',
+            'top_files' => 'No files to show with current filters.'
+          }
+        }
+      },
+      'es' => {
+        'cli' => {
+          'banner' => 'Uso: file-tree-visualizer [ruta] [opciones]',
+          'options_header' => 'Opciones:',
+          'output_option' => 'Archivo HTML de salida (default: %<default>s)',
+          'top_option' => 'Cantidad de archivos pesados en ranking (default: %<default>s)',
+          'follow_symlinks_option' => 'Sigue enlaces simbólicos durante el escaneo',
+          'no_progress_option' => 'Desactiva la barra de progreso',
+          'lang_option' => 'Idioma para CLI y reporte (en|es)',
+          'help_option' => 'Muestra esta ayuda',
+          'messages' => {
+            'report_generated' => 'Reporte generado en: %<path>s',
+            'scanned' => 'Escaneado: %<directories>s directorios, %<files>s archivos, %<skipped>s omitidos.',
+            'total_size' => 'Tamano total: %<size>s'
+          },
+          'errors' => {
+            'invalid_top' => '--top debe ser mayor que 0',
+            'invalid_lang' => "Idioma no soportado '%<lang>s'. Valores permitidos: %<supported>s",
+            'invalid_directory' => 'La ruta no es un directorio: %<path>s',
+            'use_help' => 'Usa --help para ver las opciones disponibles.',
+            'unexpected' => 'Error inesperado: %<message>s'
+          },
+          'progress' => {
+            'preparing' => 'Preparando escaneo %<spinner>s Arch:%<files>s Dir:%<dirs>s',
+            'scanning' => 'Escaneando [%<bar>s] %<percent>s%% Arch:%<pf>s/%<tf>s Dir:%<pd>s/%<td>s'
+          }
+        },
+        'report' => {
+          'page_title' => 'Reporte de archivos',
+          'header_title' => 'Reporte de espacio en disco',
+          'meta_source_prefix' => 'Origen: ',
+          'meta_generated_prefix' => 'Generado: ',
+          'stats' => {
+            'total_size' => 'Tamano total',
+            'files' => 'Archivos',
+            'directories' => 'Directorios',
+            'skipped' => 'Entradas omitidas'
+          },
+          'filters' => {
+            'search_label' => 'Buscar por nombre/ruta',
+            'search_placeholder' => 'ej: node_modules, .mp4, backup',
+            'min_size_label' => 'Tamano minimo (MB)',
+            'min_size_hint' => 'Filtra nodos y ranking por tamano minimo.'
+          },
+          'panels' => {
+            'tree' => 'Arbol de archivos',
+            'top_files' => 'Top archivos mas pesados'
+          },
+          'table' => {
+            'index' => '#',
+            'size' => 'Tamano',
+            'path' => 'Ruta'
+          },
+          'empty' => {
+            'tree' => 'Sin resultados con los filtros actuales.',
+            'top_files' => 'Sin archivos para mostrar con los filtros actuales.'
+          }
+        }
+      }
+    }.freeze
+
+    module_function
+
+    def supported_locale?(value)
+      SUPPORTED_LOCALES.include?(normalize_locale(value))
+    end
+
+    def resolve_locale(cli_value: nil, env_lang: nil)
+      normalize_locale(cli_value) || normalize_locale(env_lang) || 'en'
+    end
+
+    def normalize_locale(value)
+      return nil if value.nil?
+
+      normalized = value.to_s.strip.downcase
+      return nil if normalized.empty?
+
+      return 'es' if normalized.start_with?('es')
+      return 'en' if normalized.start_with?('en')
+
+      nil
+    end
+
+    def t(locale, key, **vars)
+      template = lookup(locale, key) || lookup('en', key)
+      return key unless template.is_a?(String)
+
+      return template if vars.empty?
+
+      template % vars.transform_keys(&:to_sym)
+    rescue KeyError
+      template
+    end
+
+    def lookup(locale, key)
+      current = TRANSLATIONS[locale]
+      return nil unless current
+
+      key.to_s.split('.').each do |part|
+        return nil unless current.is_a?(Hash)
+
+        current = current[part]
+      end
+      current
+    end
+  end
+end

data/lib/file_tree_visualizer/report_builder.rb

@@ -1,25 +1,27 @@
 # frozen_string_literal: true
 
-require "json"
-require "time"
+require 'json'
+require 'time'
 
 module FileTreeVisualizer
   class ReportBuilder
-    def initialize(result:, source_path:, generated_at: Time.now.utc)
+    def initialize(result:, source_path:, generated_at: Time.now.utc, locale: 'en')
       @result = result
       @source_path = File.expand_path(source_path.to_s)
       @generated_at = generated_at
+      @locale = I18n.resolve_locale(cli_value: locale)
     end
 
     def build
-      payload_json = JSON.generate(payload).gsub("</", "<\\/")
+      payload_json = JSON.generate(payload).gsub('</', '<\\/')
+      translations_json = JSON.generate(translation_payload).gsub('</', '<\\/')
       <<~HTML
         <!doctype html>
-        <html lang="es">
+        <html lang="#{@locale}">
           <head>
             <meta charset="utf-8" />
             <meta name="viewport" content="width=device-width, initial-scale=1" />
-            <title>Reporte de archivos</title>
+            <title>#{t('report.page_title')}</title>
             <style>
               :root {
                 color-scheme: dark;
@@ -215,6 +217,7 @@ module FileTreeVisualizer
             <script>
               (function () {
                 const data = JSON.parse(document.getElementById("scan-data").textContent);
+                const i18n = #{translations_json};
                 const app = document.getElementById("app");
 
                 const state = {
@@ -256,31 +259,31 @@ module FileTreeVisualizer
                   '<div class="container">',
                   '  <header class="header">',
                   '    <div>',
-                  '      <h1>Reporte de espacio en disco</h1>',
+                  '      <h1>' + i18n.headerTitle + '</h1>',
                   '      <div class="meta" id="meta-source"></div>',
                   '      <div class="meta" id="meta-generated"></div>',
                   '    </div>',
                   '  </header>',
                   '  <section class="stats">',
-                  '    <div class="stat"><div class="stat-label">Tamaño total</div><div class="stat-value" id="stat-bytes"></div></div>',
-                  '    <div class="stat"><div class="stat-label">Archivos</div><div class="stat-value" id="stat-files"></div></div>',
-                  '    <div class="stat"><div class="stat-label">Directorios</div><div class="stat-value" id="stat-directories"></div></div>',
-                  '    <div class="stat"><div class="stat-label">Entradas omitidas</div><div class="stat-value" id="stat-skipped"></div></div>',
+                  '    <div class="stat"><div class="stat-label">' + i18n.statsTotalSize + '</div><div class="stat-value" id="stat-bytes"></div></div>',
+                  '    <div class="stat"><div class="stat-label">' + i18n.statsFiles + '</div><div class="stat-value" id="stat-files"></div></div>',
+                  '    <div class="stat"><div class="stat-label">' + i18n.statsDirectories + '</div><div class="stat-value" id="stat-directories"></div></div>',
+                  '    <div class="stat"><div class="stat-label">' + i18n.statsSkipped + '</div><div class="stat-value" id="stat-skipped"></div></div>',
                   '  </section>',
                   '  <section class="filters">',
-                  '    <label>Buscar por nombre/ruta<input id="query-input" type="text" placeholder="ej: node_modules, .mp4, backup" /></label>',
-                  '    <label>Tamaño mínimo (MB)<input id="min-size-input" type="number" min="0" value="0" /><span class="hint">Filtra nodos y ranking por tamaño mínimo.</span></label>',
+                  '    <label>' + i18n.searchLabel + '<input id="query-input" type="text" placeholder="' + i18n.searchPlaceholder + '" /></label>',
+                  '    <label>' + i18n.minSizeLabel + '<input id="min-size-input" type="number" min="0" value="0" /><span class="hint">' + i18n.minSizeHint + '</span></label>',
                   '  </section>',
                   '  <section class="layout">',
                   '    <article class="panel">',
-                  '      <h2>Árbol de archivos</h2>',
+                  '      <h2>' + i18n.treeTitle + '</h2>',
                   '      <div class="panel-body" id="tree-panel"></div>',
                   '    </article>',
                   '    <article class="panel">',
-                  '      <h2>Top archivos más pesados</h2>',
+                  '      <h2>' + i18n.topFilesTitle + '</h2>',
                   '      <div class="panel-body">',
                   '        <table>',
-                  '          <thead><tr><th>#</th><th>Tamaño</th><th>Ruta</th></tr></thead>',
+                  '          <thead><tr><th>' + i18n.tableIndex + '</th><th>' + i18n.tableSize + '</th><th>' + i18n.tablePath + '</th></tr></thead>',
                   '          <tbody id="top-files-body"></tbody>',
                   '        </table>',
                   '      </div>',
@@ -294,8 +297,8 @@ module FileTreeVisualizer
                 const treePanel = document.getElementById("tree-panel");
                 const topFilesBody = document.getElementById("top-files-body");
 
-                document.getElementById("meta-source").textContent = "Origen: " + data.source_path;
-                document.getElementById("meta-generated").textContent = "Generado: " + data.generated_at;
+                document.getElementById("meta-source").textContent = i18n.metaSourcePrefix + data.source_path;
+                document.getElementById("meta-generated").textContent = i18n.metaGeneratedPrefix + data.generated_at;
                 document.getElementById("stat-bytes").textContent = formatBytes(data.stats.bytes);
                 document.getElementById("stat-files").textContent = formatNumber(data.stats.files);
                 document.getElementById("stat-directories").textContent = formatNumber(data.stats.directories);
@@ -365,7 +368,7 @@ module FileTreeVisualizer
                   if (!nodeMatches(data.root, activeFilters.query, activeFilters.minBytes)) {
                     const empty = document.createElement("div");
                     empty.className = "empty-state";
-                    empty.textContent = "Sin resultados con los filtros actuales.";
+                    empty.textContent = i18n.emptyTree;
                     treePanel.appendChild(empty);
                     return;
                   }
@@ -384,7 +387,7 @@ module FileTreeVisualizer
                     const cell = document.createElement("td");
                     cell.colSpan = 3;
                     cell.className = "empty-state";
-                    cell.textContent = "Sin archivos para mostrar con los filtros actuales.";
+                    cell.textContent = i18n.emptyTopFiles;
                     emptyRow.appendChild(cell);
                     topFilesBody.appendChild(emptyRow);
                     return;
@@ -439,5 +442,32 @@ module FileTreeVisualizer
         top_files: @result.top_files
       }
     end
+
+    def translation_payload
+      {
+        headerTitle: t('report.header_title'),
+        metaSourcePrefix: t('report.meta_source_prefix'),
+        metaGeneratedPrefix: t('report.meta_generated_prefix'),
+        statsTotalSize: t('report.stats.total_size'),
+        statsFiles: t('report.stats.files'),
+        statsDirectories: t('report.stats.directories'),
+        statsSkipped: t('report.stats.skipped'),
+        searchLabel: t('report.filters.search_label'),
+        searchPlaceholder: t('report.filters.search_placeholder'),
+        minSizeLabel: t('report.filters.min_size_label'),
+        minSizeHint: t('report.filters.min_size_hint'),
+        treeTitle: t('report.panels.tree'),
+        topFilesTitle: t('report.panels.top_files'),
+        tableIndex: t('report.table.index'),
+        tableSize: t('report.table.size'),
+        tablePath: t('report.table.path'),
+        emptyTree: t('report.empty.tree'),
+        emptyTopFiles: t('report.empty.top_files')
+      }
+    end
+
+    def t(key)
+      I18n.t(@locale, key)
+    end
   end
 end

data/lib/file_tree_visualizer/scanner.rb

@@ -14,7 +14,7 @@ module FileTreeVisualizer
     def scan(path, progress: nil)
       reset!
       expanded_path = File.expand_path(path.to_s)
-      raise ArgumentError, "La ruta no es un directorio: #{expanded_path}" unless File.directory?(expanded_path)
+      raise ArgumentError, "Path is not a directory: #{expanded_path}" unless File.directory?(expanded_path)
 
       @progress_callback = progress
       notify_counting_progress(force: true)
@@ -66,7 +66,7 @@ module FileTreeVisualizer
       node = {
         name: directory_name,
         path: path,
-        type: "directory",
+        type: 'directory',
         size: 0,
         children: []
       }
@@ -106,7 +106,7 @@ module FileTreeVisualizer
         file_node = {
           name: entry_name,
           path: child_path,
-          type: "file",
+          type: 'file',
           size: file_size
         }
         parent_node[:children] << file_node

data/lib/file_tree_visualizer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FileTreeVisualizer
-  VERSION = "0.0.3"
+  VERSION = '0.1.0'
 end

data/lib/file_tree_visualizer.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "file_tree_visualizer/version"
-require_relative "file_tree_visualizer/scanner"
-require_relative "file_tree_visualizer/report_builder"
-require_relative "file_tree_visualizer/cli"
+require_relative 'file_tree_visualizer/version'
+require_relative 'file_tree_visualizer/i18n'
+require_relative 'file_tree_visualizer/scanner'
+require_relative 'file_tree_visualizer/report_builder'
+require_relative 'file_tree_visualizer/cli'
 
 module FileTreeVisualizer
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: file_tree_visualizer
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - jbidwell1
@@ -26,15 +26,16 @@ files:
 - file_tree_visualizer.gemspec
 - lib/file_tree_visualizer.rb
 - lib/file_tree_visualizer/cli.rb
+- lib/file_tree_visualizer/i18n.rb
 - lib/file_tree_visualizer/report_builder.rb
 - lib/file_tree_visualizer/scanner.rb
 - lib/file_tree_visualizer/version.rb
-homepage: https://example.com/file_tree_visualizer
+homepage: https://github.com/JohnBidwellB/file-tree-visualizer
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://example.com/file_tree_visualizer
-  source_code_uri: https://example.com/file_tree_visualizer
+  source_code_uri: https://github.com/JohnBidwellB/file-tree-visualizer
+  changelog_uri: https://github.com/JohnBidwellB/file-tree-visualizer/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths: