dorian 2.4.0 → 2.5.1

data/lib/dorian/bin.rb

@@ -6,14 +6,82 @@ require "dorian/eval"
 require "dorian/progress"
 require "dorian/to_struct"
 require "git"
+require "hexapdf"
 require "json"
+require "mini_racer"
 require "net/http"
 require "parallel"
+require "shellwords"
+require "syntax_tree"
+require "syntax_tree/erb"
+require "syntax_tree/haml"
+require "syntax_tree/xml"
+require "syntax_tree/json"
+require "tempfile"
+require "terminal-table"
 require "uri"
 require "yaml"
 
 class Dorian
   class Bin
+    RUBY_EXTENSIONS = %w[
+      .rb
+      .arb
+      .axlsx
+      .builder
+      .fcgi
+      .gemfile
+      .gemspec
+      .god
+      .jb
+      .jbuilder
+      .mspec
+      .opal
+      .pluginspec
+      .podspec
+      .rabl
+      .rake
+      .rbuild
+      .rbw
+      .rbx
+      .ru
+      .ruby
+      .schema
+      .spec
+      .thor
+      .watchr
+    ].freeze
+
+    RUBY_FILENAMES = %w[
+      .irbrc
+      .pryrc
+      .simplecov
+      Appraisals
+      Berksfile
+      Brewfile
+      Buildfile
+      Capfile
+      Cheffile
+      Dangerfile
+      Deliverfile
+      Fastfile
+      Gemfile
+      Guardfile
+      Jarfile
+      Mavenfile
+      Podfile
+      Puppetfile
+      Rakefile
+      rakefile
+      Schemafile
+      Snapfile
+      Steepfile
+      Thorfile
+      Vagabondfile
+      Vagrantfile
+      buildfile
+    ].freeze
+
     VERSION = File.read(File.expand_path("../../VERSION", __dir__))
 
     DEFAULT_IO = :raw
