bard 1.9.6 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4a1a61baf060f0f93948d1fe64ae0439e40510fc68315375c758c9533f59ac6
-  data.tar.gz: ca0e627b6c823a8922d1dbd7822633bb324d46ec994d53f20a339db074e51db0
+  metadata.gz: 24a9ee78c591a6446ac1bb749225497c75470e12e4fe822d96e975870ac88152
+  data.tar.gz: 2b8ae0acbf1237b3312957128130f399a516a3a19d52d45f63c7b0677952e4f2
 SHA512:
-  metadata.gz: 476b6b23bdd7e5314ca7a389e42fd878a01568408ae3de1c5f6f91ed2086f59c5545100a0ccaa371b083d63e6800bea32b0d23ea3dcd85c0d2ace6ced944e28b
-  data.tar.gz: 0fb206ae49740b070cea34d19b150da314cc4a8c41284886d45a261f934dcccf7b6e3dd7a507f1b69f23b429adb8b03992e1b8d746e52533e3a60aa19fdfdd0a
+  metadata.gz: 55a1a4f6fcf3bf12201105974a619be5178c3c9c6367d8dccf2eef1e7e504880a869a6291dfb5024930e025f63d8cf2f22c8925cf5fc24f9e83d2aa85ed047ed
+  data.tar.gz: 5da5d707ceed5ca663e4a68cd4a2ba2afbb232052e4a0542a4e41a1badc0161ba4eda410195b717d21f8fdaea299af771afa6a19310d93b66915996e8579b5fa

data/.github/workflows/ci.yml

@@ -5,7 +5,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ "3.2", "3.3", "3.4" ]
+        ruby: [ "3.3", "3.4", "4.0" ]
 
     runs-on: ubuntu-latest
     steps:
@@ -36,7 +36,7 @@ jobs:
 
       - name: Build test container image
         run: |
-          sudo podman pull ubuntu:22.04
+          sudo podman pull ubuntu:24.04
           sudo podman build -t bard-test-server -f spec/acceptance/docker/Dockerfile spec/acceptance/docker
 
       - name: Run tests

data/CLAUDE.md

@@ -44,7 +44,7 @@ bundle exec bin/bard
 - **`Bard::CLI`** (`lib/bard/cli.rb`) - Thor-based command dispatcher. Commands are modules in `lib/bard/cli/` included into CLI.
 - **`Bard::Config`** (`lib/bard/config.rb`) - DSL parser for `bard.rb` files. Manages targets and settings.
 - **`Bard::Target`** (`lib/bard/target.rb`) - Deployment destination with capabilities (ssh, ping, data). Supports dynamic strategy DSL via `method_missing`.
-- **`Bard::Server`** (`lib/bard/server.rb`) - Legacy v1.x server representation (deprecated, use Target).
+- **`Bard::SSHServer`** (`lib/bard/ssh_server.rb`) - SSH connection details (user, host, port, gateway, ssh_key, env).
 - **`Bard::DeployStrategy`** (`lib/bard/deploy_strategy.rb`) - Base class for deployment strategies. Subclasses auto-register via Ruby's `inherited` hook.
 
 ### Capability System

data/PLUGINS.md

@@ -4,18 +4,37 @@ Bard uses a plugin system to extend functionality. Plugins can add CLI commands,
 
 ## Plugin Structure
 
-Plugins live in `lib/bard/plugins/` and register themselves:
+Plugins live in `lib/bard/plugins/` and are auto-loaded. Command classes auto-register when they subclass `Bard::Plugin::Command`:
 
 ```ruby
 # lib/bard/plugins/my_plugin.rb
 require "bard/plugin"
 
-Bard::Plugin.register :my_plugin do
-  # Add CLI commands (class must implement .setup)
-  cli "Bard::CLI::MyPlugin", require: "bard/cli/my_plugin"
+class Bard::CLI::MyPlugin < Bard::Plugin::Command
+  desc "mycommand", "Description of my command"
+  option :verbose, type: :boolean
+  def mycommand
+    puts "Hello from my plugin!"
+    puts config[:production].url
+  end
+end
+```
+
+That's it — no registration block needed. The `Command` base class provides:
+- Automatic registration via Ruby's `inherited` hook
+- `desc` and `option` class methods for Thor integration
+- Delegation to the CLI instance (access to `config`, `project_name`, `run!`, `options`, etc.)
+
+## Extending Target and Config
 
