bard 1.8.0.beta4 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1a0399d5fd80c8599d584b056a6ae7b77959cdf9f394e3d76461826f2219f9f
-  data.tar.gz: cd5b858005ffeddd001fffcef8538c07572b70d81ab086c9b44c4b06b2304f18
+  metadata.gz: 937ff227cd4b15691d6aa48c4d5f6670aa6c0232adf650672bd8790fb6baa6fa
+  data.tar.gz: 2858f62171dedf98e5518e16a82b0e1569c8c251024e7a934b9ebcbbec15a568
 SHA512:
-  metadata.gz: 279c018696cdbef81518d54e37bc5f1508b42808e8c8f448bd048816a398f28b46ecd62865481ab3f83da742c4015b1d5acb69941769f004f40e7d88f765add7
-  data.tar.gz: 3b7d5e076a8f5f20ac500e8261e4ff15b10dd7a8814c1aba097a8f1635dc610ed60f951af648a2a0e56e6adce2f2da8eee2ca54a2ad93312446883de3e416d93
+  metadata.gz: 03ecce7b9ee18e490a207d776b92958f71d17d2738f6641ceeb9a9a1605aba169dff86f942ae727134197bbed6b5b80825ed8a9a02b17d912dee3aa176ecae89
+  data.tar.gz: b39fe1a1e8d4e92961425ffdd5856d90f926d6f96cb19690e884b2b7c00776f1251285c9ef2034303f0cd3490823206cf975903f775ac19104e4b3243ac72b14

data/CLAUDE.md

@@ -0,0 +1,76 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What is Bard?
+
+Bard is a modular deployment CLI tool for Ruby applications. It provides:
+- SSH-based deployment via git pull
+- GitHub Pages static site deployment
+- Custom pluggable deployment strategies
+- Data syncing (database dumps and file rsync)
+- CI integration (GitHub Actions/Jenkins)
+- Server provisioning
+
+## Development Commands
+
+```bash
+# Install dependencies
+bundle install
+
+# Run all tests (RSpec + Cucumber)
+bundle exec rake
+
+# Run only RSpec tests
+bundle exec rspec
+
+# Run a single spec file
+bundle exec rspec spec/bard/target_spec.rb
+
+# Run a specific test by line number
+bundle exec rspec spec/bard/target_spec.rb:42
+
+# Run Cucumber features (slow - avoid full suite)
+bundle exec cucumber features/deploy.feature
+
+# Run bard from source
+bundle exec bin/bard
+```
+
+## Architecture
+
+### Core Classes
+
+- **`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::DeployStrategy`** (`lib/bard/deploy_strategy.rb`) - Base class for deployment strategies. Subclasses auto-register via Ruby's `inherited` hook.
+
+### Capability System
+
+Targets track enabled capabilities (`:ssh`, `:ping`, `:github_pages`, etc.). Commands call `require_capability!` to ensure the target supports the operation.
+
+### Strategy Auto-Registration
+
+Custom strategies subclass `DeployStrategy` and are automatically registered by class name:
+```ruby
+class Bard::DeployStrategy::Jets < DeployStrategy  # registers as :jets
+  def deploy; ...; end
+end
+```
+
+### File Organization
+
+- `lib/bard/cli/*.rb` - CLI command modules (deploy, data, ssh, etc.)
+- `lib/bard/ci/*.rb` - CI system integrations (github_actions, jenkins, local)
+- `lib/bard/deploy_strategy/*.rb` - Built-in strategies (ssh, github_pages)
+- `lib/bard/provision/*.rb` - Server provisioning modules
+- `spec/` - RSpec unit tests
+- `features/` - Cucumber integration tests
+
+## Testing Notes
+
+- Use `focus: true` in RSpec to run specific tests
+- Cucumber tests use testcontainers and are slow - run specific feature files only
+- SimpleCov tracks coverage across both RSpec and Cucumber runs

data/PLUGINS.md

@@ -0,0 +1,114 @@
+# Plugin Development
+
+Bard uses a plugin system to extend functionality. Plugins can add CLI commands, target methods, and config DSL methods.
+
+## Plugin Structure
+
+Plugins live in `lib/bard/plugins/` and register themselves:
+
+```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"
+
+  # Add methods to Target
+  target_method :my_feature do |url = nil|
+    if url.nil?
+      @my_feature_url
+    else
+      @my_feature_url = url
+      enable_capability(:my_feature)
+    end
+  end
+
+  # Add methods to Config
+  config_method :my_global_setting do |value = nil|
+    if value.nil?
+      @my_global_setting
+    else
+      @my_global_setting = value
+    end
+  end
+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:
+
+```ruby
+# Custom deploy strategy
+module Bard
+  class DeployStrategy
+    class MyCloud < DeployStrategy
+      def deploy
+        # Deployment logic here
+        run! "my-cloud deploy #{target.key}"
+      end
+    end
+  end
+end
+
+# Custom CI runner
+module Bard
+  class CI
+    class Runner
+      class MyCI < Runner
+        def run
+          # Start CI run
+        end
+
+        def status
+          # Return current status
+        end
+      end
+    end
+  end
+end
+```
+
+Strategies auto-register via Ruby's `inherited` hook. The class name determines the strategy key (e.g., `MyCloud` → `:my_cloud`).
+
+## 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.

data/README.md

@@ -12,7 +12,7 @@ end
 ```
 
 ```bash
-bard deploy production
+bard deploy
 ```
 
 ## Features
