jade_systems_toolbox 0.1.4 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bb1d901493c286300b53d74441705dc7402263497e998f5490ca14beac572a5
-  data.tar.gz: bc12fcce57604c61fe617eac640c3ab38e6204da916e73124162df78c519e803
+  metadata.gz: 6e5e58dc71de22b037aab057b8a9205361a239590b6b844f438b59fdd771441f
+  data.tar.gz: 1b6a2766065ad815318eb62d463c3d5113ac3ed4b6e293c6aa883f6b3e174845
 SHA512:
-  metadata.gz: 58b7e44b6210955e1b50fc2601cc018a2434c92c105436bf923ab818577448c8f11cc90ed81128bfa6290c86f455b6aeb4e444682d4966ebc04c7cab1f382c37
-  data.tar.gz: 91636de5259a810060040aa51d3cc0fc1bb914358c679e2dc12dad59e639dafcbf3869a0a1f6886228e302154596195503315c92f9ed567cd6394ca708c1d2b1
+  metadata.gz: 257d930928d5186d49415b1cc25b28122e5dada2753610ef3346ef39aa6174b01c89a43dfa567464caca71ea0c23982d9bb876e544e1fd4ae2fed4c4b29548e7
+  data.tar.gz: 51ea308a86ef16a12d8d2cb43dbe300558e3b97ed4aa0fe009834ad6c226121c58cc3e287639132f425f0d50ae2da3b907b9698349e9ec9775df551dd9eb28b6

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 3.2
+  TargetRubyVersion: 3.3
 
 # Omakase Ruby styling for Rails
 inherit_gem:

data/.vscode/settings.json

@@ -66,5 +66,6 @@
   "files.trimTrailingWhitespace": true,
   "[sql]": {
     "editor.defaultFormatter": "adpyke.vscode-sql-formatter"
-  }
+  },
+  "window.title": "jade_systems_toolbox"
 }

data/README.md

@@ -3,7 +3,7 @@
 This gem installs a program to help do container-based development. It provides functions to:
 
 * Prepare a directory for development in containers, including some files to configure VScode.
-* Bring up the container(s).
+* Start the container(s).
 * Open VScode on the code in the container.
 * Open a browser window on the application-under-development's web server.
 * Open a terminal session on the application container.
@@ -29,19 +29,21 @@ gem install --user-install jade_systems_toolbox
 
 ```terminal
 Commands:
-  tool down                   # docker compose down. Deletes the container. You probably want stop.
+  tool down -- [COMPOSE_ARGS] # docker compose down. Deletes the container. You probably want stop.
   tool edit                   # devcontainer open
+  tool exec COMMAND [ARGS]    # Run a command in the container and exit
   tool help [COMMAND]         # Describe available commands or one specific command
   tool init                   # Initialize compose files and devcontainer.json
   tool initialize_docker      # Initialize compose files
-  tool initilize_vscode       # Initialize devcontainer.json for vscode
-  tool open                   # Open a page on the services's first port
+  tool initialize_vscode      # Initialize devcontainer.json for vscode
+  tool open                   # Open a page on the services's first port or specified port
   tool port [CONTAINER_PORT]  # Get the host port for the CONTAINER_PORT's container port CONTAINER_PORT
   tool ports                  # Get the host ports for the container ports defined in `compose.yml`
   tool server [COMMAND]       # Run the server in the container
+  tool start [COMPOSE_ARGS]   # docker compose up -d (aliased as `up`)
   tool stop                   # Stop the service(s) but preserve the container(s)
   tool terminal               # Run a shell in the container
-  tool up                     # docker compose up -d
+  tool tree                   # Print a tree of all available commands
   tool version                # Show the version number of the tool.
 
 Options:
@@ -56,7 +58,7 @@ The broad steps to start a brand new project are:
 1. Create a directory for the project, and change directory into the new directory.
 1. Decide which container(s) you want to use.
 1. Initialize the container(s).
-1. Bring up the container(s).
+1. Start the container(s).
 1. Open a terminal session and create the application (e.g. `rails new` if you're doing a Rails project.)
 1. Run the editor and otherwise do what you need to do to create your project.
 1. When the web server is ready to run (if you're developing a web app), run the server.
@@ -83,7 +85,9 @@ tool init
 
 The initialization installs
 
-* A `compose.yml` file for Rails development with a SQLite database, using Ruby 3.4, and the `bookworm` version of Debian.
+* A `compose.yml` file for Rails development with a SQLite database, using the latest released version of Ruby,
+and the latest stable version of Debian.
+(Give or take. We don't track the releases so closely. Raise and issue if you need an upgrade.)
 * On Linux, a `compose.override.yml` file.
 * A `.devcontainer.json` file, so VScode can edit without the context of the container.
 * `.vscode/settings.json` and `vscode/extensions.json` so developers have a consistent experience in VScode (mostly linting and autoformatting).
@@ -102,19 +106,37 @@ To choose a different ruby version and Debian version:
 tool init --ruby-version 3.2 --distro-version bullseye
 ```
 