-  # Add methods to Target
-  target_method :my_feature do |url = nil|
+To add methods to `Bard::Target` or `Bard::Config`, reopen the class directly:
+
+```ruby
+# lib/bard/plugins/my_plugin.rb
+require "bard/target"
+
+class Bard::Target
+  def my_feature(url = nil)
     if url.nil?
       @my_feature_url
     else
@@ -23,9 +42,12 @@ Bard::Plugin.register :my_plugin do
       enable_capability(:my_feature)
     end
   end
+end
 
-  # Add methods to Config
-  config_method :my_global_setting do |value = nil|
+require "bard/config"
+
+class Bard::Config
+  def my_global_setting(value = nil)
     if value.nil?
       @my_global_setting
     else
@@ -35,43 +57,6 @@ Bard::Plugin.register :my_plugin do
 end
 ```
 
-## CLI Commands
-
-CLI commands inherit from `Bard::CLI::Command` and implement a `setup` class method:
-
-```ruby
-# lib/bard/cli/my_plugin.rb
-require "bard/cli/command"
-
-class Bard::CLI::MyPlugin < Bard::CLI::Command
-  desc "mycommand", "Description of my command"
-  def mycommand
-    puts "Hello from my plugin!"
-  end
-end
-```
-
-The `Command` base class provides:
-- Automatic `setup` that registers the command with the CLI
-- Delegation to the CLI instance (access to `config`, `project_name`, etc.)
-- `desc` and `option` class methods for Thor integration
-
-For Thor subcommand groups (nested under `bard mygroup`):
-
-```ruby
-# lib/bard/cli/my_subcommand.rb
-class Bard::CLI::MySubcommand < Thor
-  def self.setup(cli)
-    cli.register(self, "mygroup", "mygroup COMMAND", "My subcommand group")
-  end
-
-  desc "action", "Do something"
-  def action
-    puts "Hello from subcommand!"
-  end
-end
-```
-
 ## Adding Strategies
 
 Plugins can add deployment strategies or CI runners:
@@ -111,4 +96,4 @@ Strategies auto-register via Ruby's `inherited` hook. The class name determines
 
 ## Plugin Loading
 
-Plugins are loaded automatically from `lib/bard/plugins/`. The load order is alphabetical by filename. For CI runners, the last registered runner becomes the default.
+Plugins are loaded automatically from `lib/bard/plugins/`. The load order is alphabetical by filename. External plugins are loaded from the project's `lib/bard/plugins/` directory.

data/bard.gemspec

@@ -15,11 +15,11 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = ["bard"]
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.required_ruby_version = ">= 3.3"
   spec.require_paths = ["lib"]
 
   spec.add_dependency "thor", ">= 0.19.0"
   spec.add_dependency "rvm"
-  spec.add_dependency "term-ansicolor", ">= 1.0.3"
   spec.add_dependency "rbnacl"
   spec.add_dependency "base64"
 
@@ -28,4 +28,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "debug"
   spec.add_development_dependency "cucumber"
   spec.add_development_dependency "testcontainers"
+  spec.add_development_dependency "ostruct"
 end

data/features/ci.feature

@@ -1,3 +1,4 @@
+@server
 Feature: bard ci
   Run continuous integration tests.
 

data/features/data.feature

@@ -1,3 +1,4 @@
+@server
 Feature: bard data
   Copy database from a remote server to local.
 

data/features/deploy.feature

@@ -1,3 +1,4 @@
+@server
 Feature: bard deploy
   Deploy code changes to a remote server.
 

data/features/deploy_git_workflow.feature

@@ -1,3 +1,4 @@
+@server
 Feature: bard deploy git workflow
   Git workflow behaviors during deploy.
 

data/features/run.feature

@@ -1,3 +1,4 @@
+@server
 Feature: bard run
   Execute commands on a remote server.
 

data/features/step_definitions/bard_steps.rb

@@ -133,3 +133,4 @@ end
 Then /^the output should not contain "([^"]+)"$/ do |unexpected|
   expect(@stdout).not_to include(unexpected)
 end
+

data/features/support/test_server.rb

@@ -53,7 +53,7 @@ module TestServerWorld
       return
     end
 