@@ -115,17 +115,21 @@ end
 ### Deployment
 
 ```bash
-# Deploy to production
-bard deploy production
+# Deploy current branch to production (default)
+bard deploy
 
-# Deploy to staging
-bard deploy staging
+# Deploy a specific branch to production
+bard deploy feature-branch
+
+# Deploy to a different target
+bard deploy --target=staging
+bard deploy feature-branch --target=staging
 
 # Deploy feature branch to staging (no merge)
 bard stage feature-branch
 
 # Skip CI checks
-bard deploy production --skip-ci
+bard deploy --skip-ci
 ```
 
 ### Data Management
@@ -459,6 +463,10 @@ See [ARCHITECTURE.md](ARCHITECTURE.md) for detailed architecture documentation.
 
 See [CUSTOM_STRATEGIES.md](CUSTOM_STRATEGIES.md) for a step-by-step guide to creating custom deployment strategies.
 
+## Plugin Development
+
+See [PLUGINS.md](PLUGINS.md) for a guide to creating plugins.
+
 ## Development
 
 ```bash

data/features/ci.feature

@@ -0,0 +1,62 @@
+Feature: bard ci
+  Run continuous integration tests.
+
+  Background:
+    Given a test server is running
+
+  Scenario: no CI configured error
+    When I run expecting failure: bard ci
+    Then the output should contain "No CI found"
+    And the output should contain "Re-run with --skip-ci to bypass CI"
+
+  Scenario: local CI runs successfully
+    Given a local CI script that passes
+    When I run: bard ci --local-ci
+    Then the output should contain "Continuous integration: starting build"
+    And the output should contain "Continuous integration: success!"
+
+  Scenario: local CI reports failure
+    Given a local CI script that fails with "Test failed: expected 1 but got 2"
+    When I run expecting failure: bard ci --local-ci
+    Then the output should contain "Test failed: expected 1 but got 2"
+    And the output should contain "Automated tests failed!"
+
+  Scenario: --ci option runs specified CI runner
+    Given a local CI script that passes
+    When I run: bard ci --ci=local
+    Then the output should contain "Continuous integration: starting build"
+    And the output should contain "Continuous integration: success!"
+
+  Scenario: --ci option reports failure from specified runner
+    Given a local CI script that fails with "Custom runner failed"
+    When I run expecting failure: bard ci --ci=local
+    Then the output should contain "Custom runner failed"
+    And the output should contain "Automated tests failed!"
+
+  Scenario: deploy passes --ci option to CI
+    Given a local CI script that passes
+    And I create a file "ci-option-test.txt" with content "ci option test"
+    And I commit the changes with message "Add CI option test file"
+    When I run: bard deploy --ci=local
+    Then the output should contain "Continuous integration: starting build"
+    And the output should contain "Continuous integration: success!"
+    And the output should contain "Deploy Succeeded"
+
+  Scenario: deploy runs CI before deploying
+    Given a local CI script that passes
+    And I create a file "ci-test.txt" with content "ci test"
+    And I commit the changes with message "Add CI test file"
+    When I run: bard deploy --local-ci
+    Then the output should contain "Continuous integration: starting build"
+    And the output should contain "Continuous integration: success!"
+    And the output should contain "Deploy Succeeded"
+
+  Scenario: deploy aborts if CI fails
+    Given a local CI script that fails with "Build failed"
+    And I create a file "ci-fail.txt" with content "ci fail test"
+    And I commit the changes with message "Add CI fail test file"
+    When I run expecting failure: bard deploy --local-ci
+    Then the output should contain "Continuous integration: starting build"
+    And the output should contain "Build failed"
+    And the output should contain "Automated tests failed!"
+    And the output should not contain "Deploy Succeeded"

data/features/deploy_git_workflow.feature

@@ -0,0 +1,88 @@
+Feature: bard deploy git workflow
+  Git workflow behaviors during deploy.
+
+  Background:
+    Given a test server is running
+
+  Scenario: deploy on master pushes unpushed commits
+    Given I create a file "local-only.txt" with content "local commit"
+    And I commit the changes with message "Add local only file"
+    When I run: bard deploy --skip-ci
+    Then the output should contain "Deploy Succeeded"
+    When I run: bard run "cat local-only.txt"
+    Then the output should contain "local commit"
+
+  Scenario: feature branch fast-forward merge
+    Given I create and switch to branch "feature-branch"
+    And I create a file "feature.txt" with content "feature content"
+    And I commit the changes with message "Add feature"
+    When I run: bard deploy --skip-ci
+    Then the output should contain "Deploy Succeeded"
+    And I should be on branch "master"
+    And branch "feature-branch" should not exist locally
+    And branch "feature-branch" should not exist on origin
+    When I run: bard run "cat feature.txt"
+    Then the output should contain "feature content"
+
+  Scenario: feature branch requires rebase
+    Given I create and switch to branch "feature-branch"
+    And I create a file "feature.txt" with content "feature content"
+    And I commit the changes with message "Add feature"
+    And master has an additional commit from another source
+    When I run: bard deploy --skip-ci
+    Then the output should contain "The master branch has advanced"
+    And the output should contain "Attempting rebase"
+    And the output should contain "Deploy Succeeded"
+    And I should be on branch "master"
+    When I run: bard run "cat feature.txt"
+    Then the output should contain "feature content"
+    When I run: bard run "cat remote-change.txt"
+    Then the output should contain "remote change"
+
+  Scenario: feature branch rebase conflict
+    Given I create and switch to branch "feature-branch"
+    And I create a file "conflict.txt" with content "feature content"
+    And I commit the changes with message "Add conflicting file"
+    And master has a conflicting commit to "conflict.txt"
+    When I run expecting failure: bard deploy --skip-ci
+    Then the output should contain "The master branch has advanced"
+    And the output should contain "Attempting rebase"
+    And the output should contain "Running command failed"
+
+  Scenario: branch cleanup after deploy
+    Given I create and switch to branch "cleanup-test"
+    And I create a file "cleanup.txt" with content "cleanup test"
+    And I commit the changes with message "Add cleanup test file"
+    And I push branch "cleanup-test" to origin
+    When I run: bard deploy --skip-ci
+    Then the output should contain "Deleting branch: cleanup-test"
+    And the output should contain "Deploy Succeeded"
+    And I should be on branch "master"
+    And branch "cleanup-test" should not exist locally
+    And branch "cleanup-test" should not exist on origin
+
+  Scenario: deploy a branch without checking it out
+    Given I create and switch to branch "feature-branch"
+    And I create a file "feature.txt" with content "feature content"
+    And I commit the changes with message "Add feature"
+    And I switch to branch "master"
+    When I run: bard deploy feature-branch --skip-ci
+    Then the output should contain "Deploy Succeeded"
+    And I should be on branch "master"
+    And branch "feature-branch" should not exist locally
+    When I run: bard run "cat feature.txt"
+    Then the output should contain "feature content"
+
+  Scenario: deploy a branch that requires rebase without checking it out
+    Given I create and switch to branch "feature-branch"
+    And I create a file "feature.txt" with content "feature content"
+    And I commit the changes with message "Add feature"
+    And I switch to branch "master"
+    And master has an additional commit from another source
+    When I run: bard deploy feature-branch --skip-ci
+    Then the output should contain "The master branch has advanced"
+    And the output should contain "Attempting rebase"
+    And the output should contain "Deploy Succeeded"
+    And I should be on branch "master"
+    When I run: bard run "cat feature.txt"
+    Then the output should contain "feature content"

data/features/step_definitions/bard_steps.rb

@@ -37,3 +37,99 @@ Then /^a file "([^\"]+)" should exist locally$/ do |filename|
   path = File.join(@test_dir, filename)
   expect(File.exist?(path)).to be(true), "Expected file #{filename} to exist at #{path}"
 end
+
+# Branch management
+Given /^I create and switch to branch "([^"]+)"$/ do |branch_name|
+  Dir.chdir(@test_dir) do
+    system("git checkout -b #{branch_name}", out: File::NULL, err: File::NULL)
+  end
+end
+
+Then /^I should be on branch "([^"]+)"$/ do |expected_branch|
+  Dir.chdir(@test_dir) do
+    current = `git rev-parse --abbrev-ref HEAD`.chomp
+    expect(current).to eq(expected_branch)
+  end
+end
+
+Given /^I push branch "([^"]+)" to origin$/ do |branch_name|
+  Dir.chdir(@test_dir) do
+    system("git push -u origin #{branch_name}", out: File::NULL, err: File::NULL)
+  end
+end
+
+Then /^branch "([^"]+)" should not exist locally$/ do |branch_name|
+  Dir.chdir(@test_dir) do
+    result = system("git rev-parse --verify #{branch_name}", out: File::NULL, err: File::NULL)
+    expect(result).to be(false), "Expected branch #{branch_name} to not exist locally"
+  end
+end
+
+Then /^branch "([^"]+)" should not exist on origin$/ do |branch_name|
+  Dir.chdir(@test_dir) do
+    system("git fetch --prune origin", out: File::NULL, err: File::NULL)
+    result = system("git rev-parse --verify origin/#{branch_name}", out: File::NULL, err: File::NULL)
+    expect(result).to be(false), "Expected branch #{branch_name} to not exist on origin"
+  end
+end
+
+# Simulating remote changes
+Given /^master has an additional commit from another source$/ do
+  run_ssh "cd ~/testproject && git pull origin master"
+  run_ssh "cd ~/testproject && echo 'remote change' > remote-change.txt"
+  run_ssh "cd ~/testproject && git add remote-change.txt"
+  run_ssh "cd ~/testproject && git commit -m 'Remote commit on master'"
+  run_ssh "cd ~/testproject && git push origin master"
+
+  Dir.chdir(@test_dir) do
+    system("git fetch origin", out: File::NULL, err: File::NULL)
+  end
+end
+
+Given /^master has a conflicting commit to "([^"]+)"$/ do |filename|
+  run_ssh "cd ~/testproject && git pull origin master"
+  run_ssh "cd ~/testproject && echo 'conflicting content from remote' > #{filename}"
+  run_ssh "cd ~/testproject && git add #{filename}"
+  run_ssh "cd ~/testproject && git commit -m 'Remote conflicting commit'"
+  run_ssh "cd ~/testproject && git push origin master"
+
+  Dir.chdir(@test_dir) do
+    system("git fetch origin", out: File::NULL, err: File::NULL)
+  end
+end
+
+# CI setup
+Given /^a local CI script that passes$/ do
+  Dir.chdir(@test_dir) do
+    File.write("bin/rake", <<~'SCRIPT')
+#!/bin/bash
+case "$1" in
+  ci) echo "All tests passed!"; exit 0 ;;
+esac
+    SCRIPT
+    FileUtils.chmod(0o755, "bin/rake")
+  end
+end
+
+Given /^a local CI script that fails with "([^"]+)"$/ do |error_message|
+  Dir.chdir(@test_dir) do
+    File.write("bin/rake", <<~SCRIPT)
+#!/bin/bash
+case "$1" in
+  ci) echo "#{error_message}"; exit 1 ;;
+esac
+    SCRIPT
+    FileUtils.chmod(0o755, "bin/rake")
+  end
+end
+
+Given /^I switch to branch "([^"]+)"$/ do |branch_name|
+  Dir.chdir(@test_dir) do
+    system("git checkout #{branch_name}", out: File::NULL, err: File::NULL)
+  end
+end
+
+# Output negation
+Then /^the output should not contain "([^"]+)"$/ do |unexpected|
+  expect(@stdout).not_to include(unexpected)
+end

data/features/support/bard-coverage

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+root = File.expand_path("../../..", __FILE__)
+
+require "simplecov"
+SimpleCov.root(root)
+SimpleCov.start do
+  command_name "Cucumber (subprocess #{$$})"
+  track_files "lib/**/*.rb"
+  add_filter "spec/"
+  add_filter "features/"
+  coverage_dir "#{root}/coverage"
+end
+
+$LOAD_PATH.unshift("#{root}/lib")
+require "bard/cli"
+Bard::CLI.start ARGV

data/features/support/env.rb

@@ -1,8 +1,17 @@
+require "simplecov"
+SimpleCov.start do
+  command_name "Cucumber"
+  track_files "lib/**/*.rb"
+  add_filter "spec/"
+  add_filter "features/"
+end
+
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require "bard"
 require 'rspec/expectations'
 require 'fileutils'
 
-ENV["PATH"] = "#{File.dirname(File.expand_path(__FILE__))}/../../bin:#{ENV['PATH']}"
+ENV["PATH"] = "#{File.dirname(File.expand_path(__FILE__))}:#{ENV['PATH']}"
 ENV["GIT_DIR"] = nil
 ENV["GIT_WORK_TREE"] = nil
 ENV["GIT_INDEX_FILE"] = nil

data/features/support/test_server.rb

@@ -184,7 +184,8 @@ SCRIPT
 
   def run_bard(command)
     Dir.chdir(@test_dir) do
-      @stdout, @status = Open3.capture2e("bard #{command}")
+      bard_coverage = File.join(ROOT, "features/support/bard-coverage")
+      @stdout, @status = Open3.capture2e("#{bard_coverage} #{command}")
     end
   end
 

data/lib/bard/ci/github_actions.rb

@@ -5,9 +5,8 @@ require "bard/ci/runner"
 module Bard
   class CI
     class GithubActions < Runner
-
       def exists?
-        true
+        File.exist?(".github/workflows/ci.yml")
       end
 
       def console