dip 8.3.0 → 8.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1251c437797a56125f593a350dde6c3709f70936a6cc274949d0b2b58dd814f
-  data.tar.gz: d1e4d3484bdc41ed6281d14a7ce324146cd1768989c3e3f3fa09fc412d72bf2d
+  metadata.gz: eae945780bd009e844b733abddfbc4529204ff443a4b112b39e13dfdc4f8e987
+  data.tar.gz: 60790bd09dda4ebda2c18a08c774b5deb9e52336c51723fa153dc034376c8806
 SHA512:
-  metadata.gz: 1dafa2c574e88f414a498ed0e3cbeaab047085ee0232977fcf1900ef92637c333cab39dc9d9ae1e5eaf93843949e3bd62a9c61f23f46ba83711cd0aecf83412c
-  data.tar.gz: 3ce49864159703c73ac8811a5a9f8d295192f3dc0be569a7d6708a5084013a2464de89b67cb1982edd888dec7284d44761959b85fa02b62e23b95547b5ef70fc
+  metadata.gz: 4e881c360bfb42ef5e6e3ca150e656b0cca36adbbf171424ca4a7fc78771bd15b6572a7438aae53009a73123b541ab47af1afd873f1734263a3bfde6d400f959
+  data.tar.gz: 93fadd1ead85482d4b9b7a128cfbd5e75de0df7e2d575f9d9ba766c86a7221c4b3ec32bbb999e6041bf2418b58cade580cb3c9e9e0160d2f4dc797e139c15974

data/README.md

@@ -36,12 +36,34 @@ gem install dip
 
 ### Integration with shell
 
-Dip can be injected into the current shell (ZSH or Bash).
+Dip can be injected into the current shell so that interaction commands (and `compose`, `up`, `stop`, `down`, `build`, `provision`) become available without the `dip` prefix. **Bash**, **ZSH**, and **Fish** are supported.
+
+Add the matching line to your shell startup file so the integration is loaded in every session:
+
+```sh
+# Bash — ~/.bashrc or ~/.bash_profile
+eval "$(dip console)"
+```
 
 ```sh
+# ZSH — ~/.zshrc
 eval "$(dip console)"
 ```
 
+```fish
+# Fish — ~/.config/fish/config.fish
+dip console | source
+```
+
+The target shell is autodetected from the `$SHELL` environment variable, so the snippets above work as-is. If autodetection is wrong (for example, you run Fish but `$SHELL` still points to Bash), force the dialect explicitly:
+
+```sh
+eval "$(dip console --shell zsh)"     # Bash / ZSH
+dip console --shell fish | source     # Fish
+```
+
+`--shell` accepts `bash`, `zsh`, or `fish` (`bash` and `zsh` produce the same POSIX output).
+
 **IMPORTANT**: Beware of possible collisions with local tools. One particular example is supporting both local and Docker frontend build tools, such as Yarn. If you want some developer to run `yarn` locally and other to use Docker for that, you should either avoid adding the `yarn` command to the `dip.yml` or avoid using the shell integration for hybrid development.
 
 After that we can type commands without `dip` prefix. For example:
