bard 1.8.0 → 2.0.0.beta

data/features/step_definitions/rails_steps.rb

@@ -0,0 +1,44 @@
+Given /^a commit with a new migration$/ do
+  type "script/generate migration test_migration"
+  type "git add ."
+  type "git commit -am'added test migration.'"
+end
+
+Given /^a (\w+) database$/ do |env|
+  type "rake db:create RAILS_ENV=#{env} && rake db:migrate RAILS_ENV=#{env}"
+end
+
+Then /^the (\w+) database should include that migration$/ do |env|
+  db_version = type("rake db:version RAILS_ENV=#{env}")[/[0-9]{14}/]
+  migration_version = type("ls db/migrate/*_test_migration.rb")[/[0-9]{14}/]
+  db_version.should == migration_version
+end
+
+Given /^the test gem is not installed$/ do
+  type "gem uninstall rake-dotnet -v=0.0.1 -x"
+end
+
+Given /^a commit that adds the test gem as a dependency$/ do
+  file_inject "config/environment.rb", "
+Rails::Initializer.run do |config|", <<-RUBY
+  config.gem "rake-dotnet", :version => "0.0.1"
+RUBY
+  type "git add ."
+  type "git commit -am'added test gem dependency.'"
+end
+
+Then /^the test gem should be installed$/ do
+  type("gem list rake-dotnet").should include "rake-dotnet (0.0.1)"
+end
+
+Then /^passenger should have been restarted$/ do
+  File.exist?("tmp/restart.txt").should be_true
+end
+
+Given /^the "([^\"]+)" file includes "([^\"]+)"$/ do |file, contents|
+  file_append file, contents
+end
+
+Given /^the "([^\"]+)" file does not include "([^\"]+)"$/ do |file, contents|
+  gsub_file file, contents, ""
+end

data/features/step_definitions/submodule_steps.rb