-    system("podman pull ubuntu:22.04 >/dev/null 2>&1")
+    system("podman pull ubuntu:24.04 >/dev/null 2>&1")
 
     docker_dir = File.join(ROOT, "spec/acceptance/docker")
     unless system("podman build -t bard-test-server -f #{docker_dir}/Dockerfile #{docker_dir} 2>&1")
@@ -207,10 +207,10 @@ end
 
 World(TestServerWorld)
 
-Before do
+Before("@server") do
   start_test_server
 end
 
-After do
+After("@server") do
   stop_test_server
 end

data/lib/bard/cli.rb

@@ -4,36 +4,11 @@ require "thor"
 require "bard/version"
 require "bard/config"
 require "bard/command"
-require "bard/plugin"
-require "term/ansicolor"
 
 module Bard
   class CLI < Thor
-    include Term::ANSIColor
-
     class_option :verbose, type: :boolean, aliases: :v
 
-    {
-      data: "Data",
-      stage: "Stage",
-      deploy: "Deploy",
-      ci: "CI",
-      master_key: "MasterKey",
-      setup: "Setup",
-      run: "Run",
-      ssh: "SSH",
-    }.each do |command, klass|
-      require "bard/cli/#{command}"
-      include const_get(klass)
-    end
-
-    Plugin.load_all!
-    Plugin.all.each { |plugin| plugin.apply_to_cli(self) }
-
-    # Load core CI runners AFTER plugins so GithubActions is the default (last registered wins)
-    require "bard/ci/local"
-    require "bard/ci/github_actions"
-
     map "--version" => :version
     desc "version", "Display version"
     def version
@@ -43,6 +18,10 @@ module Bard
     def self.exit_on_failure? = true
 
     no_commands do
+      def red(text)    = "\e[31m#{text}\e[0m"
+      def yellow(text) = "\e[33m#{text}\e[0m"
+      def green(text)  = "\e[32m#{text}\e[0m"
+
       def run!(...)
         Bard::Command.run!(...)
       rescue Bard::Command::Error => e
@@ -51,13 +30,15 @@ module Bard
       end
 
       def config
-        @config ||= Bard::Config.new(project_name, path: "bard.rb")
+        @config ||= Bard::Config.current
       end
 
       def project_name
-        @project_name ||= File.expand_path(".").split("/").last
+        config.project_name
       end
     end
+
+    # load plugins from bard and other gems
+    Gem.find_files("bard/plugins/*.rb").sort.each { |path| require path }
   end
 end
-

data/lib/bard/command.rb

@@ -1,43 +1,20 @@
 require "open3"
-require "shellwords"
 
 module Bard
-  class Command < Struct.new(:command, :on, :home)
+  module Command
     class Error < RuntimeError; end
 
-    def self.run! command, on: :local, home: false, verbose: false, quiet: false
-      new(command, on, home).run! verbose:, quiet:
-    end
-
-    def self.run command, on: :local, home: false, verbose: false, quiet: false
-      new(command, on, home).run verbose:, quiet:
-    end
-
-    def self.exec! command, on: :local, home: false
-      new(command, on, home).exec!
-    end
-
-    def run! verbose: false, quiet: false
-      result = run(verbose:, quiet:)
-      raise Error.new(full_command) unless result
+    def self.run!(command, verbose: false, quiet: false)
+      result = run(command, verbose:, quiet:)
+      raise Error.new(command) unless result
       result
     end
 
-    def run verbose: false, quiet: false
-      # no-op if server doesn't really exist
-      if on.to_sym != :local
-        # Check for new Target architecture
-        if on.respond_to?(:server) && on.server.nil?
-          return true
-        # Check for old Server architecture
-        elsif on.respond_to?(:ssh) && on.ssh == false
-          return true
-        end
-      end
+    def self.run(command, verbose: false, quiet: false)
       if verbose
-        system full_command(quiet: quiet)
+        system command
       else
-        stdout, stderr, status = Open3.capture3(full_command)
+        stdout, stderr, status = Open3.capture3(command)
         failed = status.to_i.nonzero?
         if failed && !quiet
           $stdout.puts stdout
@@ -47,64 +24,8 @@ module Bard
       end
     end
 