@@ -54,16 +76,27 @@ ktl *any-kubectl-arg
 provision
 ```
 
-When we change the current directory, all shell aliases will be automatically removed. But when we enter back into a directory with a `dip.yml` file, then shell aliases will be renewed.
+When we change the current directory, all shell aliases are automatically removed. When we enter a directory that has a `dip.yml` file (in it or in a parent), the aliases are renewed. This is wired through the shell's directory-change hook — `chpwd_functions` on ZSH, a `cd`/`pushd`/`popd` wrapper on Bash, and a `--on-variable PWD` handler on Fish. The hook resolves the applicable `dip.yml` itself (no `dip` process involved) and only actually reloads when that path changes, so `cd`ing around inside the same project doesn't re-run `dip` on every prompt.
 
-Also, in shell mode Dip is trying to determine manually passed environment variables. For example:
+Also, in shell mode Dip tries to determine manually passed environment variables. For example:
 
 ```sh
 VERSION=20180515103400 rails db:migrate:down
 ```
 
-You could add this `eval` at the end of your `~/.zshrc`, or `~/.bashrc`, or `~/.bash_profile`.
-After that, it will be automatically applied when you open your preferred terminal.
+Once the startup snippet is in place, the integration is applied automatically every time you open your terminal.
+
+#### How it works
+
+`dip console` prints a bootstrap script that defines three helpers:
+
+- `dip_inject` — evaluates `dip console inject`, which emits one shell function per interaction command plus the built-in `compose`/`up`/`stop`/`down`/`build`/`provision` wrappers. An interaction command whose name collides with a shell builtin/keyword (`jobs`, `test`, `read`, `set`, …) is skipped, with a warning on stderr — run it as `dip <name>` instead, or rename it.
+- `dip_clear` — removes the functions previously injected (regenerated on every inject so it always matches the current `dip.yml`).
+- `dip_reload` — runs `dip_clear` then `dip_inject`; also bound to the directory-change hook, which calls it only when the resolved `dip.yml` path actually changed.
+
+The bootstrap also exports `DIP_SHELL=1`, `DIP_EARLY_ENVS` (the list of variables present at load time, used to detect manually passed env vars), and `DIP_PROMPT_TEXT` (`ⅆ`). On ZSH with the `agnoster` theme, `DIP_PROMPT_TEXT` is added as a prompt segment; other shells and themes are left untouched.
+
+You can force a reload at any time by running `dip_reload` (useful after editing `dip.yml`).
 
 ## Usage
 
@@ -508,6 +541,20 @@ If validation fails, you'll get detailed error messages indicating what needs to
 You can skip validation by setting `DIP_SKIP_VALIDATION` environment variable.
 
 Add `# yaml-language-server: $schema=https://raw.githubusercontent.com/bibendi/dip/refs/heads/master/schema.json` to the top of your dip.yml to get schema validation in VSCode. Read more about [YAML Language Server](https://github.com/redhat-developer/vscode-yaml?tab=readme-ov-file#associating-schemas).
