bard 1.9.6 → 2.0.0.beta

data/features/deploy.feature

@@ -1,13 +0,0 @@
-Feature: bard deploy
-  Deploy code changes to a remote server.
-
-  Background:
-    Given a test server is running
-
-  Scenario: deploys code changes to the remote server
-    Given I create a file "DEPLOYED.txt" with content "deployed by bard"
-    And I commit the changes with message "Add deployed marker"
-    When I run: bard deploy --skip-ci
-    Then the output should contain "Deploy Succeeded"
-    When I run: bard run "cat DEPLOYED.txt"
-    Then the output should contain "deployed by bard"

data/features/deploy_git_workflow.feature

@@ -1,88 +0,0 @@
-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/run.feature

@@ -1,13 +0,0 @@
-Feature: bard run
-  Execute commands on a remote server.
-
-  Background:
-    Given a test server is running
-
-  Scenario: executes a command on the remote server
-    When I run: bard run "echo hello"
-    Then the output should contain "hello"
-
-  Scenario: operates in the configured path
-    When I run: bard run "pwd"
-    Then the output should contain "testproject"

data/features/step_definitions/bard_steps.rb

@@ -1,135 +0,0 @@
-Given /^a test server is running$/ do
-  raise "Test server failed to start" unless @container && @ssh_port
-end
-
-When /^I run: bard (.+)$/ do |command|
-  run_bard(command)
-  unless @status.success?
-    raise "Command failed with status: #{@status}\nOutput: #{@stdout}"
-  end
-end
-
-When /^I run expecting failure: bard (.+)$/ do |command|
-  run_bard(command)
-  unless !@status.success?
-    raise "Command succeeded but was expected to fail\nOutput: #{@stdout}"
-  end
-end
-
-Then /^the output should contain "([^\"]+)"$/ do |expected|
-  expect(@stdout).to include(expected)
-end
-
-Given /^I create a file "([^\"]+)" with content "([^\"]+)"$/ do |filename, content|
-  Dir.chdir(@test_dir) do
-    File.write(filename, content)
-  end
-end
-
-Given /^I commit the changes with message "([^\"]+)"$/ do |message|
-  Dir.chdir(@test_dir) do
-    system("git add -A", out: File::NULL, err: File::NULL)
-    system("git commit -m '#{message}'", out: File::NULL, err: File::NULL)
-  end
-end
-
-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

@@ -1,16 +0,0 @@
-#!/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/test_server.rb