-    def exec!
-      exec full_command
-    end
-
-    private
-
-    def full_command quiet: false
-      if on.to_sym == :local
-        command
-      else
-        remote_command quiet: false
-      end
-    end
-
-    def remote_command quiet: false
-      # Support both new Target (with server attribute) and old Server architecture
-      ssh_server = on.respond_to?(:server) ? on.server : on
-
-      # Get options from Target first (for deprecated separate method calls), fall back to SSHServer
-      env_value = on.respond_to?(:env) ? on.env : nil
-      env_value ||= ssh_server.env if ssh_server.respond_to?(:env)
-
-      ssh_key = on.respond_to?(:ssh_key) ? on.ssh_key : nil
-      ssh_key ||= ssh_server.ssh_key if ssh_server.respond_to?(:ssh_key)
-
-      gateway = on.respond_to?(:gateway) ? on.gateway : nil
-      gateway ||= ssh_server.gateway if ssh_server.respond_to?(:gateway)
-
-      cmd = command
-      cmd = "#{env_value} #{command}" if env_value
-
-      unless home
-        path = on.respond_to?(:path) ? on.path : ssh_server.path
-        cmd = "cd #{path} && #{cmd}" if path
-      end
-
-      ssh_opts = ["-tt", "-o StrictHostKeyChecking=no", "-o UserKnownHostsFile=/dev/null", "-o LogLevel=ERROR"]
-      ssh_opts << "-i #{ssh_key}" if ssh_key
-
-      # Handle new SSHServer vs old Server architecture
-      if ssh_server.respond_to?(:host)
-        # New SSHServer - has separate host/port/user
-        ssh_opts << "-p #{ssh_server.port}" if ssh_server.port && ssh_server.port != "22"
-        ssh_opts << "-o ProxyJump=#{gateway}" if gateway
-        ssh_target = "#{ssh_server.user}@#{ssh_server.host}"
-      else
-        # Old Server - uses URI-based ssh_uri
-        ssh_target = ssh_server.ssh_uri
-        if gateway
-          gateway_uri = ssh_server.ssh_uri(:gateway)
-          ssh_opts << "-o ProxyJump=#{gateway_uri}"
-        end
-      end
-
-      cmd = "ssh #{ssh_opts.join(' ')} #{ssh_target} #{Shellwords.shellescape(cmd)}"
-
-      cmd += " 2>&1" if quiet
-      cmd
+    def self.exec!(command)
+      Kernel.exec command
     end
   end
 end

data/lib/bard/config.rb

@@ -1,218 +1,79 @@
-require "bard/server"
 require "bard/target"
-require "bard/deprecation"
+require "bard/plugins/ssh/target_methods"
+require "bard/plugins/ping/target_methods"
 
 module Bard
   class Config
-    def self.current(working_directory: Dir.getwd)
-      project_name = File.basename(working_directory)
-      path = File.join(working_directory, "bard.rb")
-      new(project_name, path: path)
+    def self.current
+      new(detect_project_name, path: "bard.rb")
+    end
+
+    def self.detect_project_name
+      git_common_dir = `git rev-parse --git-common-dir 2>/dev/null`.chomp
+      dirname = if $?.success? && !git_common_dir.empty?
+        File.dirname(File.expand_path(git_common_dir))
+      else
+        Dir.getwd
+      end
+      File.basename(dirname)
     end
 
     attr_reader :project_name, :targets
 
     def initialize(project_name = nil, path: nil, source: nil)
-      # Support both positional and keyword argument for project_name
       @project_name = project_name
-      @servers = {}  # Unified hash for both Server and Target instances
-      @data_paths = []
-      @backup = nil
-      @ci_system = nil
-
-      # Load default configuration (creates Server instances for backward compat)
+      @targets = {}
       load_defaults if project_name
 
-      # Load user configuration
       if path && File.exist?(path)
         source = File.read(path)
       end
       if source
-        instance_eval(source)
+        instance_eval(source, path)
       end
     end
 
-    # Backward compatible accessor
-    def servers
-      @servers
-    end
-
-    # New v2.0 accessor (same as servers)
-    def targets
-      @servers
-    end
-
-    # Old v1.x API - creates Server instances
-    def server(key, &block)
-      Deprecation.warn "`server` is deprecated; use `target` instead (will be removed in v2.0)"
-      key = key.to_sym
-      @servers[key] = Server.define(project_name, key, &block)
-    end
-
     def remove_target(key)
-      @servers.delete(key.to_sym)
+      @targets.delete(key.to_sym)
     end
 