@@ -51,8 +119,7 @@ class Dorian
             alias: :o
           },
           parallel: {
-            alias: :p,
-            default: true
+            alias: :p
           },
           parallel_type: {
             alias: :pt,
@@ -206,6 +273,83 @@ class Dorian
         arguments.delete("ls")
         @command = :ls
         command_ls
+      when :strip
+        arguments.delete("strip")
+        @command = :strip
+        command_strip
+      when :rstrip
+        arguments.delete("rstrip")
+        @command = :rstrip
+        command_rstrip
+      when :lstrip
+        arguments.delete("lstrip")
+        @command = :lstrip
+        command_lstrip
+      when :merge
+        arguments.delete("merge")
+        @command = :merge
+        command_merge
+      when :pluck
+        arguments.delete("pluck")
+        @command = :pluck
+        command_pluck
+      when :shuffle
+        arguments.delete("shuffle")
+        @command = :shuffle
+        command_shuffle
+      when :rename
+        arguments.delete("rename")
+        @command = :rename
+        command_rename
+      when :replace
+        arguments.delete("replace")
+        @command = :replace
+        command_replace
+      when :sort
+        arguments.delete("sort")
+        @command = :sort
+        command_sort
+      when :table
+        arguments.delete("table")
+        @command = :table
+        command_table
+      when :then
+        arguments.delete("then")
+        @command = :then
+        @ruby = arguments.delete_at(0)
+        command_then
+      when :times
+        arguments.delete("times")
+        @command = :times
+        command_times
+      when :uniq
+        arguments.delete("uniq")
+        @command = :uniq
+        command_uniq
+      when :write
+        arguments.delete("write")
+        @command = :write
+        command_write
+      when :release
+        arguments.delete("release")
+        @command = :release
+        command_release
+      when :top
+        arguments.delete("top")
+        @command = :top
+        command_top
+      when :tree
+        arguments.delete("tree")
+        @command = :tree
+        command_tree
+      when :format
+        arguments.delete("format")
+        @command = :format
+        command_format
+      when :pretty
+        arguments.delete("pretty")
+        @command = :pretty
+        command_pretty
       else
         arguments.delete("read")
         @command = :read
@@ -213,12 +357,217 @@ class Dorian
       end
     end
 
+    def command_pretty
+      command_format
+    end
+
+    def command_format
+      context = MiniRacer::Context.new
+      context.attach("puts", proc { |string| puts(string) })
+      context.attach("warn", proc { |string| warn(string) })
+      context.attach("read", proc { |path| File.read(path) })
+      context.attach(
+        "write",
+        proc { |path, content| File.write(path, content) }
+      )
+
+      root = File.expand_path("../../", __dir__)
+
+      prettier_path = File.join(root, "vendor/prettier/standalone.js")
+      prettier_js = File.read(prettier_path)
+      context.eval(prettier_js)
+
+      sql_path = File.join(root, "vendor/sql-formatter.js")
+      sql_js = File.read(sql_path)
+      context.eval("self = {};")
+      context.eval(sql_js)
+      context.eval("sqlFormatter = self.sqlFormatter;")
+
+      groovy_path = File.join(root, "vendor/groovy-beautify/dist/cjs/index.js")
+      groovy_js = File.read(groovy_path)
+      context.eval("module = { exports: {} };")
+      context.eval("exports = module.exports;")
+      context.eval(groovy_js)
+      context.eval("groovyBeautify = module.exports;")
+
+      plugins = %w[babel estree typescript html postcss markdown]
+
+      plugins.each do |plugin|
+        path = File.join(root, "vendor/prettier/plugins/#{plugin}.js")
+        js = File.read(path)
+        context.eval("module = { exports: {} };")
+        context.eval("exports = module.exports;")
+        context.eval(js)
+        context.eval("#{plugin} = module.exports;")
+      end
+
+      context.eval("plugins = [#{plugins.join(", ")}];")
+
+      context.eval(<<~JS)
+        format = async (path, parser) => {
+          try {
+            const before = read(path);
+            let after;
+
+            if (parser === "sql") {
+              after = sqlFormatter.format(before);
+            } else if (parser === "groovy") {
+              after = groovyBeautify(before);
+            } else {
+              after = await prettier.format(before, { parser, plugins });
+            }
+
+            if (before != after) {
+              puts(path);
+              write(path, after);
+            }
+          } catch (e) {
+            warn(`failed to parse ${path}: ${e.message.split("\\n")[0]}`);
+          }
+        };
+      JS
+
+      if files.any?
+        each(files) { |file| format(file, context:) }
+      else
+        each(
+          Git.open(".").ls_files.map(&:first)
+        ) { |file| format(file, context:) }
+      end
+    end
+
+    def command_release
+      File.delete(*Dir["*.gem"])
+      system("gem build")
+      system("gem push *.gem")
+      File.delete(*Dir["*.gem"])
+    end
+
+    def command_top
+      shell = arguments[0] || File.basename(ENV.fetch("SHELL", nil)) || "bash"
+      limit = arguments[1] || 10
+
+      history =
+        case shell.to_s.downcase
+        when "fish"
+          File
+            .read("#{Dir.home}/.local/share/fish/fish_history")
+            .lines
+            .grep(/^- cmd: /)
+            .map { |line| line.split("- cmd: ", 2).last.strip }
+        when "bash"
+          File.read("#{Dir.home}/.bash_history").lines.map(&:strip)
+        when "zsh"
+          File.read("#{Dir.home}/.zsh_history").lines.map(&:strip)
+        else
+          raise NotImplementedError, shell
+        end
+
+      table(
+        history
+          .map { |line| line.split.first }
+          .tally
+          .to_a
+          .sort_by(&:last)
+          .reverse
+          .map
+          .with_index do |(command, command_count), index|
+            {
+              "#" => index + 1,
+              :count => command_count,
+              :percent =>
+                "#{(command_count * 100 / history.size.to_f).round(3)}%",
+              :command => command
+            }
+          end
+          .first(limit)
+      )
+    end
+
+    def command_tree
+      space = "    "
+      right = "└── "
+      down = "│   "
+      down_and_right = "├── "
+
+      git_ls_files = ->(path) { Git.open(".").ls_files(path).map(&:first) }
+
+      group =
+        lambda do |files|
+          files
+            .group_by { |file| file.split("/").first }
+            .transform_values do |values|
+              group.call(
+                values
+                  .map { |value| value.split("/")[1..].join("/") }
+                  .reject(&:empty?)
+              )
+            end
+        end
+
+      print =
+        lambda do |key:, values:, index: 0, size: 1, prefix: ""|
+          key = "#{key}/" if values.any?
+          last = index + 1 == size
+          right_prefix = last ? right : down_and_right
+          puts prefix + right_prefix + key
+          values.each.with_index do |(value_key, value_values), value_index|
+            print.call(
+              key: value_key,
+              values: value_values,
+              index: value_index,
+              size: values.size,
+              prefix: prefix + (last ? space : down)
+            )
+          end
+        end
+
+      keys = (arguments + files)
+      keys = ["."] unless keys.any?
+
+      keys.each do |key|
+        files =
+          git_ls_files
+            .call(key)
+            .map { |file| parsed.arguments.any? ? file.sub(key, "") : file }
+        values = group.call(files)
+        key = "#{key}/" if values.any? && key != "." && key[-1] != "/"
+        puts key
+        values.each.with_index do |(value_key, value_values), value_index|
+          print.call(
+            key: value_key,
+            values: value_values,
+            index: value_index,
+            size: values.size
+          )
+        end
+      end
+    end
+
     def files
       parsed.files
     end
 
+    def command_times
+      map(everything, &:to_i).sum.times { |index| puts index + 1 }
+    end
+
     def command_eval
-      each(everything) { |thing| outputs(evaluates(ruby: thing).returned) }
+      each(everything) { |thing| outputs(evaluates(ruby: thing)) }
+    end
+
+    def command_then
+      each(stdin_files + files) do |input|
+        outputs(evaluates(it: reads(File.read(input))), file: input)
+      end
+
+      each(stdin_arguments + arguments) do |input|
+        outputs(evaluates(it: reads(input)))
+      end
+    end
+
+    def command_table
+      table(map(everything) { |thing| lines(reads(thing)) }.inject(&:+))
     end
 
     def command_chat
@@ -258,6 +607,39 @@ class Dorian
       puts message
     end
 
+    def command_replace
+      from, to = arguments
+
+      each(stdin_files + stdin_arguments + files) do |file|
+        next if File.directory?(file)
+
+        File.write(file, File.read(file).gsub(from, to))
+      end
+    end
+
+    def command_rename
+      from, to = arguments
+      files = stdin_files + stdin_arguments + self.files
+      (files - directories).each { |file| rename(file, file.gsub(from, to)) }
+      directories.each { |dir| rename(dir, dir.gsub(from, to)) }
+    end
+
+    def directories
+      (stdin_files + files).select { |file| File.directory?(file) }
+    end
+
+    def rename(old, new)
+      return if old == new
+
+      puts "#{old} -> #{new}"
+      File.rename(old, new)
+    end
+
+    def command_write
+      content = read_stdin.join
+      each(files + arguments) { |file| File.write(file, content) }
+    end
+
     def command_read
       each(stdin_files + files) do |input|
         outputs(reads(File.read(input)), file: input)
@@ -266,6 +648,36 @@ class Dorian
       each(stdin_arguments + arguments) { |input| outputs(reads(input)) }
     end
 
+    def command_strip
+      each(stdin_files + files) do |input|
+        outputs(lines(reads(File.read(input)), strip: :strip), file: input)
+      end
+
+      each(stdin_arguments + arguments) do |input|
+        outputs(lines(reads(input), strip: :strip))
+      end
+    end
+
+    def command_rstrip
+      each(stdin_files + files) do |input|
+        outputs(lines(reads(File.read(input)), strip: :rstrip), file: input)
+      end
+
+      each(stdin_arguments + arguments) do |input|
+        outputs(lines(reads(input), strip: :rstrip))
+      end
+    end
+
+    def command_lstrip
+      each(stdin_files + files) do |input|
+        outputs(lines(reads(File.read(input)), strip: :lstrip), file: input)
+      end
+
+      each(stdin_arguments + arguments) do |input|
+        outputs(lines(reads(input), strip: :lstrip))
+      end
+    end
+
     def everything
       read_stdin_files + stdin_arguments + read_files + arguments
     end
@@ -335,7 +747,9 @@ class Dorian
 
           homefile = "#{Dir.home}/#{file}"
           dotfile = File.expand_path("#{dir.chomp("/")}/#{file}")
-          File.delete(homefile) if File.exist?(homefile) || File.symlink?(homefile)
+          if File.exist?(homefile) || File.symlink?(homefile)
+            File.delete(homefile)
+          end
           FileUtils.mkdir_p(File.dirname(homefile))
           FileUtils.ln_s(dotfile, homefile, verbose: true)
         end
@@ -370,6 +784,43 @@ class Dorian
       end
     end
 
+    def command_merge
+      outputs(map(everything) { |thing| lines(reads(thing)) }.inject(&:+))
+    end
+
+    def command_sort
+      outputs(
+        map(everything) { |thing| lines(reads(thing)) }
+          .inject(&:+)
+          .sort_by do |line|
+            result = pluck(line).from_deep_struct
+            result.is_a?(Hash) ? result.values : result
+          end
+      )
+    end
+
+    def command_uniq
+      outputs(
+        map(everything) { |thing| lines(reads(thing)) }
+          .inject(&:+)
+          .uniq { |line| pluck(line) }
+      )
+    end
+
+    def command_pluck
+      outputs(
+        map(everything) do |thing|
+          map(lines(reads(thing))) { |line| pluck(line) }
+        end.inject(&:+)
+      )
+    end
+
+    def command_shuffle
+      outputs(
+        map(everything) { |thing| lines(reads(thing)) }.inject(&:+).shuffle
+      )
+    end
+
     def command_tally
       each(everything) do |input|
         outputs(
@@ -378,7 +829,7 @@ class Dorian
               if ruby.to_s.empty?
                 element
               else
-                evaluates(it: element, returns: true, stdout: false).returned
+                evaluates(it: element, returns: true, stdout: false)
               end
             end.tally
           )
@@ -393,11 +844,13 @@ class Dorian
     end
 
     def command_append
-      outputs(everything.sum { |input| lines(reads(input)) })
+      outputs(map(everything) { |input| lines(reads(input)) }.inject(&:+))
     end
 
     def command_prepend
-      outputs(everything.reverse.sum { |input| lines(reads(input)) })
+      outputs(
+        map(everything.reverse) { |input| lines(reads(input)) }.inject(&:+)
+      )
     end
 
     def command_select
@@ -479,20 +932,23 @@ class Dorian
 
       case output
       when :csv
-        (headers_of(content) ? headers_of(content).to_csv : "") +
+        "#{headers_of(content)&.to_csv}#{
           map(content) do |element|
             CSV.generate(headers: headers_of(content)) do |csv|
               csv << wrap(element)
             end
           end.join
+        }"
       when :json
         pretty? ? JSON.pretty_generate(content) : content.to_json