@@ -0,0 +1,110 @@
+Given /^a submodule$/ do
+  Given 'on development_b, a commit with a new submodule'
+  Given 'on development_b, I type "bard push"'
+  Given 'I type "bard pull"'
+  @submodule_url = File.read(".gitmodules").match(/url = (.*)$/)[1]
+  @submodule_commit = type "git submodule status"
+end
+
+Given /^the submodule working directory is dirty$/ do
+  Dir.chdir "submodule" do
+    type "git checkout master"
+    type "echo 'submodule_update' > submodule_update"
+  end
+end
+
+Given /^a commit to the submodule$/ do
+  Dir.chdir "submodule" do
+    type "echo 'submodule_update' > submodule_update"
+    type "git add ."
+    type "git commit -am 'update in submodule'"
+  end
+end
+
+Given /^a commit with a new submodule$/ do
+  type "git submodule add #{ROOT}/tmp/submodule_a.git submodule"
+  type "git submodule update --init"
+  Dir.chdir "submodule" do
+    type "git checkout master"
+  end
+  type "git add ."
+  type "git commit -m 'added submodule'"
+end
+
+Given /^a commit with a submodule update$/ do
+  type "git checkout integration"
+  Dir.chdir "submodule" do
+    type "git checkout master"
+    type "echo 'submodule_update' > submodule_update"
+    type "git add ."
+    type "git commit -m 'update in submodule'"
+    type "git push origin HEAD"
+  end
+  type "git add ."
+  type "git commit -m 'updated submodule'"
+end
+
+Given /^a commit with a submodule url change$/ do
+  gsub_file ".gitmodules", "submodule_a.git", "submodule_b.git"
+  type "git add ."
+  type "git commit -m 'updated submodule url'"
+end
+
+Given /^I a commit a with a submodule deletion$/ do
+  type "rm .gitmodules"
+  type "rm -rf --cached submodule"
+  type "git add ."
+  type "git commit -am'removed submodule'"
+end
+
+Then /^there should be one new submodule$/ do
+  status = type "git submodule status"
+  status.should match /.[a-z0-9]{40} submodule/
+end
+
+Then /^the submodule branch should match the submodule origin branch$/ do
+  @submodule_url = File.read(".gitmodules").match(/url = (.*)$/)[1]
+  @submodule_commit = type "git submodule status"
+  @submodule_commit.should match %r( [a-z0-9]{40} submodule)
+  Dir.chdir "submodule" do
+    @submodule = Grit::Repo.new "."
+    branch = @submodule.head.name rescue nil
+    remote_branch = @submodule.remotes.find {|n| n.name == "origin/HEAD" }.commit.id[/\w+$/]
+    branch.should_not be_nil
+    remote_branch.should_not be_nil
+    branch.should == remote_branch
+    type("git rev-parse HEAD").should == type("git rev-parse origin/HEAD")
+    type("git name-rev --name-only HEAD").should == type("git name-rev --name-only origin/HEAD")
+  end
+end
+
+Then /^the submodule should be checked out$/ do
+  @submodule_url = File.read(".gitmodules").match(/url = (.*)$/)[1]
+  @submodule_commit = type "git submodule status"
+  @submodule_commit.should match %r( [a-z0-9]{40} submodule)
+end
+
+Then /^the submodule should be updated$/ do
+  @submodule_commit[/[a-z0-9]{40}/].should_not == type("git submodule status")[/[a-z0-9]{40}/]
+end
+
+Then /^the submodule url should be changed$/ do
+  Dir.chdir "submodule" do
+    remote = type "git remote show origin"
+    remote.should_not match %r(Fetch URL: #{@submodule_url}$)
+    remote.should_not match %r(Push  URL: #{@submodule_url}$)
+  end
+end
+
+Then /^the submodule should be deleted$/ do
+  Then 'the directory should not be dirty'
+  @submodule_commit = type "git submodule status"
+  @submodule_commit.should_not match /.[a-z0-9]{40} submodule/
+
+end
+
+Then /^the submodule working directory should be clean$/ do
+  Dir.chdir "submodule" do
+    type("git status").should include "working directory clean"
+  end
+end

data/features/support/env.rb

@@ -1,13 +1,47 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'rspec/expectations'
-require 'fileutils'
+require 'ruby-debug'
+require 'grit'
+require 'spec/expectations'
+gem 'sqlite3-ruby'
 
-ENV["PATH"] = "#{File.dirname(File.expand_path(__FILE__))}/../../bin:#{ENV['PATH']}"
+ENV["PATH"] += ":#{File.dirname(File.expand_path(__FILE__))}/../../bin"
 ENV["GIT_DIR"] = nil
 ENV["GIT_WORK_TREE"] = nil
 ENV["GIT_INDEX_FILE"] = nil
 
 ROOT = File.expand_path(File.dirname(__FILE__) + '/../..')
 
-# Ensure tmp directory exists
-FileUtils.mkdir_p(File.join(ROOT, "tmp"))
+# 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

data/features/support/grit_ext.rb

@@ -0,0 +1,13 @@
+Grit::Repo.class_eval do
+  def remote_branches(remote = "origin")
+    branches = self.remotes
+    branches.reject!  { |r| r.name !~ %r(^#{remote}/) }
+    branches.collect! { |r| r.name.split('/')[1] }
+    branches.reject!  { |b| b == "HEAD" }
+  end
+
+  def find_common_ancestor(head1, head2)
+    `git merge-base #{head1} #{head2}`.chomp
+  end
+end
+

data/features/support/io.rb

@@ -0,0 +1,32 @@
+require "open3"
+def type(command)
+  @stdout, @stderr, @status = Open3.capture3(@env, command)
+  if ENV['DEBUG']
+    puts '-' * 20
+    puts "Executing command: #{command}"
+    puts "  Status: #{@status}"
+    puts "  Stdout:\n #{@stdout}"
+    puts "  Stderr:\n #{@stderr}"
+    puts '-' * 20
+  end
+  @stdout || @stderr
+end
+
+def file_append(file_name, contents)
+  File.open(file_name, 'ab') { |file| file.puts("\n#{contents}") }
+end
+
+def file_inject(file_name, sentinel, string, before_after=:after)
+  gsub_file file_name, /(#{Regexp.escape(sentinel)})/mi do |match|
+    if before_after == :after
+      "#{match}\n#{string}"
+    else
+      "#{string}\n#{match}"
+    end
+  end
+end
+
+def gsub_file(file_name, regexp, *args, &block)
+  content = File.read(file_name).gsub(regexp, *args, &block)
+  File.open(file_name, 'wb') { |file| file.write(content) }
+end

data/features/support/podman.rb

@@ -0,0 +1,153 @@
+require "fileutils"
+require "open3"
+require "securerandom"
+require "shellwords"
+require "testcontainers"
+
+module PodmanWorld
+  class << self
+    attr_accessor :podman_available, :podman_image_built
+  end
+
+  class PrerequisiteError < StandardError; end
+
+  def ensure_podman_available
+    return if @podman_available || PodmanWorld.podman_available
+
+    raise PrerequisiteError, "podman is not installed or not on PATH" unless system("command -v podman >/dev/null 2>&1")
+
+    configure_podman_socket
+    ensure_bard_test_image
+    FileUtils.chmod(0o600, podman_ssh_key_path)
+
+    PodmanWorld.podman_available = true
+    @podman_available = true
+  end
+
+  def configure_podman_socket
+    return if ENV["DOCKER_HOST"]
+
+    podman_socket = "/run/user/#{Process.uid}/podman/podman.sock"
+    unless File.exist?(podman_socket)
+      system("systemctl --user start podman.socket 2>/dev/null || podman system service --time=0 unix://#{podman_socket} &")
+      sleep 2
+    end
+
+    raise PrerequisiteError, "Podman socket not available at #{podman_socket}" unless File.exist?(podman_socket)
+
+    ENV["DOCKER_HOST"] = "unix://#{podman_socket}"
+  end
+
+  def ensure_bard_test_image
+    return if @podman_image_built || PodmanWorld.podman_image_built
+
+    raise PrerequisiteError, "Unable to pull ubuntu:22.04 image" unless system("podman pull ubuntu:22.04 >/dev/null 2>&1")
+
+    docker_dir = File.join(ROOT, "spec/acceptance/docker")
+    dockerfile = File.join(docker_dir, "Dockerfile")
+    unless system("podman build -t bard-test-server -f #{dockerfile} #{docker_dir} 2>&1")
+      raise PrerequisiteError, "Failed to build bard test image"
+    end
+
+    PodmanWorld.podman_image_built = true
+    @podman_image_built = true
+  end
+
+  def start_podman_container
+    ensure_podman_available
+
+    @podman_container = Testcontainers::DockerContainer
+      .new("localhost/bard-test-server:latest")
+      .with_exposed_port(22)
+      .with_name("bard-test-#{SecureRandom.hex(4)}")
+      .start
+
+    @podman_ssh_port = @podman_container.mapped_port(22)
+    wait_for_ssh
+    run_ssh("mkdir -p testproject")
+    write_bard_config
+  end
+
+  def wait_for_ssh
+    30.times do
+      return if run_ssh("echo ready", quiet: true)
+      sleep 0.5
+    end
+
+    raise PrerequisiteError, "SSH in podman container did not become ready"
+  end
+
+  def write_bard_config
+    FileUtils.mkdir_p(File.join(ROOT, "tmp"))
+    @bard_config_path = File.join(ROOT, "tmp", "test_bard_#{SecureRandom.hex(4)}.rb")
+
+    File.write(@bard_config_path, <<~RUBY)
+      server :production do
+        ssh "deploy@localhost:#{@podman_ssh_port}"
+        path "testproject"
+        ssh_key "#{podman_ssh_key_path}"
+        ping false
+      end
+    RUBY
+  end
+
+  def run_ssh(command, quiet: false)
+    escaped = Shellwords.escape(command)
+    ssh_command = [
+      "ssh",
+      "-o", "StrictHostKeyChecking=no",
+      "-o", "ConnectTimeout=1",
+      "-p", @podman_ssh_port.to_s,
+      "-i", podman_ssh_key_path,
+      "deploy@localhost",
+      "--",
+      "bash",
+      "-lc",
+      escaped
+    ].join(" ")
+
+    quiet ? system("#{ssh_command} >/dev/null 2>&1") : system(ssh_command)
+  end
+
+  def run_bard_against_container(command)
+    Dir.chdir(File.join(ROOT, "tmp")) do
+      FileUtils.cp(@bard_config_path, "bard.rb")
+      @stdout, @status = Open3.capture2e(@env || {}, "bard run #{command}")
+      @stderr = ""
+      FileUtils.rm_f("bard.rb")
+    end
+  end
+
+  def podman_ssh_key_path
+    @podman_ssh_key_path ||= File.expand_path(File.join(ROOT, "spec/acceptance/docker/test_key"))
+  end
+
+  def stop_podman_container
+    FileUtils.rm_f(@bard_config_path) if @bard_config_path
+    return unless @podman_container
+
+    @podman_container.stop
+    @podman_container.remove
+  rescue StandardError => e
+    warn "Failed to cleanup podman container: #{e.message}"
+  ensure
+    @podman_container = nil
+    @podman_ssh_port = nil
+  end
+end
+
+World(PodmanWorld)
+
+Before("@podman") do
+  @env ||= {}
+
+  begin
+    start_podman_container
+  rescue PodmanWorld::PrerequisiteError => e
+    pending(e.message)
+  end
+end
+
+After("@podman") do
+  stop_podman_container
+end

data/lib/bard/command.rb

@@ -64,43 +64,24 @@ module Bard
       # 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
-
+      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_opts = ["-tt", "-o StrictHostKeyChecking=no", "-o UserKnownHostsFile=/dev/null", "-o LogLevel=ERROR"]
-      ssh_opts << "-i #{ssh_key}" if ssh_key
+      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)
 
-      # 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 -tt #{ssh_key} #{ssh_uri} '#{cmd}'"
 
-      cmd = "ssh #{ssh_opts.join(' ')} #{ssh_target} '#{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

data/lib/bard/config.rb

@@ -1,6 +1,5 @@
 require "bard/server"
 require "bard/target"
-require "bard/deprecation"
 
 module Bard
   class Config
@@ -44,7 +43,6 @@ module Bard
 
     # 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

data/lib/bard/copy.rb

@@ -29,16 +29,10 @@ module Bard
 
       ssh_key = ssh_server.ssh_key ? "-i #{ssh_server.ssh_key}" : ""
 
-      ssh_opts = "-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR"
-
-      # scp uses -P for port (uppercase, unlike ssh's -p)
-      port = ssh_server.port
-      port_opt = port && port.to_s != "22" ? "-P #{port}" : ""
-
-      from_and_to = [path, target_or_server.scp_uri(path).to_s]
+      from_and_to = [path, target_or_server.scp_uri(path)]
       from_and_to.reverse! if direction == :from
 
-      command = ["scp", ssh_opts, gateway, ssh_key, port_opt, *from_and_to].reject(&:empty?).join(" ")
+      command = ["scp", gateway, ssh_key, *from_and_to].join(" ")
       Bard::Command.run! command, verbose: verbose
     end
 
@@ -65,7 +59,18 @@ module Bard
       # Support both new Target (with server attribute) and old Server
       ssh_server = target_or_server.respond_to?(:server) ? target_or_server.server : target_or_server
 
-      ssh_uri = ssh_server.ssh_uri
+      # Get ssh_uri - it might be a URI object (old Server), string (new SSHServer), or mock
+      ssh_uri_value = ssh_server.respond_to?(:ssh_uri) ? ssh_server.ssh_uri : nil
+      if ssh_uri_value.respond_to?(:port)
+        # Already a URI-like object (old Server or mock)
+        ssh_uri = ssh_uri_value
+      elsif ssh_uri_value.is_a?(String)
+        # String from new SSHServer
+        ssh_uri = URI("ssh://#{ssh_uri_value}")
+      else
+        # Fallback
+        ssh_uri = ssh_uri_value
+      end
 
       gateway = ssh_server.gateway ? "-oProxyCommand=\"ssh #{ssh_server.gateway} -W %h:%p\"" : ""
 
@@ -86,13 +91,29 @@ module Bard
 
       raise NotImplementedError if from_server.gateway || to_server.gateway || from_server.ssh_key || to_server.ssh_key
 
-      from_uri = from_server.ssh_uri
-      to_uri = to_server.ssh_uri
+      # Get ssh_uri - it might be a URI object (old Server), string (new SSHServer), or mock
+      from_uri_value = from_server.respond_to?(:ssh_uri) ? from_server.ssh_uri : nil
+      if from_uri_value.respond_to?(:port)
+        from_uri = from_uri_value
+      elsif from_uri_value.is_a?(String)
+        from_uri = URI("ssh://#{from_uri_value}")
+      else
+        from_uri = from_uri_value
+      end
+
+      to_uri_value = to_server.respond_to?(:ssh_uri) ? to_server.ssh_uri : nil
+      if to_uri_value.respond_to?(:port)
+        to_uri = to_uri_value
+      elsif to_uri_value.is_a?(String)
+        to_uri = URI("ssh://#{to_uri_value}")
+      else
+        to_uri = to_uri_value
+      end
 
       from_str = "-p#{from_uri.port || 22} #{from_uri.user}@#{from_uri.host}"
       to_str = to.rsync_uri(path).sub(%r(/[^/]+$), '/')
 
-      command = %(ssh -A #{from_str} 'rsync -e \"ssh -A -p#{to_uri.port || 22} -o StrictHostKeyChecking=no -o LogLevel=ERROR\" --delete --info=progress2 -az #{from.path}/#{path} #{to_str}')
+      command = %(ssh -A #{from_str} 'rsync -e \"ssh -A -p#{to_uri.port || 22} -o StrictHostKeyChecking=no\" --delete --info=progress2 -az #{from.path}/#{path} #{to_str}')
       Bard::Command.run! command, verbose: verbose
     end
   end

data/lib/bard/server.rb

@@ -1,7 +1,6 @@
 require "uri"
 require "bard/command"
 require "bard/copy"
-require "bard/deprecation"
 
 module Bard
   class Server < Struct.new(:project_name, :key, :ssh, :path, :ping, :gateway, :ssh_key, :env, :github_pages)
@@ -25,24 +24,7 @@ module Bard
       end
     end
 
-    def self.setting_with_deprecation *fields, message:
-      fields.each do |field|
-        define_method field do |*args|
-          if args.length == 1
-            Deprecation.warn message
-            send :"#{field}=", args.first
-          elsif args.length == 0
-            super()
-          else
-            raise ArgumentError
-          end
-        end
-      end
-    end
-
-    setting :ssh, :ping, :github_pages
-    setting_with_deprecation :gateway, :ssh_key, :env,
-      message: "Separate SSH options are deprecated; pass as keyword arguments to `ssh` instead, e.g., `ssh \"user@host\", path: \"/app\"` (will be removed in v2.0)"
+    setting :ssh, :path, :ping, :gateway, :ssh_key, :env, :github_pages
 
     def ping(*args)
       if args.length == 0
@@ -68,7 +50,6 @@ module Bard
 
     def path(*args)
       if args.length == 1
-        Deprecation.warn "Separate SSH options are deprecated; pass as keyword arguments to `ssh` instead, e.g., `ssh \"user@host\", path: \"/app\"` (will be removed in v2.0)"
         self.path = args.first
       elsif args.length == 0
         super() || project_name
@@ -77,34 +58,11 @@ module Bard
       end
     end
 
-    def strategy(name)
-      Deprecation.warn "`strategy` is deprecated; use the strategy method directly, e.g., `jets \"url\"` instead of `strategy :jets` (will be removed in v2.0)"
-      @strategy = name
-    end
-
-    def option(key, value)
-      Deprecation.warn "`option` is deprecated; pass options as keyword arguments to the strategy method, e.g., `jets \"url\", run_tests: true` (will be removed in v2.0)"
-      @options ||= {}
-      @options[key] = value
-    end
-
-    def strategy_name
-      @strategy
-    end
-
-    def strategy_options
-      @options || {}
-    end
-
     def ssh_uri which=:ssh
       value = send(which)
       URI("ssh://#{value}")
     end
 
-    def port
-      ssh_uri.port || 22
-    end
-
     def scp_uri file_path=nil
       ssh_uri.dup.tap do |uri|
         uri.scheme = "scp"

data/lib/bard/ssh_server.rb

@@ -23,7 +23,7 @@ module Bard
     end
 
     def ssh_uri
-      URI("ssh://#{user}@#{host}:#{port}")
+      "#{user}@#{host}:#{port}"
     end
 
     def hostname