+A fairly common variant is to get a `compose.yml` that also has a Playwright container:
+
+```bash
+tool init --end-to-end-tool playwright
+```
+
+This retrieves the compose file, and puts it in your local `compose.yml`.
+
 You can choose a currently supported Ruby version, and a Debian version that supports that Ruby version, from the containers built by https://github.com/lcreid/docker.
 
-You're free to modify the `compose.yml` (and `compose.override.yml` on Linux). If you run `tool init` again, it will over-write your changes.
+You're free to modify the `compose.yml` (and `compose.override.yml` on Linux). Note that if you run `tool init` again, it will over-write your changes.
 
 #### Start the Containers
 
 ```bash
-tool up
+tool start
 ```
 
 This takes a while to run, the first time you run it when the image isn't already downloaded to your computer.
 
-### Open a Terminal Session
+You can add additional Docker Compose arguments to the command line. For example:
+
+```bash
+tool start --remove-orphans
+```
+
+If any of the Docker Compose arguments are the same as any of `tool`'s arguments,
+separate the `start` command from the rest of the command line with `--`,
+like this: `tool start -- -v`.
+
+#### Open a Terminal Session
 
 ```bash
 tool terminal
@@ -126,6 +148,14 @@ This connects to the `web` service defined in the `compose.yml` file. If you wan
 tool terminal --service mysql
 ```
 
+Set some environment variables in the container (the `docker compose --env` flag):
+
+```bash
+tool terminal -e RAILS_ENV=test
+```
+
+`tool terminal` supports the `--mapping` argument as described under [Run the Server](run-the-server).
+
 #### Start VScode
 
 ```bash
@@ -138,10 +168,22 @@ tool edit
 tool server
 ```
 
+By default, the container has environment variables set for port mapping.
+The container environment will have variables named `HOST_PORT_xxxx`,
+and `xxxx` is the container port (e.g. 3000).
+The _value_ of each environment variable
+is the host's port number that the container port is mapped to.
+
+If you don't want the mapping, you can turn it off:
+
+```bash
+tool server --no-mapping
+```
+
 This runs `bin/dev`. To run something else, e.g. a bare Puma so you can debug it:
 
 ```bash
-tool server "bin/rails s -b 0.0.0.0"
+tool server bin/rails s -b 0.0.0.0
 ```
 
 If you have other services running servers, or the server is in a sub-directory of your project:
@@ -152,6 +194,8 @@ tool server --work-dir test/app --service monitor
 
 To terminate the server, type Control-C.
 
+`tool server` supports the `--env` argument as described under [Open a Terminal Session](open-a-terminal-session).
+
 #### Open a Browser Window
 
 To connect to the server running on service `web` on port 3000:
@@ -184,6 +228,33 @@ tool open --path letter_opener
 tool stop
 ```
 
+You can add additional Docker Compose arguments to the command line. For example:
+
+```bash
+tool stop --remove-orphans
+```
+
+If any of the Docker Compose arguments are the same as any of `tool`'s arguments,
+separate the `exec` command from the rest of the command line with `--`,
+like this: `tool stop -- -v`.
+
+#### Run a Single Command in a Container
+
+```bash
+tool exec ls -l ..
+```
+
+Some things to watch for:
+
+- If any of the Docker Compose arguments are the same as any of `tool`'s arguments,
+separate the `exec` command from the rest of the command line with `--`,
+like this: `tool exec -- ls -l -t ..`.
+- The shell on the host processes the command line,
+so you need to quote or escape the command if you want variable expansion
+and other shell features to happen in the container.
+For example: `tool exec ls -l '$HOME'` to show the home directory in the container, not your home directory
+(which probably doesn't exist in the container).
+
 #### Bring Down the Containers
 
 This destroys the containers, which will likely destroy all your gems.
@@ -192,6 +263,16 @@ This destroys the containers, which will likely destroy all your gems.
 tool down
 ```
 
