dip 8.2.6 → 8.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2024ed1872b11b03b134cef94a5e15bd0525f93ab6e61de7bf6cfe971b43ebd
-  data.tar.gz: 13100418400bb01c4a1843559b7349aae4468a802ed9ea0ba2536840f11a9eb8
+  metadata.gz: eae945780bd009e844b733abddfbc4529204ff443a4b112b39e13dfdc4f8e987
+  data.tar.gz: 60790bd09dda4ebda2c18a08c774b5deb9e52336c51723fa153dc034376c8806
 SHA512:
-  metadata.gz: d018d6a84f98cd8778a9672f6764ca80ffdd590738b4f3649c1176f586f2dcf8679cb365576211fb094d008410a69ff9160642354de396973392761498d694ba
-  data.tar.gz: f2eb077654301b798ef2ff43a93b610c3ddea668e437cc016c22944b8acb3a546fe259f42cd1f3366cca114c799e8c939cd670f140f8163e578c535413f5c064
+  metadata.gz: 4e881c360bfb42ef5e6e3ca150e656b0cca36adbbf171424ca4a7fc78771bd15b6572a7438aae53009a73123b541ab47af1afd873f1734263a3bfde6d400f959
+  data.tar.gz: 93fadd1ead85482d4b9b7a128cfbd5e75de0df7e2d575f9d9ba766c86a7221c4b3ec32bbb999e6041bf2418b58cade580cb3c9e9e0160d2f4dc797e139c15974

data/README.md

@@ -20,6 +20,14 @@ The dip is a CLI dev–tool that provides native-like interaction with a Dockeri
 
 [![asciicast](https://asciinema.org/a/210236.svg)](https://asciinema.org/a/210236)
 
+## Quick start with AI
+
+[dip-skill](https://github.com/kalashnikovisme/dip-skill) helps you quickly configure a `dip` environment for your project. It detects the tech stack and bootstraps `dip.yml`, compose files, and Dockerfiles.
+
+```sh
+npx skills add kalashnikovisme/dip-skill
+```
+
 ## Installation
 
 ```sh
@@ -28,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:
@@ -46,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
 
@@ -178,8 +219,16 @@ provision:
   - dip clean_cache
   - dip compose up -d pg redis
   - dip bash -c ./bin/setup
+
+preflight:
+  - ./bin/check-credentials
+  - test -f .env
 ```
 
+`preflight` is an array of shell commands that dip runs before any command that touches a running container or cluster: `dip compose ...` (and its aliases `dip up`, `dip build`, `dip stop`, `dip down`), `dip ktl ...`, and `dip run ...` (including the interaction shorthand `dip <name>`). If any command exits non-zero, dip aborts before the underlying operation runs. Useful for verifying credentials are present, required files exist, env vars are set, etc.
+
+Not triggered by `dip down --all` (cross-project teardown), `dip ssh`, `dip infra`, or `dip provision`.
+
 ### Predefined environment variables
 
 #### $DIP_OS
@@ -493,6 +542,19 @@ 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

@@ -49,7 +49,10 @@ module Dip
 
     desc "compose CMD [OPTIONS]", "Run Docker Compose commands"
     def compose(*argv)
+      require_relative "commands/preflight"
       require_relative "commands/compose"
+
+      Dip::Commands::Preflight.new.execute
       Dip::Commands::Compose.new(*argv).execute
     end
 
@@ -84,7 +87,10 @@ module Dip
 
     desc "ktl CMD [OPTIONS]", "Run kubectl commands"
     def ktl(*argv)
+      require_relative "commands/preflight"
       require_relative "commands/kubectl"
+
+      Dip::Commands::Preflight.new.execute
       Dip::Commands::Kubectl.new(*argv).execute
     end
 
@@ -96,8 +102,10 @@ module Dip
       if argv.empty? || options[:help]
         invoke :help, ["run"]
       else
+        require_relative "commands/preflight"
         require_relative "commands/run"
 
+        Dip::Commands::Preflight.new.execute
         Dip::Commands::Run.new(
           *argv,
           **options.to_h.transform_keys!(&:to_sym)
@@ -135,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/commands/preflight.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+
+module Dip
+  module Commands
+    class Preflight < Dip::Command
+      def execute
+        Dip.config.preflight.each do |command|
+          exec_subprocess(command)
+        end
+      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"
@@ -20,10 +20,11 @@ module Dip
       kubectl: {},
       infra: {},
       interaction: {},
-      provision: []
+      provision: [],
+      preflight: []
     }.freeze
 
-    TOP_LEVEL_KEYS = %i[environment compose kubectl infra interaction provision].freeze
+    TOP_LEVEL_KEYS = %i[environment compose kubectl infra interaction provision preflight].freeze
 
     ConfigKeyMissingError = Class.new(ArgumentError)
 
@@ -113,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}"
@@ -129,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
 
@@ -178,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.2.6"
+  VERSION = "8.4.0"
 end

data/schema.json

@@ -175,6 +175,16 @@
         ]
       ]
     },
+    "preflight": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Shell commands to run before any `dip compose` subcommand. A non-zero exit aborts the command.",
+      "examples": [
+        ["./bin/check-credentials", "test -f .env"]
+      ]
+    },
     "environment": {
       "$ref": "#/definitions/environment_vars"
     },

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dip
 version: !ruby/object:Gem::Version
-  version: 8.2.6
+  version: 8.4.0
 platform: ruby
 authors:
 - bibendi
@@ -231,6 +231,7 @@ files:
 - lib/dip/commands/infra/service.rb
 - lib/dip/commands/kubectl.rb
 - lib/dip/commands/list.rb
+- lib/dip/commands/preflight.rb
 - lib/dip/commands/provision.rb
 - lib/dip/commands/run.rb
 - lib/dip/commands/runners/base.rb