-      when :jsonl, :yamll
-        map(content, &:to_json).join("\n")
+      when :jsonl
+        "#{map(content, &:to_json).join("\n")}\n"
       when :raw
         content
       when :yaml
         content.to_yaml
+      when :yamll
+        "#{map(map(content, &:to_yaml), &:to_json).join("\n")}\n"
       else
         abort "#{output.inspect} not supported"
       end
@@ -508,12 +964,16 @@ class Dorian
         end
       when :json
         JSON.parse(content).to_deep_struct
-      when :jsonl, :yamll
+      when :jsonl
         map(content.lines) { |line| JSON.parse(line) }.to_deep_struct
       when :raw
         content
       when :yaml
         YAML.safe_load(content).to_deep_struct
+      when :yamll
+        map(content.lines) do |line|
+          YAML.safe_load(JSON.parse(line))
+        end.to_deep_struct
       else
         abort "#{input.inspect} not supported"
       end
@@ -722,9 +1182,9 @@ class Dorian
       end
     end
 
-    def lines(input)
+    def lines(input, strip: :rstrip)
       if input.is_a?(String)
-        input.lines.map(&:rstrip)
+        input.lines.map(&strip)
       elsif deep?
         deep_lines(input)
       else
@@ -827,7 +1287,7 @@ class Dorian
     end
 
     def match?(element, ruby: @ruby)