+You can add additional Docker Compose arguments to the command line. For example: NOTE THAT THE FOLLOWING COMMAND IS VERY DESTRUCTIVE. It destroys the volume where you might have your development and test databases, or other important data:
+
+```bash
+tool down --volumes --remove-orphans
+```
+
+If any of the Docker Compose arguments are the same as any of `tool`'s arguments,
+separate the `exec` command from the rest of the command line with `--`,
+like this: `tool down -- -v`.
+
 Skip the confirmation mesage with:
 
 ```bash
@@ -214,7 +295,7 @@ To run in another directory, use the path from the directory you're in, to the d
 ruby -I ../jade_systems_toolbox/lib ../jade_systems_toolbox/exe/tool [COMMAND]
 ```
 
-To install this gem onto your local machine, build it: `gem build jade_systems_toolbox.gemspec`, and install it: `gem install -l jade_systems_toolbox-0.1.4.gem`. (Change the version number to match the current version number.)
+To install this gem onto your local machine, build it: `gem build jade_systems_toolbox.gemspec`, and install it: `gem install -l jade_systems_toolbox-0.2.0.gem`. (Change the version number to match the current version number.)
 
 ## Release
 

data/lib/jade_systems_toolbox/cli.rb

@@ -2,10 +2,10 @@
 
 module JadeSystemsToolbox
   class Cli < Thor
-    # This and other improvements from Matt: https://mattbrictson.com/blog/fixing-thor-cli-behavior
-    check_unknown_options!
+    stop_on_unknown_option! :down
 
     class << self
+      # This and other improvements from Matt: https://mattbrictson.com/blog/fixing-thor-cli-behavior
       def exit_on_failure? = true
     end
 
@@ -14,13 +14,13 @@ module JadeSystemsToolbox
 
     class_option :verbose, type: :boolean, default: false, aliases: "-v"
 
-    desc "down", "docker compose down. Deletes the container. You probably want stop."
+    desc "down -- [COMPOSE_ARGS]", "docker compose down. Deletes the container. You probably want stop."
     option :force, default: "n", aliases: "-f"
-    def down
-      force = ask("tool down destroys the containers. Are you sure?").downcase unless options[:force] == "y"
+    def down(*compose_args)
+      force = ask("tool down destroys the containers. Are you sure [y/N]?").downcase unless options[:force] == "y"
       exit(1) if force[0] != "y"
 
-      system("docker compose down")
+      system(([ "docker compose down" ] + compose_args).join(" "))
     end
 
     desc "edit", "devcontainer open"
@@ -28,57 +28,64 @@ module JadeSystemsToolbox
       `devcontainer open`
     end
 
+    desc "exec COMMAND [ARGS]", "Run a command in the container and exit"
+    option :env, repeatable: true, default: [], aliases: "-e", banner: "VAR=value"
+    option :mapping, type: :boolean, default: true, aliases: "-m"
+    option :service, default: "web", aliases: "-s"
+    option :work_dir, aliases: "-w"
+    def exec(command_for_container, *args)
+      service = options[:service]
+      workdir = "-w #{options[:work_dir]} " unless options[:work_dir].nil?
+      environment_variables = options[:env].map { "-e #{_1}" }.join(" ")
+      port_map_environment_variables = port_map_for_environment(service) if options[:mapping]
+      shell_command = [ command_for_container, *args ].join(" ")
+      command = [
+        "docker compose exec",
+        environment_variables,
+        port_map_environment_variables,
+        workdir,
+        "-it",
+        service,
+        "sh -c",
+        "'#{shell_command}'",
+      ].compact.join(" ")
+
+      system(command)
+    end
+
     desc "init", "Initialize compose files and devcontainer.json"
-    option :compose_file, default: "compose.yml"
     option :database, default: "sqlite", aliases: "-d"
