bard 2.0.0.beta → 2.0.0

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,47 +1,22 @@
+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 'ruby-debug'
-require 'grit'
-require 'spec/expectations'
-gem 'sqlite3-ruby'
+require "bard"
+require 'rspec/expectations'
+require 'fileutils'
 
-ENV["PATH"] += ":#{File.dirname(File.expand_path(__FILE__))}/../../bin"
+ENV["PATH"] = "#{File.dirname(File.expand_path(__FILE__))}:#{ENV['PATH']}"
 ENV["GIT_DIR"] = nil
 ENV["GIT_WORK_TREE"] = nil
 ENV["GIT_INDEX_FILE"] = nil
 
 ROOT = File.expand_path(File.dirname(__FILE__) + '/../..')
 
-# setup fixtures
-if File.exist?("/dev/shm")
-  FileUtils.rm_rf "tmp"
-  tmp_dir = "/dev/shm/bard_testing_tmp"
-  FileUtils.rm_rf tmp_dir
-  FileUtils.mkdir tmp_dir
-  `ln -s #{tmp_dir} tmp`
-else
-  FileUtils.rm_rf "tmp"
-  FileUtils.mkdir "tmp"
-end
-
-Dir.chdir 'tmp' do
-  `git clone --mirror --recursive #{ROOT}/fixtures/repo origin.git`
-
-  `git clone --bare --recursive origin.git submodule_a.git`
-  `git clone --bare --recursive origin.git submodule_b.git`
-  %w(development_a development_b staging production).each do |env|
-    `git clone --recursive origin.git #{env}`
-    Dir.chdir env do
-      FileUtils.cp "config/database.sample.yml", "config/database.yml"
-      `grb track master`
-      `git checkout master`
-      unless env == "production"
-        `grb track integration`
-        `git checkout integration`
-      end
-    end
-  end
-  FileUtils.mkdir "fixtures"
-  Dir.foreach "." do |file|
-    FileUtils.mv(file, "fixtures/") unless %w(fixtures . ..).include? file
-  end
-end
+# Ensure tmp directory exists
+FileUtils.mkdir_p(File.join(ROOT, "tmp"))

data/features/support/test_server.rb

@@ -0,0 +1,216 @@
+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: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")
+      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("@server") do
+  start_test_server
+end
+
+After("@server") do
+  stop_test_server
+end

data/lib/bard/cli.rb

@@ -1,46 +1,27 @@
 # this file gets loaded in the CLI context, not the Rails boot context
 
 require "thor"
+require "bard/version"
 require "bard/config"
 require "bard/command"
-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",
-      open: "Open",
-      ssh: "SSH",
-      install: "Install",
-      ping: "Ping",
-      hurt: "Hurt",
-      vim: "Vim",
-    }.each do |command, klass|
-      require "bard/cli/#{command}"
-      include const_get(klass)
-    end
-
-    {
-      provision: "Provision",
-      new: "New",
-    }.each do |command, klass|
-      require "bard/cli/#{command}"
-      const_get(klass).setup(self)
+    map "--version" => :version
+    desc "version", "Display version"
+    def version
+      puts Bard::VERSION
     end
 
     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
@@ -49,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,42 +1,20 @@
 require "open3"
 
 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:
+    def self.run!(command, verbose: false, quiet: false)
+      result = run(command, verbose:, quiet:)
+      raise Error.new(command) unless result
+      result
     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
-      if !run(verbose:, quiet:)
-        raise Error.new(full_command)
-      end
-    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
@@ -46,45 +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
-
-      cmd = command
-      if ssh_server.env
-        cmd = "#{ssh_server.env} #{command}"
-      end
-      unless home
-        path = on.respond_to?(:path) ? on.path : ssh_server.path
-        cmd = "cd #{path} && #{cmd}" if path
-      end
-
-      ssh_key = ssh_server.ssh_key ? "-i #{ssh_server.ssh_key} " : ""
-      ssh_uri = ssh_server.respond_to?(:ssh_uri) ? ssh_server.ssh_uri : ssh_server.ssh_uri(:ssh)
-
-      cmd = "ssh -tt #{ssh_key} #{ssh_uri} '#{cmd}'"
-
-      if ssh_server.gateway
-        gateway_uri = ssh_server.respond_to?(:ssh_uri) ? ssh_server.gateway : ssh_server.ssh_uri(:gateway)
-        cmd = "ssh -tt #{gateway_uri} \"#{cmd}\""
-      end
-
-      cmd += " 2>&1" if quiet
-      cmd
+    def self.exec!(command)
+      Kernel.exec command
     end
   end
 end