-      !!evaluates(ruby:, it: element, stdout: false, returns: true).returned
+      !!evaluates(ruby:, it: element, stdout: false, returns: true)
     end
 
     def token(file)
@@ -934,77 +1394,65 @@ class Dorian
       Tiktoken.encoding_for_model("gpt-4o")
     end
 
-    def match_filetypes?(path)
-      return true unless arguments.any?
-      return true unless arguments.intersect?(["rb", "ruby"])
-
-      ruby_extensions = %w[
-        .rb
-        .arb
-        .axlsx
-        .builder
-        .fcgi
-        .gemfile
-        .gemspec
-        .god
-        .jb
-        .jbuilder
-        .mspec
-        .opal
-        .pluginspec
-        .podspec
-        .rabl
-        .rake
-        .rbuild
-        .rbw
-        .rbx
-        .ru
-        .ruby
-        .schema
-        .spec
-        .thor
-        .watchr
-      ]
-
-      ruby_filenames = %w[
-        .irbrc
-        .pryrc
-        .simplecov
-        Appraisals
-        Berksfile
-        Brewfile
-        Buildfile
-        Capfile
-        Cheffile
-        Dangerfile
-        Deliverfile
-        Fastfile
-        Gemfile
-        Guardfile
-        Jarfile
-        Mavenfile
-        Podfile
-        Puppetfile
-        Rakefile
-        rakefile
-        Schemafile
-        Snapfile
-        Steepfile
-        Thorfile
-        Vagabondfile
-        Vagrantfile
-        buildfile
-      ]
-
+    def match_filetypes?(path, filetypes: arguments)
+      return true if filetypes.none?
+      return true unless filetypes.intersect?(%w[rb ruby])
       return false if Dir.exist?(path)