+
+### dip console
+
+Prints the shell integration script for the current shell. See [Integration with shell](#integration-with-shell) for the full setup.
+
+```sh
+dip console [--shell bash|zsh|fish]          # bootstrap script (default subcommand)
+dip console inject [--shell bash|zsh|fish]   # just the command aliases
+```
+
+- `--shell` (`-s`) selects the dialect: `bash`, `zsh`, or `fish`. When omitted, it is autodetected from `$SHELL`, falling back to POSIX (Bash/ZSH) output.
+- `dip console` is meant to be evaluated by your shell: `eval "$(dip console)"` for Bash/ZSH, `dip console | source` for Fish.
+- `dip console inject` is called internally by the bootstrap script (via `dip_reload`); you normally don't run it by hand. It only needs the interaction command names, so it skips full `dip.yml` schema validation — run `dip validate` (or any other `dip` command) to check the file against the schema.
+
 ## Changelog
 
 See [CHANGELOG.md](CHANGELOG.md).

data/lib/dip/cli/console.rb

@@ -7,14 +7,21 @@ require_relative "../commands/console"
 module Dip
   class CLI
     class Console < Base
+      SHELL_OPTION = [
+        :shell,
+        {aliases: "-s", type: :string, enum: %w[bash zsh fish posix],
+         desc: "Target shell dialect (autodetected from $SHELL by default)"}
+      ].freeze
+
       desc "start", "Integrate Dip into current shell"
       method_option :help, aliases: "-h", type: :boolean,
         desc: "Display usage information"
+      method_option(*SHELL_OPTION)
       def start
         if options[:help]
           invoke :help, ["start"]
         else
-          Dip::Commands::Console::Start.new.execute
+          Dip::Commands::Console::Start.new(shell: options[:shell]).execute
         end
       end
 
@@ -23,11 +30,12 @@ module Dip
       desc "inject", "Inject aliases"
       method_option :help, aliases: "-h", type: :boolean,
         desc: "Display usage information"
+      method_option(*SHELL_OPTION)
       def inject
         if options[:help]
           invoke :help, ["inject"]
         else
-          Dip::Commands::Console::Inject.new.execute
+          Dip::Commands::Console::Inject.new(shell: options[:shell]).execute
         end
       end
     end

data/lib/dip/cli.rb

@@ -143,7 +143,7 @@ module Dip
     subcommand :infra, Dip::CLI::Infra
 
     require_relative "cli/console"
-    desc "console", "Integrate Dip commands into shell (only ZSH and Bash are supported)"
+    desc "console", "Integrate Dip commands into shell (Bash, ZSH and Fish are supported)"
     subcommand :console, Dip::CLI::Console
   end
 end

data/lib/dip/commands/console.rb

@@ -5,14 +5,50 @@ require_relative "../command"
 module Dip
   module Commands
     module Console
+      # Interaction command names come straight from `dip.yml`, and `inject`
+      # turns each one into a same-named shell function. A name that collides
+      # with a shell builtin/keyword silently shadows it for the rest of the
+      # session — e.g. an interaction called `jobs` breaks `jobs`, which
+      # things like Starship's prompt call on every render, turning every
+      # keystroke into a `dip jobs` invocation. Skip those instead of
+      # aliasing over them.
+      RESERVED_NAMES = %w[
+        cd pwd test read set jobs type command builtin history alias unalias
+        source eval exec exit return break continue trap kill wait bg fg
+        export unset declare typeset readonly local shift times true false
+        echo printf time status functions function end
+      ].freeze
+
+      # Figure out which shell dialect to generate integration code for.
+      #
+      # An explicit value (from `--shell`) always wins. Otherwise we guess from
+      # the `$SHELL` environment variable and fall back to the POSIX flavour
+      # (bash/zsh) which was the only supported one historically.
+      def self.detect_shell(explicit = nil)
+        name = (explicit || File.basename(ENV["SHELL"].to_s)).to_s.downcase
+        name.include?("fish") ? :fish : :posix
+      end
+
       class Start < Dip::Command
+        def initialize(shell: nil)
+          @shell = Console.detect_shell(shell)
+        end
+
         def execute
-          puts script
+          puts fish? ? fish_script : posix_script
         end
 
         private
 
-        def script
+        def fish?
+          @shell == :fish
+        end
+
+        def inject_command
+          "#{Dip.bin_path} console inject --shell #{@shell}"
+        end
+
+        def posix_script
           <<-SH.gsub(/^ {12}/, "")
             export DIP_SHELL=1
             export DIP_EARLY_ENVS=#{ENV.keys.join(",")}
@@ -24,7 +60,7 @@ module Dip
             }
 
             function dip_inject() {
-              eval "$(#{Dip.bin_path} console inject)"
+              eval "$(#{inject_command})"
             }
 
             function dip_reload() {
@@ -32,6 +68,36 @@ module Dip
               dip_inject
             }
 
+            # Resolves the dip.yml that applies to $PWD (or $DIP_FILE), without
+            # spawning a `dip` process — used to skip redundant reloads below.
+            function __dip_config_path() {
+              if [ -n "${DIP_FILE:-}" ]; then
+                printf '%s\\n' "$DIP_FILE"
+                return
+              fi
+
+              \\typeset __dip_dir="$PWD"
+              while :; do
+                if [ -e "$__dip_dir/dip.yml" ]; then
+                  printf '%s\\n' "$__dip_dir/dip.yml"
+                  return
+                fi
+                [ "$__dip_dir" = "/" ] && return
+                __dip_dir=$(dirname "$__dip_dir")
+              done
+            }
+
+            # Only reload aliases on `cd` when the resolved dip.yml actually
+            # changed — most `cd`s stay within the same project and would
+            # otherwise re-spawn `dip` (Ruby boot + schema validation) for nothing.
+            function __dip_auto_reload() {
+              \\typeset __dip_new_config_path
+              __dip_new_config_path="$(__dip_config_path)"
+              [ "$__dip_new_config_path" = "${__DIP_CONFIG_PATH:-}" ] && return
+              __DIP_CONFIG_PATH="$__dip_new_config_path"
+              dip_reload
+            }
+
             # Inspired by RVM
             function __zsh_like_cd() {
               \\typeset __zsh_like_cd_hook
@@ -58,7 +124,7 @@ module Dip
             }
 
             export -a chpwd_functions