-    # New v2.0 API - creates Target instances
     def target(key, &block)
       key = key.to_sym
-      unless @servers[key].is_a?(Target)
-        @servers[key] = Target.new(key, self)
+      unless @targets[key].is_a?(Target)
+        @targets[key] = Target.new(key, self)
       end
-      @servers[key].instance_eval(&block) if block
-      @servers[key]
+      @targets[key].instance_eval(&block) if block
+      @targets[key]
     end
 
-    # Get a server/target by key
     def [](key)
-      key = key.to_sym
-      # Fallback to staging if production not defined
-      if @servers[key].nil? && key == :production
-        key = :staging
-      end
-      @servers[key]
+      @targets[key.to_sym]
     end
 
-    # Data paths configuration
-    def data(*paths)
-      if paths.empty?
-        @data_paths
-      else
-        @data_paths = paths
-      end
-    end
-
-    def data_paths
-      @data_paths
-    end
-
-    def backup(value = nil, &block)
-      if block_given?
-        @backup = BackupConfig.new(&block)
-      elsif value == false
-        @backup = BackupConfig.new { disabled }
-      elsif value.nil? # Getter
-        @backup ||= BackupConfig.new { bard }
-      else
-        raise ArgumentError, "backup accepts false or a block"
-      end
-    end
+    private
 
-    def backup_enabled?
-      backup == true
-    end
+    def load_defaults
+      target :local
 
-    def github_pages url
-      urls = []
-      uri = url.start_with?("http") ? URI.parse(url) : URI.parse("https://#{url}")
-      hostname = uri.hostname.sub(/^www\./, '')
-      urls = [hostname]
-      if hostname.count(".") < 2
-        urls << "www.#{hostname}"
+      target :gubs do
+        ssh "botandrose@cloud.hackett.world:22022",
+          path: "Sites/#{config.project_name}"
+        url false
       end
 
-      target :production do
-        github_pages url
-        ssh false
-        ping(*urls) if urls.any?
+      target :ci do
+        ssh "jenkins@staging.botandrose.com:22022",
+          path: "jobs/#{config.project_name}/workspace"
+        url false
       end
 
-      backup false
-    end
-
-    # CI configuration
-    def ci(system = nil)
-      if system.nil?
-        @ci_system
-      else
-        @ci_system = system
+      staging_defaults = proc do
+        ssh "www@staging.botandrose.com:22022"
+        url "#{config.project_name}.botandrose.com"
       end
-    end
-
-    def ci_system
-      @ci_system
-    end
-
-    def ci_instance(branch)
-      return nil if @ci_system == false
-
-      require "bard/ci"
-      CI.new(project_name, branch, runner_name: @ci_system)
-    end
-
-    private
-
-    # Load default server configurations (v1.x compatible)
-    def load_defaults
-      @servers[:local] = Server.new(
-        project_name,
-        :local,
-        false,
-        "./",
-        ["#{project_name}.local"],
-      )
-      @servers[:gubs] = Server.new(
-        project_name,
-        :gubs,
-        "botandrose@cloud.hackett.world:22022",
-        "Sites/#{project_name}",
-        false,
-      )
-      @servers[:ci] = Server.new(
-        project_name,
-        :ci,
-        "jenkins@staging.botandrose.com:22022",
-        "jobs/#{project_name}/workspace",
-        false,
-      )
-      @servers[:staging] = Server.new(
-        project_name,
-        :staging,
-        "www@staging.botandrose.com:22022",
-        project_name,
-        ["#{project_name}.botandrose.com"],
-      )
-    end
-  end
-
-  class BackupConfig
-    attr_reader :destinations
-
-    def initialize(&block)
-      @destinations = []
-      instance_eval(&block) if block_given?
-    end
-
-    def bard
-      @bard = true
-    end
-
-    def bard?
-      !!@bard
-    end
-
-    def disabled
-      @disabled = true
-    end
-
-    def disabled?
-      !!@disabled
-    end
-
-    def enabled?
-      !disabled?
-    end
-
-    def s3(name, **kwargs)
-      @destinations << {
-        name: name,
-        type: :s3,
-        **kwargs,
-      }
-    end
 
-    def self_managed?
-      @destinations.any?
+      target :staging, &staging_defaults
+      target :production, &staging_defaults
     end
   end
 end