-      return true if ruby_filenames.include?(path)
-      return true if ruby_extensions.include?(File.extname(path))
+      return true if RUBY_FILENAMES.include?(path)
+      return true if RUBY_EXTENSIONS.include?(File.extname(path))
       return false unless File.exist?(path)
 
-      first_line =
-        File.open(path, &:gets).to_s.encode("UTF-8", invalid: :replace)
+      first_line = File.open(path, &:gets).to_s
+      first_line = first_line.encode("UTF-8", invalid: :replace)
 
-      /\A#!.*ruby\z/.match?(first_line)
+      return true if /\A#!.*ruby\z/.match?(first_line)
+
+      false
+    end
+
+    def pluck(element)
+      element = element.from_deep_struct
+
+      keys =
+        if arguments.any?
+          arguments
+        elsif element.is_a?(Hash)
+          element.keys
+        elsif element.is_a?(Array)
+          (0...(element.size)).map(&:to_s)
+        else
+          "it"
+        end
+
+      results =
+        keys.map do |argument|
+          if element.is_a?(Array) && argument.to_i.to_s == argument
+            element[argument.to_i]
+          elsif element.is_a?(Hash) && element.key?(argument)
+            { argument => element[argument] }
+          else
+            evaluates(ruby: argument, it: element.to_deep_struct)
+          end
+        end
+
+      if results.all?(Hash)
+        results.inject(&:merge).to_deep_struct
+      else
+        results
+          .map { |result| result.is_a?(Hash) ? result.values.first : result }
+          .to_deep_struct
+      end
+    end
+
+    def table(data)
+      is_hashes = data.first.from_deep_struct.is_a?(Hash)
+      headings = is_hashes ? data.first.to_h.keys : nil
+      rows = is_hashes ? data.map(&:values) : data.map { |row| wrap(row) }
+      if headings
+        puts Terminal::Table.new(headings:, rows:)
+      else
+        puts Terminal::Table.new(rows:)
+      end
     end
 
     def evaluates(
@@ -1028,7 +1476,219 @@ class Dorian
         rails:,
         fast:,
         returns:
-      )
+      ).returned
+    end
+
+    def sort(object)
+      object = object.from_deep_struct
+
+      if object.is_a?(Hash)
+        object
+          .to_a
+          .sort_by(&:first)
+          .to_h
+          .transform_values { |value| sort(value) }
+      elsif object.is_a?(Array)
+        object.map { |element| sort(element) }
+      else
+        object
+      end
+    end
+
+    def filetype(path)
+      ext = File.extname(path).to_s.downcase
+      return :directory if Dir.exist?(path)
+      return :symlink if File.symlink?(path)
+      return :ruby if RUBY_FILENAMES.include?(File.basename(path))
+      return :ruby if RUBY_EXTENSIONS.include?(ext)
+      return :json if ext == ".json"
+      return :jsonl if ext == ".jsonl"
+      return :yaml if ext == ".yaml"
+      return :yaml if ext == ".yml"
+      return :yamll if ext == ".yamll"
+      return :yamll if ext == ".ymll"
+      return :csv if ext == ".csv"
+      return :js if ext == ".js"
+      return :js if ext == ".mjs"
+      return :js if ext == ".cjs"
+      return :ts if ext == ".ts"
+      return :css if ext == ".css"
+      return :html if ext == ".html"
+      return :html if ext == ".htm"
+      return :haml if ext == ".haml"
+      return :slim if ext == ".slim"
+      return :erb if ext == ".erb"
+      return :fish if ext == ".fish"
+      return :sql if ext == ".sql"
+      return :tex if ext == ".tex"
+      return :md if ext == ".md"
+      return :md if ext == ".markdown"
+      return :png if ext == ".png"
+      return :jpeg if ext == ".jpg"
+      return :jpeg if ext == ".jpeg"
+      return :ico if ext == ".ico"
+      return :webp if ext == ".webp"
+      return :heic if ext == ".heic"
+      return :pdf if ext == ".pdf"
+      return :raw if ext == ".raw"
+      return :env if path == ".env"
+      return :env if path.start_with?(".env.")
+      return :sh if path == "Dockerfile"
+      return :sh if ext == ".sh"
+      return :enc if ext == ".enc"
+      return :enc if ext == ".keystore"
+      return :pro if ext == ".pro"
+      return :txt if ext == ".txt"
+      return :bat if ext == ".bat"
+      return :xcconfig if ext == ".xcconfig"
+      return :pbxproj if ext == ".pbxproj"
+      return :xml if ext == ".xml"
+      return :xml if ext == ".plist"
+      return :xml if ext == ".storyboard"
+      return :xml if ext == ".xcscheme"
+      return :xml if ext == ".xcworkspacedata"
+      return :xml if ext == ".xcprivacy"
+      return :xml if ext == ".entitlements"
+      return :kotlin if ext == ".kt"
+      return :groovy if ext == ".gradle"
+      return :groovy if ext == ".properties"
+      return :binary if ext == ".jar"
+      return :objectivec if ext == ".h"
+      return :objectivec if ext == ".mm"
+      return :objectivec if ext == ".m"
+      return unless File.exist?(path)
+
+      first_line = File.open(path, &:gets).to_s
+      first_line = first_line.encode("UTF-8", invalid: :replace).strip
+      return :ruby if first_line == "#!/usr/bin/env ruby"
+      return :sh if first_line == "#!/bin/bash"
+      return :sh if first_line == "#!/bin/sh"
+      return :sh if first_line == "#!/bin/bash -e"
+      return :sh if first_line == "#!/usr/bin/env sh"
+
+      nil
+    end
+
+    def format(path, context:)
+      return if File.symlink?(path)
+      return if File.directory?(path)
+      return unless File.exist?(path)
+
+      before = File.read(path)
+
+      case filetype(path)
+      when :ruby
+        after = SyntaxTree.format(before)
+      when :haml
+        after = SyntaxTree::Haml.format(before)
+      when :erb
+        after = SyntaxTree::ERB.format(before)
+      when :xml
+        after = SyntaxTree::XML.format(before)
+      when :json
+        after = JSON.pretty_generate(JSON.parse(before))
+      when :jsonl
+        after =
+          "#{before.lines.map { |line| JSON.parse(line).to_json }.join("\n")}\n"
+      when :csv
+        after =
+          "#{CSV.generate { |csv| CSV.parse(before).each { |row| csv << row } }}\n"
+      when :yaml
+        after = sort(YAML.safe_load(before)).to_yaml
+      when :yamll
+        after =
+          "#{
+            before
+              .lines
+              .map do |line|
+                sort(YAML.safe_load(JSON.parse(line))).to_yaml.to_json
+              end
+              .join("\n")
+          }\n"
+      when :js
+        context.eval("format(#{path.to_json}, 'babel')")
+      when :ts
+        context.eval("format(#{path.to_json}, 'typescript')")
+      when :html
+        context.eval("format(#{path.to_json}, 'html')")
+      when :md
+        context.eval("format(#{path.to_json}, 'markdown')")
+      when :sql
+        context.eval("format(#{path.to_json}, 'sql')")
+      when :groovy
+        context.eval("format(#{path.to_json}, 'groovy')")
+      when :css
+        context.eval("format(#{path.to_json}, 'css')")
+      when :sh
+        if system("command -v shfmt > /dev/null 2>&1")
+          command = ["shfmt", "--indent", "4", path].shelljoin
+          stdout, stderr, status = Open3.capture3(command)
+          raise stderr unless stderr.empty? && status.success?
+
+          after = stdout
+        else
+          warn "run: `brew install shfmt` for #{path}"
+        end
+      when :pdf
+        doc = HexaPDF::Document.open(path)
+        doc.trailer.info.each { |key, _| doc.trailer.info.delete(key) }
+        doc.write(path, update_fields: false)
+        after = File.read(path)
+      when :tex
+        if system("command -v latexindent > /dev/null 2>&1")
+          command = ["latexindent", path, "--logfile", "/dev/null"].shelljoin
+          stdout, stderr, status = Open3.capture3(command)
+          raise stderr unless stderr.empty? && status.success?
+
+          after = stdout.gsub("\t", "  ")
+        else
+          warn "run: `brew install latexindent` for #{path}"
+        end
+      when :objectivec
+        if system("command -v clang-format > /dev/null 2>&1")
+          command = ["clang-format", path].shelljoin
+          stdout, stderr, status = Open3.capture3(command)
+          raise stderr unless stderr.empty? && status.success?
+
+          after = stdout.gsub("\t", "  ")
+        else
+          warn "run: `brew install clang-format` for #{path}"
+        end
+      when :kotlin
+        if system("command -v ktlint > /dev/null 2>&1")
+          command = ["ktlint", "-F", path].shelljoin
+          stdout, stderr, status = Open3.capture3(command)
+          raise stderr unless stderr.empty? && status.success?
+
+          after = File.read(path)
+        else
+          warn "run: `brew install ktlint` for #{path}"
+        end
+      when :raw, :env, :enc, :txt, :pro, :binary, :slim, :fish, :bat, :xcconfig,
+           :pbxproj, :jpeg, :png, :webp, :heic, :ico
+        # nothing to do
+      else
+        case File.basename(path)
+        when ".gitignore", ".node-version", ".prettierignore", ".ruby-version",
+             ".tool-versions", "Gemfile.lock", "LICENSE", "VERSION", ".rspec",
+             "Procfile", "Procfile.dev", "Podfile.lock", ".xcode.env", "CNAME",
+             "TODO", ".gitmodules", ".asdfrc", "config", ".dotignore", ".gemrc",
+             ".gitconfig", ".gitmessage", ".hushlogin", ".psqlrc", ".vimrc",
+             "DIRECTORIES"
+          # nothing to do
+        when ".keep"
+          File.write(path, "")
+        else
+          puts "unhandled: #{path}"
+        end
+      end
+
+      if after && before != after
+        puts path
+        File.write(path, after)
+      end
+    rescue StandardError => e
+      warn "failed to parse #{path}: #{e.message}"
     end
   end
 end