-            [[ " ${chpwd_functions[*]} " == *" dip_reload "* ]] || chpwd_functions+=(dip_reload)
+            [[ " ${chpwd_functions[*]} " == *" __dip_auto_reload "* ]] || chpwd_functions+=(__dip_auto_reload)
 
             if [[ "$ZSH_THEME" = "agnoster" ]]; then
               eval "`declare -f prompt_end | sed '1s/.*/_&/'`"
@@ -73,22 +139,87 @@ module Dip
             fi
 
             dip_reload
+            __DIP_CONFIG_PATH="$(__dip_config_path)"
           SH
         end
+
+        def fish_script
+          <<-FISH.gsub(/^ {12}/, "")
+            set -gx DIP_SHELL 1
+            set -gx DIP_EARLY_ENVS "#{ENV.keys.join(",")}"
+            set -gx DIP_PROMPT_TEXT "ⅆ"
+
+            function dip_clear
+              # just stub, will be redefined after injecting aliases
+              true
+            end
+
+            function dip_inject
+              #{inject_command} | source
+            end
+
+            function dip_reload
+              dip_clear
+              dip_inject
+            end
+
+            # Resolves the dip.yml that applies to $PWD (or $DIP_FILE), without
+            # spawning a `dip` process — used to skip redundant reloads below.
+            function __dip_config_path
+              if set -q DIP_FILE
+                echo "$DIP_FILE"
+                return
+              end
+
+              set -l __dip_dir "$PWD"
+              while true
+                if test -e "$__dip_dir/dip.yml"
+                  echo "$__dip_dir/dip.yml"
+                  return
+                end
+                if test "$__dip_dir" = "/"
+                  return
+                end
+                set __dip_dir (dirname "$__dip_dir")
+              end
+            end
+
+            # Renew aliases whenever the working directory changes — but only
+            # when the resolved dip.yml actually changed. Most `cd`s stay within
+            # the same project and would otherwise re-spawn `dip` (Ruby boot +
+            # schema validation) for nothing.
+            function __dip_chpwd --on-variable PWD
+              set -l __dip_new_config_path (__dip_config_path)
+              if test "$__dip_new_config_path" != "$__dip_config_path_cache"
+                set -g __dip_config_path_cache "$__dip_new_config_path"
+                dip_reload
+              end
+            end
+
+            dip_reload
+            set -g __dip_config_path_cache (__dip_config_path)
+          FISH
+        end
       end
 
       class Inject < Dip::Command
         attr_reader :out, :aliases
 
-        def initialize
+        def initialize(shell: nil)
+          @shell = Console.detect_shell(shell)
           @aliases = []
           @out = []
         end
 
         def execute
-          if Dip.config.exist?
-            add_aliases(*Dip.config.interaction.keys) if Dip.config.interaction
-            add_aliases("compose", "up", "stop", "down", "provision", "build")
+          # Runs on every automatic shell reload (e.g. on `cd`), so it only needs
+          # the interaction command names, not full schema conformance — skip the
+          # `json-schema` require and validation pass that every other command pays.
+          with_validation_skipped do
+            if Dip.config.exist?
+              add_aliases(*Dip.config.interaction.keys) if Dip.config.interaction
+              add_aliases("compose", "up", "stop", "down", "provision", "build")
+            end
           end
 
           clear_aliases
@@ -98,17 +229,49 @@ module Dip
 
         private
 