@@ -1,216 +0,0 @@
-require "fileutils"
-require "open3"
-require "tmpdir"
-require "docker-api"
-
-module TestServerWorld
-  class << self
-    attr_accessor :server_available, :image_built
-  end
-
-  class PrerequisiteError < StandardError; end
-
-  def ensure_server_available
-    return if TestServerWorld.server_available
-
-    unless system("command -v podman >/dev/null 2>&1")
-      raise PrerequisiteError, "podman is not installed"
-    end
-
-    configure_container_socket
-    build_test_image
-    FileUtils.chmod(0o600, ssh_key_path)
-
-    TestServerWorld.server_available = true
-  end
-
-  def configure_container_socket
-    if ENV["DOCKER_HOST"]
-      Docker.url = ENV["DOCKER_HOST"]
-      return
-    end
-
-    socket_path = "/run/user/#{Process.uid}/podman/podman.sock"
-    unless File.exist?(socket_path)
-      system("systemctl --user start podman.socket 2>/dev/null")
-      sleep 2
-    end
-
-    unless File.exist?(socket_path)
-      raise PrerequisiteError, "Podman socket not available"
-    end
-
-    ENV["DOCKER_HOST"] = "unix://#{socket_path}"
-    Docker.url = ENV["DOCKER_HOST"]
-  end
-
-  def build_test_image
-    return if TestServerWorld.image_built
-
-    # Check if image already exists (e.g., pre-built in CI)
-    if image_exists?("bard-test-server")
-      TestServerWorld.image_built = true
-      return
-    end
-
-    system("podman pull ubuntu:22.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")
-      raise PrerequisiteError, "Failed to build test image"
-    end
-
-    TestServerWorld.image_built = true
-  end
-
-  def image_exists?(name)
-    Docker::Image.get(name)
-    true
-  rescue Docker::Error::NotFoundError
-    false
-  end
-
-  def start_test_server
-    ensure_server_available
-
-    @container = Docker::Container.create(
-      "Image" => "localhost/bard-test-server:latest",
-      "ExposedPorts" => { "22/tcp" => {} },
-      "HostConfig" => {
-        "PortBindings" => { "22/tcp" => [{ "HostPort" => "" }] },
-        "PublishAllPorts" => true
-      }
-    )
-    @container.start
-    @container.refresh!
-
-    @ssh_port = @container.info["NetworkSettings"]["Ports"]["22/tcp"].first["HostPort"].to_i
-
-    wait_for_ssh
-    setup_test_directory
-  end
-
-  def wait_for_ssh
-    30.times do
-      return if system(
-        "ssh", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null",
-        "-o", "ConnectTimeout=1", "-p", @ssh_port.to_s, "-i", ssh_key_path,
-        "deploy@localhost", "true",
-        out: File::NULL, err: File::NULL
-      )
-      sleep 0.5
-    end
-    raise PrerequisiteError, "SSH not ready"
-  end
-
-  def setup_test_directory
-    # Set up git repos on the remote container
-    run_ssh "git config --global user.email 'test@example.com'"
-    run_ssh "git config --global user.name 'Test User'"
-    run_ssh "git config --global init.defaultBranch master"
-    run_ssh "mkdir -p ~/repos/testproject.git"
-    run_ssh "cd ~/repos/testproject.git && git init --bare"
-    run_ssh "git clone ~/repos/testproject.git ~/testproject"
-    run_ssh "mkdir -p ~/testproject/bin ~/testproject/db"
-
-    # bin/setup script
-    run_ssh "echo '#!/bin/bash' > ~/testproject/bin/setup"
-    run_ssh "echo 'echo Setup complete' >> ~/testproject/bin/setup"
-    run_ssh "chmod +x ~/testproject/bin/setup"
-
-    # bin/rake script for db:dump and db:load
-    run_ssh <<~'SETUP'
-      cat > ~/testproject/bin/rake << 'SCRIPT'
-#!/bin/bash
-case "$1" in
-  db:dump)
-    echo "production data" | gzip > db/data.sql.gz
-    ;;
-  db:load)
-    gunzip -c db/data.sql.gz > /dev/null
-    echo "Data loaded"
-    ;;
-esac
-SCRIPT
-    SETUP
-    run_ssh "chmod +x ~/testproject/bin/rake"
-    run_ssh "cd ~/testproject && git add . && git commit -m 'Initial commit'"
-    run_ssh "cd ~/testproject && git push origin master"
-
-    # Set up local git repo in isolated temp directory
-    setup_local_git_repo
-  end
-
-  def setup_local_git_repo
-    @test_dir = Dir.mktmpdir("bard_test")
-    @ssh_command = "ssh -i #{ssh_key_path} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
-
-    Dir.chdir(@test_dir) do
-      # Clone directly into the temp directory (pass SSH command via env, not global ENV)
-      ssh_url = "ssh://deploy@localhost:#{@ssh_port}/home/deploy/repos/testproject.git"
-      system({ "GIT_SSH_COMMAND" => @ssh_command }, "git clone #{ssh_url} .", out: File::NULL, err: File::NULL)
-
-      # Configure git settings locally in this repo only
-      system("git config user.email 'test@example.com'", out: File::NULL, err: File::NULL)
-      system("git config user.name 'Test User'", out: File::NULL, err: File::NULL)
-      system("git config core.sshCommand '#{@ssh_command}'", out: File::NULL, err: File::NULL)
-
-      # Ensure db directory exists locally
-      FileUtils.mkdir_p("db")
-
-      # Write bard config in the test directory
-      File.write("bard.rb", <<~RUBY)
-        target :production do
-          ssh "deploy@localhost:#{@ssh_port}",
-            path: "testproject",
-            ssh_key: "#{ssh_key_path}"
-          ping false
-        end
-      RUBY
-    end
-  end
-
-  def run_ssh(command)
-    stdout, status = Open3.capture2e(
-      "ssh", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null",
-      "-p", @ssh_port.to_s, "-i", ssh_key_path,
-      "deploy@localhost", command
-    )
-    unless status.success?
-      raise PrerequisiteError, "SSH command failed: #{command}\nOutput: #{stdout}"
-    end
-    true
-  end
-
-  def run_bard(command)
-    Dir.chdir(@test_dir) do
-      bard_coverage = File.join(ROOT, "features/support/bard-coverage")
-      @stdout, @status = Open3.capture2e("#{bard_coverage} #{command}")
-    end
-  end
-
-  def ssh_key_path
-    File.join(ROOT, "spec/acceptance/docker/test_key")
-  end
-
-  def stop_test_server
-    return unless @container
-    @container.stop rescue nil
-    @container.delete(force: true) rescue nil
-  ensure
-    @container = nil
-    @ssh_port = nil
-    FileUtils.rm_rf(@test_dir) if @test_dir
-    @test_dir = nil
-  end
-end
-
-World(TestServerWorld)
-
-Before do
-  start_test_server
-end
-
-After do
-  stop_test_server
-end

data/lib/bard/deprecation.rb

@@ -1,19 +0,0 @@
-module Bard
-  module Deprecation
-    @warned = {}
-
-    def self.warn(message, callsite: nil)
-      callsite ||= caller_locations(2, 1).first
-      key = "#{callsite.path}:#{callsite.lineno}:#{message}"
-      return if @warned[key]
-
-      @warned[key] = true
-      location = "#{callsite.path}:#{callsite.lineno}"
-      Kernel.warn "[DEPRECATION] #{message} (called from #{location})"
-    end
-
-    def self.reset!
-      @warned = {}
-    end
-  end
-end

data/lib/bard/plugin.rb