-    option :ruby_version, default: "3.4", aliases: "-r"
-    option :distro_version, default: "bookworm", aliases: "-t" # For Toy Story.
+    option :ruby_version, default: "4.0", aliases: "-r"
+    option :distro_version, default: "trixie", aliases: "-t" # For Toy Story.
     def init
       invoke :initialize_docker
       invoke :initialize_vscode, [], {}
     end
 
     desc "initialize_docker", "Initialize compose files"
-    option :compose_file, default: "compose.yml"
     option :database, default: "sqlite", aliases: "-d"
-    option :ruby_version, default: "3.4", aliases: "-r"
-    option :distro_version, default: "bookworm", aliases: "-t" # For Toy Story.
+    option :ruby_version, default: "4.0", aliases: "-r"
+    option :distro_version, default: "trixie", aliases: "-t" # For Toy Story.
+    method_option :end_to_end_tool,
+      type: :string,
+      enum: [ "playwright", "selenium" ],
+      desc: "Use an end-to-end (browser) testing tool",
+      aliases: "-e"
     def initialize_docker
-      get_and_save_file(
-        "https://github.com/lcreid/docker/raw/refs/heads/main/rails-app-sqlite/compose.yml",
-      ) do |file_contents|
-        file_contents.gsub!(
-          /jade:rails-app-[0-9]+\.[0-9]+-\w+-\w+$/,
-          "jade:rails-app-#{options[:ruby_version] || "3.4"}" \
-            "-#{options[:database] || "sqlite"}" \
-            "-#{options[:distro_version] || "bookworm"}",
-        )
-      end
-
-      case Gem::Platform.local.os
-      when "linux"
-        get_and_save_file("https://github.com/lcreid/docker/raw/refs/heads/main/Linux/compose.override.yml")
-      else
-        raise Error.new("Not implemented for #{Gem::Platform.local.os}", options[:verbose])
-      end
+      DockerInitializer.new(**options.transform_keys(&:to_sym).except(:verbose)).get_and_save_compose_files
     end
 
-    desc "initilize_vscode", "Initialize devcontainer.json for vscode"
+    desc "initialize_vscode", "Initialize devcontainer.json for vscode"
     def initialize_vscode
-      get_and_save_file("https://github.com/lcreid/docker/raw/refs/heads/main/.devcontainer.json") do |file_contents|
-        file_contents.gsub!(/, "compose.override.yml"/, "") unless Gem::Platform.local.os == "linux"
-      end
-
-      Dir.mkdir(".vscode") unless Dir.exist?(".vscode")
-      [
-        "https://github.com/lcreid/jade_systems_toolbox/raw/refs/heads/main/templates/extensions.json",
-        "https://github.com/lcreid/jade_systems_toolbox/raw/refs/heads/main/templates/settings.json",
-      ].each { get_and_save_file(_1, target_directory: File.join(".", ".vscode")) }
+      initializer = Vscode.new
+      initializer.write_devcontainer_json
+      initializer.write_extensions_json
+      initializer.write_settings_json
     end
 
-    desc "open", "Open a page on the services's first port"
-    option :service, default: "web"
-    option :path, default: "/"
+    desc "open", "Open a page on the services's first port or specified port"
+    option :service, default: "web", aliases: "-s"
+    option :path, default: "/", alias: "-p"
     option :container_port, default: 3000, type: :numeric
     option :protocol, default: "http"
     def open
@@ -87,14 +94,23 @@ module JadeSystemsToolbox
       container_port = options[:container_port]
       protocol = options[:protocol]
 
-      container_ports = compose_yaml.dig("services", "service", "ports")
+      container_ports = compose_yaml.dig("services", service, "ports")
       container_port = container_ports&.[](0) || container_port
       path = "/#{path}" if path[0] != "/"
-      `open "#{protocol}://localhost:#{host_port_from_container_port(service:, container_port:)}#{path}"`
+      url = "#{protocol}://localhost:#{host_port_from_container_port(service:, container_port:)}#{path}"
+      if `command -v "open"`
+        # Real Unix :-)
+        system "open #{url}"
+      elsif `command -v "cmd.exe"`
+        # WSL because this opens a URL in the browser, which will be on Windows.
+        system "cmd.exe /c start #{url}"
+      else
+        raise ArgumentError, "no suitable command available to open app."
+      end
     end
 
     desc "port [CONTAINER_PORT]", "Get the host port for the CONTAINER_PORT's container port CONTAINER_PORT"
