vagrant-git-hooks 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9bcb94570bf05bac8dccbbf2014d27040d72ce2c5c9f6488c4792780fe52f234
+  data.tar.gz: fe129e89c75782fec7817804b22cdf15c984281874c8ec27fca27d39f6c8378a
+SHA512:
+  metadata.gz: cdc518ee7647648c5f13ac7e902dedeffd843af6214d71d2674644b12ef0b9624a924d2b00747b2ec9c9a90a0f3ea38ba5bbcef1ad2c62e03024df997cc1ebd2
+  data.tar.gz: 2ad7b7a2f3f43053530e1461ea9c87b33179a051a1ba9ffb6d50687d7d25f1d4993abeaea3e578f8e231cb89637104cf87176e075e05194271a6de8b4a1f885a

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## [0.2.0](https://github.com/julienpoirou/vagrant-git-hooks/compare/v0.1.0...v0.2.0) (2026-07-05)
+
+
+### Fonctionnalités ✨
+
+* Add git hooks plugin implementation and RubyDoc publishing ([59218e3](https://github.com/julienpoirou/vagrant-git-hooks/commit/59218e36a20b0a439feaf2347bb071dfeb82585f))
+
+
+### Corrections 🐛
+
+* Wire the workflow_dispatch tag input and make Publish release-safe ([f3b1a84](https://github.com/julienpoirou/vagrant-git-hooks/commit/f3b1a843c1abccef00814e6349e76d8f306455c3))
+
+## Changelog
+
+All notable changes to this project are documented in this file. The format is
+managed automatically by [release-please](https://github.com/googleapis/release-please)
+from [Conventional Commits](https://www.conventionalcommits.org/).

data/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Julien Poirou
+
+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,84 @@
+# vagrant-git-hooks
+
+🇬🇧 English · [🇫🇷 Français](./README.fr.md)
+
+Manage your project's **git hooks from the Vagrantfile** — a [husky](https://github.com/typicode/husky)
+replacement that needs **no Node/npm**, only Vagrant. Stop adding a `package.json`
+and `node_modules` to a Go/Ruby/Python repo just to lint on commit.
+
+## Why
+
+Husky is great, but it *is* a Node package. `vagrant-git-hooks` moves hook
+management into the tool you already use to describe your environment — Vagrant —
+so the only dependency is Vagrant itself. Hooks are plain POSIX shell and run on
+the host, exactly like husky's.
+
+## Install
+
+```sh
+vagrant plugin install vagrant-git-hooks
+```
+
+## Configure
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.git_hooks.hooks = {
+    "pre-commit" => "rubocop --parallel",
+    "commit-msg" => "commitlint --edit $1",
+    "pre-push"   => ["bundle exec rake spec", "echo pushed"]
+  }
+
+  # Optional: adopt one-file-per-hook scripts from a versioned directory.
+  config.git_hooks.hooks_source = "scripts/githooks"
+
+  # Defaults:
+  # config.git_hooks.install_on_up     = true   # install on `vagrant up`/provision
+  # config.git_hooks.remove_on_destroy = false  # keep hooks on `vagrant destroy`
+  # config.git_hooks.fail_on_error     = true   # inject `set -e` (a failing hook blocks the commit)
+end
+```
+
+A value can be a `String` (single line) or an `Array<String>` (several lines).
+Your `$1` / `"$@"` are passed through — git feeds the hook its own arguments.
+
+On `vagrant up` the plugin writes each hook into the repository hooks directory
+(resolved via `git rev-parse --git-path hooks`, so `core.hooksPath` and worktrees
+are honored) with a managed header:
+
+```sh
+#!/usr/bin/env sh
+# >>> vagrant-git-hooks (managed) >>>
+# Managed by Vagrant - do not edit manually (hook: pre-commit)
+set -e
+rubocop --parallel
+# <<< vagrant-git-hooks (managed) <<<
+```
+
+If a non-managed hook already exists, it is backed up to `<hook>.bak` before being
+replaced, and restored on uninstall.
+
+## CLI
+
+| Command | Description |
+|---|---|
+| `vagrant hooks install` | Install configured hooks (`--dry-run`, `--json`) |
+| `vagrant hooks uninstall` | Remove managed hooks, restore backups (`--yes`) |
+| `vagrant hooks list` | Show each hook's state: `installed` / `missing` / `modified` / `foreign` |
+| `vagrant hooks run <hook> [args]` | Run a configured hook on the host (test without committing) |
+| `vagrant hooks version` | Print the plugin version |
+| `vagrant hooks help [topic]` | Help |
+
+Global flags: `--json`, `--no-emoji`, `--lang en|fr`.
+
+## husky → vagrant-git-hooks
+
+| husky | vagrant-git-hooks |
+|---|---|
+| `npx husky init` + `.husky/<hook>` files | `config.git_hooks.hooks = { … }` in the Vagrantfile |
+| installed on `npm install` (Node) | installed on `vagrant up` (Vagrant) |
+| `package.json` + `node_modules` | nothing extra — just Vagrant |
+
+## License
+
+MIT — see [LICENSE.md](./LICENSE.md).

data/lib/vagrant-git-hooks/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/vagrant-git-hooks/command.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "json"
+require "tempfile"
+
+require_relative "helpers"
+require_relative "config"
+require_relative "service"
+require_relative "hook_builder"
+require_relative "util/git"
+require_relative "util/verbose"
+require_relative "version"
+
+module VagrantGitHooks
+  BASE_CMD = if defined?(Vagrant) && Vagrant.respond_to?(:plugin)
+               Vagrant.plugin("2", :command)
+             else
+               Class.new do
+                 def initialize(argv = [], env = {})
+                   @argv = argv || []
+                   @env  = env  || {}
+                 end
+
+                 def parse_options(parser)
+                   parser.permute!(@argv)
+                   @argv
+                 rescue OptionParser::InvalidOption
+                   nil
+                 end
+               end
+             end
+
+  class Command < BASE_CMD
+    def execute
+      UiHelpers.setup_i18n!
+      @opts = { json: false, no_emoji: false, lang: nil, yes: false, dry_run: false }
+
+      argv = parse_options(build_parser)
+      return 0 unless argv
+
+      apply_locale_and_flags
+      dispatch(argv.shift, argv)
+    end
+
+    private
+
+    def dispatch(sub, argv)
+      case sub
+      when "version"             then cmd_version
+      when nil, "", "help"       then UiHelpers.print_topic_help(argv.shift)
+                                      0
+      when "install"             then with_project { |root, cfg| do_install(root, cfg) }
+      when "uninstall", "remove" then with_project { |root, cfg| do_uninstall(root, cfg) }
+      when "list", "status"      then with_project { |root, cfg| do_list(root, cfg) }
+      when "run"                 then with_project { |root, cfg| do_run(root, cfg, argv) }
+      else
+        err("#{UiHelpers.e(:error, no_emoji: @opts[:no_emoji])} #{UiHelpers.t("errors.unknown_command")}")
+        1
+      end
+    end
+
+    def build_parser
+      OptionParser.new do |o|
+        o.banner = UiHelpers.t("usage.banner")
+        o.on("--json", "Machine-readable JSON output") { @opts[:json] = true }
+        o.on("--no-emoji", "Disable emoji in output")  { @opts[:no_emoji] = true }
+        o.on("--lang LANG", "Force language (en|fr)")  { |v| @opts[:lang] = v }
+        o.on("--dry-run", "Show what would change")    { @opts[:dry_run] = true }
+        o.on("-y", "--yes", "Auto-confirm")            { @opts[:yes] = true }
+      end
+    end
+
+    def apply_locale_and_flags
+      ENV["VGH_NO_EMOJI"] = "1" if @opts[:no_emoji]
+      return unless @opts[:lang]
+
+      begin
+        UiHelpers.set_locale!(@opts[:lang])
+      rescue UiHelpers::UnsupportedLocaleError
+        UiHelpers.set_locale!("en")
+      end
+    end
+
+    def with_project
+      root = @env.respond_to?(:root_path) ? @env.root_path : nil
+      unless root
+        err("#{UiHelpers.e(:error, no_emoji: @opts[:no_emoji])} #{UiHelpers.t("errors.no_machine")}")
+        return 1
+      end
+
+      cfg = @env.vagrantfile.config.git_hooks
+      resolve_cli_locale!(cfg)
+      yield root.to_s, cfg
+    end
+
+    def resolve_cli_locale!(cfg)
+      return if @opts[:lang]
+      return unless ENV["VGH_LANG"].to_s.strip.empty?
+      return unless cfg.respond_to?(:locale) && cfg.locale
+
+      begin
+        UiHelpers.set_locale!(cfg.locale)
+      rescue UiHelpers::UnsupportedLocaleError
+        UiHelpers.set_locale!("en")
+      end
+    end
+
+    def do_install(root, cfg)
+      return fail_not_repo("install") unless git_repo?(root)
+
+      res = Service.install!(root: root, cfg: cfg, ui: ui, dry_run: @opts[:dry_run])
+      return emit("install", "success", res) if @opts[:json]
+
+      total = res[:installed].size + res[:updated].size
+      if total.zero?
+        say("#{mark(:info)} #{UiHelpers.t("messages.no_hooks")}")
+      else
+        say("#{mark(:success)} #{UiHelpers.t("messages.installed", count: total)}")
+        unless res[:backed_up].empty?
+          say("#{mark(:info)} #{UiHelpers.t("messages.backed_up", list: res[:backed_up].join(", "))}")
+        end
+      end
+      0
+    end
+
+    def do_uninstall(root, _cfg)
+      return fail_not_repo("uninstall") unless git_repo?(root)
+
+      unless @opts[:yes]
+        return err_code("uninstall", UiHelpers.t("errors.confirmation_required")) if @opts[:json]
+
+        unless confirm?("#{mark(:question)} #{UiHelpers.t("prompts.uninstall")}")
+          return err_code("uninstall", UiHelpers.t("errors.cancelled"))
+        end
+      end
+
+      res = Service.uninstall!(root: root, ui: ui, dry_run: @opts[:dry_run])
+      return emit("uninstall", "success", res) if @opts[:json]
+
+      say("#{mark(:broom)} #{UiHelpers.t("messages.removed", count: res[:removed].size)}")
+      say("#{mark(:info)} #{UiHelpers.t("messages.restored", count: res[:restored].size)}") unless res[:restored].empty?
+      0
+    end
+
+    def do_list(root, cfg)
+      rows = Service.status(root: root, cfg: cfg)
+      return emit("list", "success", { hooks: rows }) if @opts[:json]
+
+      if rows.empty?
+        say("#{mark(:info)} #{UiHelpers.t("messages.no_hooks")}")
+        return 0
+      end
+
+      say("#{mark(:info)} #{UiHelpers.t("messages.list_header")}")
+      rows.each { |r| say(format("  • %-22s %s", r[:name], r[:state])) }
+      0
+    end
+
+    def do_run(_root, cfg, argv)
+      name = argv.shift
+      return err_code("run", UiHelpers.t("usage.run")) if name.to_s.strip.empty?
+
+      cmd = (cfg.hooks || {})[name]
+      return err_code("run", UiHelpers.t("errors.hook_not_configured", name: name)) if cmd.nil?
+
+      script = HookBuilder.script_for(name: name, commands: cmd, fail_on_error: cfg.fail_on_error)
+      Tempfile.create(["vgh-", ""]) do |f|
+        f.write(script)
+        f.flush
+        File.chmod(0o755, f.path) unless Gem.win_platform?
+        Util::Verbose.log("sh", f.path, *argv)
+        system("sh", f.path, *argv) ? 0 : 1
+      end
+    end
+
+    def cmd_version
+      return emit("version", "success", { version: VERSION }) if @opts[:json]
+
+      say("#{mark(:version)} #{UiHelpers.t("log.version_line", version: VERSION)}")
+      0
+    end
+
+    def git_repo?(root)
+      Util::Git.available? && Util::Git.repo?(root)
+    end
+
+    def fail_not_repo(action)
+      err_code(action, UiHelpers.t("errors.not_a_repo"))
+    end
+
+    def err_code(action, message)
+      return emit(action, "error", { error: message }) if @opts[:json]
+
+      err("#{mark(:error)} #{message}")
+      1
+    end
+
+    def emit(action, status, data)
+      puts JSON.generate({ action: action, status: status }.merge(data))
+      status == "success" ? 0 : 1
+    end
+
+    def mark(key)
+      UiHelpers.e(key, no_emoji: @opts[:no_emoji])
+    end
+
+    def confirm?(prompt)
+      return true if @opts[:yes]
+
+      print "#{prompt} "
+      %w[y yes o oui].include?($stdin.gets.to_s.strip.downcase)
+    end
+
+    def ui
+      @env.respond_to?(:ui) ? @env.ui : nil
+    end
+
+    def say(msg)
+      UiHelpers.say(ui, msg)
+    end
+
+    def err(msg)
+      UiHelpers.error(ui, msg)
+    end
+  end
+end

data/lib/vagrant-git-hooks/config.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module VagrantGitHooks
+  # Vagrant configuration for managed Git hooks.
+  #
+  # @!attribute hooks
+  #   @return [Hash{String=>String,Array<String>}] Hook commands keyed by hook name.
+  # @!attribute hooks_source
+  #   @return [String, nil] Directory containing hook scripts to adopt.
+  # @!attribute install_on_up
+  #   @return [Boolean] Whether hooks are installed during `vagrant up`.
+  # @!attribute remove_on_destroy
+  #   @return [Boolean] Whether managed hooks are removed during `vagrant destroy`.
+  # @!attribute fail_on_error
+  #   @return [Boolean] Whether generated hooks should stop on the first failing command.
+  class Config < Vagrant.plugin("2", :config)
+    KNOWN_HOOKS = %w[
+      applypatch-msg pre-applypatch post-applypatch
+      pre-commit pre-merge-commit prepare-commit-msg commit-msg post-commit
+      pre-rebase post-checkout post-merge pre-push pre-auto-gc
+      post-rewrite post-index-change reference-transaction fsmonitor-watchman
+      p4-changelist p4-prepare-changelist p4-post-changelist p4-pre-submit
+    ].freeze
+
+    attr_accessor :hooks, :hooks_source, :install_on_up, :remove_on_destroy,
+                  :fail_on_error, :locale, :verbose
+
+    def initialize
+      @hooks             = UNSET_VALUE
+      @hooks_source      = UNSET_VALUE
+      @install_on_up     = UNSET_VALUE
+      @remove_on_destroy = UNSET_VALUE
+      @fail_on_error     = UNSET_VALUE
+      @locale            = UNSET_VALUE
+      @verbose           = UNSET_VALUE
+    end
+
+    def finalize!
+      @hooks             = {}    if @hooks             == UNSET_VALUE
+      @hooks_source      = nil   if @hooks_source      == UNSET_VALUE
+      @install_on_up     = true  if @install_on_up     == UNSET_VALUE
+      @remove_on_destroy = false if @remove_on_destroy == UNSET_VALUE
+      @fail_on_error     = true  if @fail_on_error     == UNSET_VALUE
+      @locale            = "en"  if @locale            == UNSET_VALUE
+      @verbose           = false if @verbose           == UNSET_VALUE
+    end
+
+    def validate(_machine)
+      errors = []
+
+      validate_hooks(errors)
+
+      errors << "hooks_source must be a String path" if @hooks_source && !@hooks_source.is_a?(String)
+
+      errors << "install_on_up must be boolean" unless boolean?(@install_on_up)
+      errors << "remove_on_destroy must be boolean"  unless boolean?(@remove_on_destroy)
+      errors << "fail_on_error must be boolean"      unless boolean?(@fail_on_error)
+
+      unless @locale.is_a?(String) && %w[en fr].include?(@locale.to_s[0, 2].downcase)
+        errors << "locale must be 'en' or 'fr'"
+      end
+
+      { "vagrant-git-hooks" => errors }
+    end
+
+    private
+
+    def validate_hooks(errors)
+      unless @hooks.is_a?(Hash)
+        errors << 'hooks must be a Hash of { "hook-name" => "command" | [commands] }'
+        return
+      end
+
+      @hooks.each do |name, cmd|
+        errors << "unknown git hook: #{name}" unless KNOWN_HOOKS.include?(name.to_s)
+
+        unless cmd.is_a?(String) || (cmd.is_a?(Array) && cmd.all?(String))
+          errors << "hook '#{name}' command must be a String or Array of Strings"
+          next
+        end
+
+        blank = cmd.is_a?(String) ? cmd.strip.empty? : Array(cmd).all? { |c| c.to_s.strip.empty? }
+        errors << "hook '#{name}' command is empty" if blank
+      end
+    end
+
+    def boolean?(val)
+      [true, false].include?(val)
+    end
+  end
+end

data/lib/vagrant-git-hooks/helpers.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "i18n"
+
+module VagrantGitHooks
+  module UiHelpers
+    class MissingTranslationError < StandardError; end
+    class UnsupportedLocaleError < StandardError; end
+
+    SUPPORTED      = %i[en fr].freeze
+    OUR_NAMESPACES = %w[messages. errors. usage. help. log. emoji.].freeze
+
+    EMOJI = {
+      success: "✅",
+      info: "🔍",
+      ongoing: "🔁",
+      warning: "⚠️",
+      error: "❌",
+      version: "💾",
+      broom: "🧹",
+      question: "❓",
+      bug: "🐛"
+    }.freeze
+
+    module_function
+
+    def setup_i18n!
+      return if defined?(@i18n_setup) && @i18n_setup
+
+      ::I18n.enforce_available_locales = false
+
+      base  = File.expand_path("../../locales", __dir__)
+      paths = Dir[File.join(base, "*.yml")]
+      if paths.empty? && File.directory?(base)
+        paths = Dir.children(base).grep(/\.ya?ml\z/).map { |file| File.join(base, file) }
+      end
+      ::I18n.load_path |= paths
+      ::I18n.available_locales = SUPPORTED
+
+      default = ((ENV["VGH_LANG"] || ENV["LANG"] || "en")[0, 2] || "en").to_sym
+      ::I18n.default_locale = SUPPORTED.include?(default) ? default : :en
+
+      ::I18n.backend.load_translations
+      @i18n_setup = true
+    end
+
+    def set_locale!(lang)
+      setup_i18n!
+      sym = lang.to_s[0, 2].downcase.to_sym
+      unless SUPPORTED.include?(sym)
+        raise UnsupportedLocaleError,
+              "#{EMOJI[:error]} Unsupported language: #{sym}. Available: #{SUPPORTED.join(", ")}"
+      end
+      ::I18n.locale = sym
+      ::I18n.backend.load_translations
+    end
+
+    def setup_locale_from_config!(cfg)
+      lang = (cfg.respond_to?(:locale) ? cfg.locale : nil) || ENV.fetch("VGH_LANG", nil)
+      return unless lang
+
+      set_locale!(lang)
+    rescue UnsupportedLocaleError
+      set_locale!("en")
+    end
+
+    NS = "vgh"
+
+    def namespaced(key)
+      k = key.to_s
+      k.start_with?("#{NS}.") ? k : "#{NS}.#{k}"
+    end
+
+    def t(key, **opts)
+      setup_i18n!
+      ::I18n.t(namespaced(key), **opts)
+    end
+
+    def t_hash(key)
+      setup_i18n!
+      v = ::I18n.t(namespaced(key), default: {})
+      v.is_a?(Hash) ? v : {}
+    end
+
+    def our_key?(key)
+      OUR_NAMESPACES.any? { |ns| key.to_s.start_with?(ns) }
+    end
+
+    def e(key, no_emoji: false)
+      return "" if no_emoji || ENV["VGH_NO_EMOJI"] == "1"
+
+      EMOJI[key] || ""
+    end
+
+    def say(ui, msg)
+      ui&.info(msg) || puts(msg)
+    end
+
+    def warn(ui, msg)
+      ui&.warn(msg) || puts(msg)
+    end
+
+    def error(ui, msg)
+      ui&.error(msg) || warn(ui, msg)
+    end
+
+    def debug_enabled?
+      ENV["VGH_DEBUG"].to_s == "1"
+    end
+
+    def debug(ui, msg)
+      return unless debug_enabled?
+
+      say(ui, "#{e(:bug)} #{msg}")
+    end
+
+    def print_general_help
+      setup_i18n!
+      puts t("help.general_title")
+      t_hash("help.commands").each_value { |line| puts "  #{line}" }
+    end
+
+    def print_topic_help(topic)
+      setup_i18n!
+      topic = topic.to_s.downcase.strip
+      return print_general_help if topic.empty?
+
+      body = t("help.topic.#{topic}", default: nil)
+      body ? puts(body) : print_general_help
+    end
+  end
+end

data/lib/vagrant-git-hooks/hook_builder.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "time"
+
+module VagrantGitHooks
+  module HookBuilder
+    SHEBANG     = "#!/usr/bin/env sh"
+    BLOCK_START = "# >>> vagrant-git-hooks (managed) >>>"
+    BLOCK_STOP  = "# <<< vagrant-git-hooks (managed) <<<"
+
+    module_function
+
+    # Builds a managed Git hook script from configured shell commands.
+    #
+    # @param name [String] Git hook name.
+    # @param commands [String, Array<String>] Shell commands written to the hook body.
+    # @param fail_on_error [Boolean] Whether to include `set -e`.
+    # @param newline [String] Line separator used in the generated script.
+    # @return [String] Complete hook script.
+    def script_for(name:, commands:, fail_on_error: true, newline: "\n")
+      lines = header(name, "do not edit manually")
+      lines << "set -e" if fail_on_error
+      lines.concat(body_lines(commands))
+      lines << BLOCK_STOP
+      lines.join(newline) + newline
+    end
+
+    # Wraps an existing hook body in plugin markers.
+    #
+    # Preserves user-provided hook bodies when adopting from hooks_source, but
+    # wraps them in markers so uninstall and status can manage them later.
+    #
+    # @param name [String] Git hook name.
+    # @param content [String] Existing hook script content.
+    # @param newline [String] Line separator used in the generated script.
+    # @return [String] Managed hook script.
+    def adopt_script(name:, content:, newline: "\n")
+      lines = content.to_s.split(/\r?\n/, -1)
+      lines.pop if lines.last == ""
+
+      shebang = lines.first&.start_with?("#!") ? lines.shift : SHEBANG
+      head    = [shebang, BLOCK_START, "# Managed by Vagrant - adopted from hooks_source (hook: #{name})"]
+
+      (head + lines + [BLOCK_STOP]).join(newline) + newline
+    end
+
+    def managed?(content)
+      content.to_s.include?(BLOCK_START)
+    end
+
+    def header(name, note)
+      ts = begin
+        Time.now.utc.iso8601
+      rescue StandardError
+        Time.now.utc.to_s
+      end
+      [
+        SHEBANG,
+        BLOCK_START,
+        "# Managed by Vagrant - #{note} (hook: #{name})",
+        "# Generated: #{ts}"
+      ]
+    end
+
+    def body_lines(commands)
+      Array(commands).flat_map { |c| c.to_s.split("\n") }
+    end
+  end
+end