@@ -1,100 +0,0 @@
-module Bard
-  class Plugin
-    @registry = {}
-
-    class << self
-      attr_reader :registry
-
-      def register(name, &block)
-        plugin = new(name)
-        plugin.instance_eval(&block) if block
-        @registry[name.to_sym] = plugin
-      end
-
-      def [](name)
-        @registry[name.to_sym]
-      end
-
-      def all
-        @registry.values
-      end
-
-      def load_all!
-        Dir[File.join(__dir__, "plugins", "*.rb")].sort.each { |f| require f }
-        Dir[File.join(Dir.pwd, "lib", "bard", "plugins", "*.rb")].sort.each { |f| require f }
-        all.each(&:apply!)
-      end
-
-      def reset!
-        @registry = {}
-      end
-    end
-
-    attr_reader :name, :cli_modules
-
-    def initialize(name)
-      @name = name.to_sym
-      @cli_modules = []
-      @cli_requires = []
-      @target_methods = {}
-      @config_methods = {}
-      @requires = []
-    end
-
-    # DSL methods for defining plugins
-
-    def require_file(path)
-      @requires << path
-    end
-
-    def cli(mod, require: nil)
-      @cli_requires << require if require
-      @cli_modules << mod
-    end
-
-    def target_method(name, &block)
-      @target_methods[name] = block
-    end
-
-    def config_method(name, &block)
-      @config_methods[name] = block
-    end
-
-    # Apply plugin to the system (non-CLI parts)
-    def apply!
-      @requires.each { |path| require path }
-      apply_target_methods!
-      apply_config_methods!
-    end
-
-    def apply_to_cli(cli_class)
-      @cli_requires.each { |path| require path }
-      @cli_modules.each do |mod|
-        mod = resolve_constant(mod) if mod.is_a?(String)
-        mod.setup(cli_class)
-      end
-    end
-
-    private
-
-    def apply_target_methods!
-      return if @target_methods.empty?
-      require "bard/target"
-      @target_methods.each do |method_name, block|
-        Target.define_method(method_name, &block)
-      end
-    end
-
-    def apply_config_methods!
-      return if @config_methods.empty?
-      require "bard/config"
-      @config_methods.each do |method_name, block|
-        Config.define_method(method_name, &block)
-      end
-    end
-
-    def resolve_constant(name)
-      name.split("::").reduce(Object) { |mod, const| mod.const_get(const) }
-    end
-  end
-end

data/lib/bard/plugins/backup.rb

@@ -1,19 +0,0 @@
-require "bard/plugin"
-
-Bard::Plugin.register :backup do
-  config_method :backup do |value = nil, &block|
-    if block
-      @backup = Bard::BackupConfig.new(&block)
-    elsif value == false
-      @backup = Bard::BackupConfig.new { disabled }
-    elsif value.nil? # Getter
-      @backup ||= Bard::BackupConfig.new { bard }
-    else
-      raise ArgumentError, "backup accepts false or a block"
-    end
-  end
-
-  config_method :backup_enabled? do
-    backup == true
-  end
-end

data/lib/bard/plugins/github_pages.rb

@@ -1,34 +0,0 @@
-require "bard/plugin"
-
-# Load the deploy strategy (auto-registers via inherited hook)
-require "bard/deploy_strategy/github_pages"
-
-Bard::Plugin.register :github_pages do
-  # Config DSL: github_pages "url" sets up a production target
-  config_method :github_pages do |url|
-    urls = []
-    uri = url.start_with?("http") ? URI.parse(url) : URI.parse("https://#{url}")
-    hostname = uri.hostname.sub(/^www\./, "")
-    urls = [hostname]
-    urls << "www.#{hostname}" if hostname.count(".") < 2
-
-    target :production do
-      github_pages url
-      ssh false
-      ping(*urls) if urls.any?
-    end
-
-    backup false
-  end
-
-  # Target DSL: github_pages sets deploy strategy
-  target_method :github_pages do |url = nil|
-    if url.nil?
-      @github_pages_url
-    else
-      @deploy_strategy = :github_pages
-      @github_pages_url = url
-      enable_capability(:github_pages)
-    end
-  end
-end

data/lib/bard/plugins/hurt.rb

@@ -1,5 +0,0 @@
-require "bard/plugin"
-
-Bard::Plugin.register :hurt do
-  cli "Bard::CLI::Hurt", require: "bard/cli/hurt"
-end

data/lib/bard/plugins/install.rb

@@ -1,5 +0,0 @@
-require "bard/plugin"
-
-Bard::Plugin.register :install do
-  cli "Bard::CLI::Install", require: "bard/cli/install"
-end

data/lib/bard/plugins/jenkins.rb

@@ -1,6 +0,0 @@
-require "bard/plugin"
-
-Bard::Plugin.register :jenkins do
-  # Jenkins CI runner - auto-registers via inherited hook when loaded
-  require_file "bard/ci/jenkins"
-end

data/lib/bard/plugins/new.rb

@@ -1,5 +0,0 @@
-require "bard/plugin"
-
-Bard::Plugin.register :new do
-  cli "Bard::CLI::New", require: "bard/cli/new"
-end