-    option :service, default: "web"
+    option :service, default: "web", aliases: "-s"
     def port(container_port = 3000)
       service = options[:service]
       puts host_port_from_container_port(service:, container_port:)
@@ -113,14 +129,35 @@ module JadeSystemsToolbox
       end
     end
 
-    desc "server [COMMAND]", "Run the server in the container"
-    option :service, default: "web"
+    desc "server [COMMAND] [ARGS]", "Run the server in the container"
+    option :env, repeatable: true, default: [], aliases: "-e", banner: "VAR=value"
+    option :mapping, type: :boolean, default: true, aliases: "-m"
+    option :service, default: "web", aliases: "-s"
     option :work_dir, aliases: "-w"
-    def server(command = "bin/dev")
+    def server(command = "bin/dev", *args)
       service = options[:service]
       workdir = "-w #{options[:work_dir]} " unless options[:work_dir].nil?
-      system("docker compose exec #{workdir}#{service} #{command}")
+      environment_variables = options[:env].map { "-e #{_1}" }.join(" ")
+      port_map_environment_variables = port_map_for_environment(service) if options[:mapping]
+      shell_command = [ command, *args ].join(" ")
+      compose_command = [
+        "docker compose exec",
+        environment_variables,
+        port_map_environment_variables,
+        workdir,
+        service,
+        "sh -c",
+        "'#{shell_command}'",
+      ].compact.join(" ")
+
+      system(compose_command)
+    end
+
+    desc "start [COMPOSE_ARGS]", "docker compose up -d (aliased as `up`)"
+    def start(*compose_args)
+      system(([ "docker compose up -d" ] + compose_args).join(" "))
     end
+    map "up" => :start
 
     desc "stop", "Stop the service(s) but preserve the container(s)"
     def stop
@@ -128,15 +165,22 @@ module JadeSystemsToolbox
     end
 
     desc "terminal", "Run a shell in the container"
-    option :service, default: "web"
+    option :env, repeatable: true, default: [], aliases: "-e", banner: "VAR=value"
+    option :mapping, type: :boolean, default: true, aliases: "-m"
+    option :service, default: "web", aliases: "-s"
     def terminal
       service = options[:service]
-      system("docker compose exec -it #{service} '/bin/bash'")
-    end
-
-    desc "up", "docker compose up -d"
-    def up
-      system("docker compose up -d")
+      environment_variables = options[:env].map { "-e #{_1}" }.join(" ")
+      port_map_environment_variables = port_map_for_environment(service) if options[:mapping]
+      command = [
+        "docker compose exec",
+        environment_variables,
+        port_map_environment_variables,
+        "-it",
+        service,
+        "'/bin/bash'",
+      ].join(" ")
+      system(command)
     end
 
     desc "version", "Show the version number of the tool."
@@ -148,32 +192,14 @@ module JadeSystemsToolbox
 
     def compose_yaml = @compose_yaml ||= YAML.load_file(options[:compose_file] || "compose.yml")
 
-    def get_and_save_file(url, target_directory: nil)
-      file_contents = get_file_from_internet(url:)
+    def get_and_save_file(url, target_directory: nil, target_file_name: nil)
+      file_contents = Http.get_file(url:)
       yield file_contents if block_given?
-      file_name = Pathname.new(url).basename.to_s
+      file_name = target_file_name || Pathname.new(url).basename.to_s
       file_name = Pathname.new(target_directory) + file_name unless target_directory.nil?
       File.write(file_name, file_contents)
     end
 
-    def get_file_from_internet(url:, redirects: 10)
-      raise Errorl.new("Too many redirects", options[:verbose]) if redirects.zero?
-
-      uri = URI.parse(url)
-      request = Net::HTTP.new(uri.host, uri.port)
-      request.use_ssl = true
-      response = request.get(uri.path)
-
-      case response
-      when Net::HTTPSuccess
-        response.body
-      when Net::HTTPRedirection
-        get_file_from_internet(redirects: redirects - 1, url: response["location"])
-      else
-        response.error!
-      end
-    end
-
     def host_port_from_container_port(container_port:, service: "web")
       ports = container_port.to_s.match(/([0-9]+:){0,1}([0-9]+$)/)
       if !ports[1].nil?