+        def with_validation_skipped
+          had_key = ENV.key?("DIP_SKIP_VALIDATION")
+          previous = ENV["DIP_SKIP_VALIDATION"]
+          ENV["DIP_SKIP_VALIDATION"] = "1"
+          yield
+        ensure
+          if had_key
+            ENV["DIP_SKIP_VALIDATION"] = previous
+          else
+            ENV.delete("DIP_SKIP_VALIDATION")
+          end
+        end
+
+        def fish?
+          @shell == :fish
+        end
+
         def add_aliases(*names)
           names.each do |name|
+            if Console::RESERVED_NAMES.include?(name.to_s)
+              warn "dip: skipping alias `#{name}` — it would shadow the `#{name}` shell builtin. " \
+                "Run it as `#{Dip.bin_path} #{name}`, or rename it in dip.yml."
+              next
+            end
+
             aliases << name
-            out << "function #{name}() { #{Dip.bin_path} #{name} $@; }"
+            out << if fish?
+              "function #{name}; #{Dip.bin_path} #{name} $argv; end"
+            else
+              "function #{name}() { #{Dip.bin_path} #{name} $@; }"
+            end
           end
         end
 
         def clear_aliases
-          out << "function dip_clear() { \n" \
-                  "#{aliases.any? ? aliases.map { |a| "  unset -f #{a}" }.join("\n") : "true"} " \
-                  "\n}"
+          out << if fish?
+            body = aliases.any? ? "functions -e #{aliases.join(" ")}" : "true"
+            "function dip_clear; #{body}; end"
+          else
+            "function dip_clear() { \n" \
+              "#{aliases.any? ? aliases.map { |a| "  unset -f #{a}" }.join("\n") : "true"} " \
+              "\n}"
+          end
         end
       end
     end

data/lib/dip/config.rb

@@ -3,7 +3,7 @@
 require "yaml"
 require "erb"
 require "pathname"
-require "json-schema"
+require "json"
 
 require "dip/version"
 require "dip/ext/hash"
@@ -114,15 +114,22 @@ module Dip
       end
     end
 
-    def validate
+    # `data`, when given, is the already-parsed raw config (as produced by
+    # `load_yaml`) so callers that parsed the file themselves don't pay for
+    # parsing it a second time here.
+    def validate(data = nil)
       raise Dip::Error, "Config file path is not set" if file_path.nil?
       raise Dip::Error, "Config file not found: #{file_path}" unless File.exist?(file_path)
 
       schema_path = File.join(File.dirname(__FILE__), "../../schema.json")
       raise Dip::Error, "Schema file not found: #{schema_path}" unless File.exist?(schema_path)
 
-      data = self.class.load_yaml(file_path)
-      schema = JSON::Validator.parse(File.read(schema_path))
+      require "json-schema"
+
+      data ||= self.class.load_yaml(file_path)
+      # Parse with the stdlib rather than JSON::Validator.parse: the latter passes
+      # `quirks_mode:` to JSON.parse, which the json gem removed in 3.0 (Ruby 3.5+).
+      schema = JSON.parse(File.read(schema_path))
       JSON::Validator.validate!(schema, data)
     rescue Psych::SyntaxError => e
       raise Dip::Error, "Invalid YAML syntax in config file: #{e.message}"
@@ -130,7 +137,7 @@ module Dip
       data_display = data ? data.to_yaml.gsub("\n", "\n  ") : "nil"
       error_message = "Schema validation failed: #{e.message}\nInput data:\n  #{data_display}"
       raise Dip::Error, error_message
-    rescue JSON::Schema::JsonParseError => e
+    rescue JSON::Schema::JsonParseError, JSON::ParserError => e
       raise Dip::Error, "Error parsing schema file: #{e.message}"
     end
 
@@ -179,7 +186,7 @@ module Dip
       @config = CONFIG_DEFAULTS.merge(base_config)
 
       unless ENV.key?("DIP_SKIP_VALIDATION")
-        validate
+        validate(config)
       end
 
       @config

data/lib/dip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dip
-  VERSION = "8.3.0"
+  VERSION = "8.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dip
 version: !ruby/object:Gem::Version
-  version: 8.3.0
+  version: 8.4.0
 platform: ruby
 authors:
 - bibendi