@@ -183,5 +209,31 @@ module JadeSystemsToolbox
         output.match(/[0-9]+$/)
       end
     end
+
+    def port_map(service)
+      service_ports = compose_yaml.dig("services", service, "ports")
+      service_ports&.reduce({}) do |acc, port|
+        acc[port] = host_port_from_container_port(container_port: port, service:).to_s
+        acc
+      end
+    end
+
+    def port_map_for_environment(service)
+      port_map(service).map do |container_port, host_port|
+        "-e HOST_PORT_#{container_port}=#{host_port}"
+      end.join(" ")
+    end
+
+    def handle_argument_error(command, error, args, arity)
+      # Check if the error is due to an unknown option or incorrect invocation
+      if (error.is_a?(Thor::UnknownArgumentError) || error.message.include?("was called with arguments")) &&
+        [ "down" ].include?(command)
+        # Return to let Thor proceed instead of raising the error
+        nil
+      else
+        # Fallback to standard Thor behavior for actual code bugs
+        super
+      end
+    end
   end
 end

data/lib/jade_systems_toolbox/docker_initializer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module JadeSystemsToolbox
+  class DockerInitializer
+    def initialize(compose_file: nil, database: nil, ruby_version: nil, distro_version: nil, end_to_end_tool: nil)
+      @end_to_end_tool = end_to_end_tool&.downcase&.strip
+      database = database.to_s.downcase.strip
+      @database = database unless %w[false none nil ""].include?(database)
+      @ruby_version = ruby_version&.downcase&.strip
+      @distro_version = distro_version&.downcase&.strip
+    end
+
+    def compose_file_path
+      base_dir = [ "rails-app", database ].compact.join("-")
+      Pathname("compose-files").join(*([ base_dir, end_to_end_tool, "compose.yml" ].compact))
+    end
+
+    def get_and_save_compose_files
+      compose_file = Http.get_file(url: Http.url(path: compose_file_path))
+      customize_compose_file!(compose_file)
+      File.write("compose.yml", compose_file)
+
+      case Gem::Platform.local.os
+      when "linux"
+        compose_override_file = Http.get_file(url: Http.url(path: "compose-files/Linux/compose.override.yml"))
+        File.write("compose.override.yml", compose_override_file)
+      end
+    end
+
+    def customize_compose_file!(base_file)
+      base_file.gsub!("${RUBY_VERSION:-4.0}", ruby_version) unless ruby_version.nil?
+      base_file.gsub!("${DISTRO_VERSION:-trixie}", distro_version) unless distro_version.nil?
+      base_file
+    end
+
+    private
+
+    attr_reader :end_to_end_tool
+    attr_reader :database
+    attr_reader :ruby_version
+    attr_reader :distro_version
+  end
+end

data/lib/jade_systems_toolbox/http.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module JadeSystemsToolbox
+  class Http
+    class << self
+      def url(path:)
+        base_url + path.to_s
+      end
+
+      def get_file(url:, redirects: 10)
+        raise Error.new("Too many redirects", options[:verbose]) if redirects.zero?
+
+        uri = URI.parse(url)
+        request = Net::HTTP.new(uri.host, uri.port)
+        request.use_ssl = true
+        response = request.get(uri.path)
+
+        case response
+        when Net::HTTPSuccess
+          response.body
+        when Net::HTTPRedirection
+          get_file(redirects: redirects - 1, url: response["location"])
+        else
+          response.value
+        end
+      end
+
+      private
+
+      def base_url = "https://github.com/lcreid/jade_systems_toolbox/raw/refs/heads/main/"
+    end
+  end
+end

data/lib/jade_systems_toolbox/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JadeSystemsToolbox
-  VERSION = "0.1.4"
+  VERSION = "0.2.1"
 end

data/lib/jade_systems_toolbox/vscode.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "json"
+
+module JadeSystemsToolbox
+  class Vscode
+    def write_settings_json
+      target_file = target_directory.join("settings.json")
+      settings = if !target_file.exist? || target_file.empty?
+        {}
+      else
+        JSON.load_file(target_file)
+      end
+
+      settings["window.title"] = Pathname.pwd.basename
+      File.write(target_file, JSON.pretty_generate(settings))
+    end
+
+    def write_devcontainer_json
+      devcontainer_text = Http.get_file(url: Http.url(path: "templates/.devcontainer.json"))
+      devcontainer_json = JSON.parse(devcontainer_text, allow_comments: true)
+      unless Gem::Platform.local.os == "linux"
+        devcontainer_json["dockerComposeFile"] = [ "compose.yml" ]
+      end
+      Pathname(".devcontainer.json").write(JSON.pretty_generate(devcontainer_json))
+    end
+
+    def write_extensions_json
+      extensions_text = Http.get_file(url: Http.url(path: "templates/extensions.json"))
+      target_directory.join("extensions.json").write(extensions_text)
+    end
+
+    def get_and_write_settings_json
+      settings_text = Http.get_file(url: Http.url(path: "templates/settings.json"))
+      settings = JSON.parse(settings_text, allow_comments: true)
+      settings["window.title"] = Pathname.pwd.basename
+
+      target_file = target_directory.join("settings.json")
+      File.write(target_file, JSON.pretty_generate(settings))
+    end
+
+    private
+
+    def target_directory
+      @target_directory unless @target_directory.nil?
+
+      @target_directory = Pathname("./.vscode")
+      FileUtils.mkdir(@target_directory) unless @target_directory.exist?
+      @target_directory
+    end
+  end
+end

data/lib/jade_systems_toolbox.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "debug"
 require "net/http"
 require "pathname"
 require "thor"
@@ -8,7 +7,10 @@ require "yaml"
 
 require_relative "jade_systems_toolbox/version"
 require_relative "jade_systems_toolbox/cli"
+require_relative "jade_systems_toolbox/docker_initializer"
 require_relative "jade_systems_toolbox/error_reporter"
+require_relative "jade_systems_toolbox/http"
+require_relative "jade_systems_toolbox/vscode"
 
 module JadeSystemsToolbox
   class Error < StandardError

data/templates/.devcontainer.json

@@ -0,0 +1,36 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-docker-compose
+{
+	// Update the 'dockerComposeFile' list if you have more compose files or use different names.
+	"dockerComposeFile": ["compose.yml", "compose.override.yml"],
+
+	// The 'service' property is the name of the service for the container that VS Code should
+	// use. Update this value and .devcontainer/docker-compose.yml to the real service name.
+	"service": "web",
+
+	// The optional 'workspaceFolder' property is the path VS Code should open by default when
+	// connected. This is typically a file mount in .devcontainer/docker-compose.yml
+	"workspaceFolder": "/home/dev/app",
+	// "workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}"
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Uncomment the next line if you want start specific services in your Docker Compose config.
+	// "runServices": [],
+
+	// Uncomment the next line if you want to keep your containers running after VS Code shuts down.
+	"shutdownAction": "none"
+
+	// Uncomment the next line to run commands after the container is created.
+	// "postCreateCommand": "cat /etc/os-release",
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as an existing user other than the container default. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "devcontainer"
+}

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jade_systems_toolbox
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.1
 platform: ruby
 authors:
 - Larry Reid
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -23,6 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+description:
 email:
 - lcreid@jadesystems.ca
 executables:
@@ -41,9 +43,13 @@ files:
 - exe/tool
 - lib/jade_systems_toolbox.rb
 - lib/jade_systems_toolbox/cli.rb
+- lib/jade_systems_toolbox/docker_initializer.rb
 - lib/jade_systems_toolbox/error_reporter.rb
+- lib/jade_systems_toolbox/http.rb
 - lib/jade_systems_toolbox/version.rb
+- lib/jade_systems_toolbox/vscode.rb
 - sig/jade_systems_toolbox.rbs
+- templates/.devcontainer.json
 - templates/extensions.json
 - templates/settings.json
 homepage: https://github.com/lcreid/jade_systems_toolbox
@@ -53,6 +59,7 @@ metadata:
   homepage_uri: https://github.com/lcreid/jade_systems_toolbox
   source_code_uri: https://github.com/lcreid/jade_systems_toolbox
   changelog_uri: https://github.com/lcreid/jade_systems_toolbox/CHANGELOG.nd
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -60,14 +67,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: A collection of command line commands to support development.
 test_files: []