bard 1.9.6 → 2.0.0

data/lib/bard/provision/swapfile.rb

@@ -1,23 +0,0 @@
-# setup swapfile
-
-class Bard::Provision::Swapfile < Bard::Provision
-  def call
-    print "Swapfile:"
-
-    provision_server.run! <<~SH, home: true
-      if [ ! -f /swapfile ]; then
-        sudo fallocate -l $(grep MemTotal /proc/meminfo | awk '{print $2}')K /swapfile
-      fi
-      sudo chmod 600 /swapfile
-      sudo swapon --show | grep -q '/swapfile' || sudo mkswap /swapfile
-      sudo swapon --show | grep -q '/swapfile' || sudo swapon /swapfile
-      grep -q '/swapfile none swap sw 0 0' /etc/fstab || echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
-    SH
-
-    provision_server.run! "sudo swapon --show | grep -q /swapfile", home: true
-
-    puts " ✓"
-  end
-end
-
-

data/lib/bard/provision/user.rb

@@ -1,42 +0,0 @@
-# rename user
-
-class Bard::Provision::User < Bard::Provision
-  def call
-    print "User:"
-
-    if !ssh_with_user?(provision_server.ssh_uri, user: new_user)
-      if !ssh_with_user?(provision_server.ssh_uri)
-        raise "can't ssh in with user #{new_user} or #{old_user}"
-      end
-      print " Adding user #{new_user},"
-      provision_server.run! [
-        "sudo useradd -m -s /bin/bash #{new_user}",
-        "sudo usermod -aG sudo #{new_user}",
-        "echo \"#{new_user} ALL=(ALL) NOPASSWD:ALL\" | sudo tee -a /etc/sudoers",
-        "sudo mkdir -p ~#{new_user}/.ssh",
-        "sudo cp ~/.ssh/authorized_keys ~#{new_user}/.ssh/authorized_keys",
-        "sudo chown -R #{new_user}:#{new_user} ~#{new_user}/.ssh",
-        "sudo chmod +rx ~#{new_user}", # so nginx and passenger can read it
-      ].join("; "), home: true
-    end
-
-    # provision with new user from now on
-    ssh_url.gsub!("#{old_user}@", "#{new_user}@")
-    puts " ✓"
-  end
-
-  private
-
-  def new_user
-    server.ssh_uri.user
-  end
-
-  def old_user
-    provision_server.ssh_uri.user
-  end
-
-  def ssh_with_user? ssh_uri, user: ssh_uri.user
-    system "ssh -o ConnectTimeout=2 -p#{ssh_uri.port || 22} #{user}@#{ssh_uri.host} : >/dev/null 2>&1"
-  end
-end
-

data/lib/bard/provision.rb

@@ -1,16 +0,0 @@
-module Bard
-  class Provision < Struct.new(:config, :ssh_url)
-    def self.call(...) = new(...).call
-
-    private
-
-    def server
-      config[:production]
-    end
-
-    def provision_server
-      server.with(ssh: ssh_url)
-    end
-  end
-end
-

data/lib/bard/server.rb

@@ -1,160 +0,0 @@
-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)
-    def self.define project_name, key, &block
-      new(project_name, key).tap do |server|
-        server.instance_eval &block
-      end
-    end
-
-    def self.setting *fields
-      fields.each do |field|
-        define_method field do |*args|
-          if args.length == 1
-            send :"#{field}=", args.first
-          elsif args.length == 0
-            super()
-          else
-            raise ArgumentError
-          end
-        end
-      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)"
-
-    def ping(*args)
-      if args.length == 0
-        (super() || [nil]).map(&method(:normalize_ping)).flatten
-      else
-        self.ping = args
-      end
-    end
-
-    private def normalize_ping value
-      return [] if value == false
-      normalized = "https://#{ssh_uri.host}" # default if none specified
-      if value =~ %r{^/}
-        normalized += value
-      elsif value.to_s.length > 0
-        normalized = value
-      end
-      if normalized !~ /^http/
-        normalized = "https://#{normalized}"
-      end
-      normalized
-    end
-
-    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
-      else
-        raise ArgumentError
-      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"
-        uri.path = "/#{path}"
-        uri.path += "/#{file_path}" if file_path
-      end
-    end
-
-    def rsync_uri file_path=nil
-      str = ssh_uri.dup.tap do |uri|
-        uri.send :set_scheme, nil
-        uri.send :set_port, nil
-      end.to_s[2..]
-      str += ":#{path}"
-      str += "/#{file_path}" if file_path
-      str
-    end
-
-    def with(attrs)
-      dup.tap do |s|
-        attrs.each do |key, value|
-          s.send key, value
-        end
-      end
-    end
-
-    def to_sym
-      key
-    end
-
-    def run! command, home: false, verbose: false, quiet: false, capture: false
-      result = Bard::Command.run!(command, on: self, home:, verbose:, quiet:)
-      result if capture
-    end
-
-    def run command, home: false, verbose: false, quiet: false
-      Bard::Command.run command, on: self, home:, verbose:, quiet:
-    end
-
-    def exec! command, home: false
-      Bard::Command.exec! command, on: self, home:
-    end
-
-    def copy_file path, to:, verbose: false
-      Bard::Copy.file path, from: self, to:, verbose:
-    end
-
-    def copy_dir path, to:, verbose: false
-      Bard::Copy.dir path, from: self, to:, verbose:
-    end
-  end
-end
-

data/spec/bard/cli/command_spec.rb

@@ -1,50 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-require "bard/cli/command"
-
-class TestCommand < Bard::CLI::Command
-  desc "test_command", "test command description"
-  option :verbose, type: :boolean
-
-  def test_command
-    "executed"
-  end
-end
-
-describe Bard::CLI::Command do
-  let(:cli_mock) { double("cli") }
-  let(:command) { TestCommand.new(cli_mock) }
-
-  describe ".desc" do
-    it "sets command and description" do
-      expect(TestCommand.instance_variable_get(:@command)).to eq("test_command")
-      expect(TestCommand.instance_variable_get(:@description)).to eq("test command description")
-    end
-  end
-
-  describe ".option" do
-    it "sets option arguments" do
-      expect(TestCommand.instance_variable_get(:@option_args)).to eq([:verbose])
-      expect(TestCommand.instance_variable_get(:@option_kwargs)).to eq({type: :boolean})
-    end
-  end
-
-  describe ".setup" do
-    let(:cli_double) { double("cli") }
-
-    it "sets up the command on the CLI class" do
-      expect(cli_double).to receive(:desc).with("test_command", "test command description")
-      expect(cli_double).to receive(:option).with(:verbose, type: :boolean)
-      expect(cli_double).to receive(:define_method)
-
-      TestCommand.setup(cli_double)
-    end
-  end
-
-  describe "delegation" do
-    it "should delegate to the wrapped object" do
-      allow(cli_mock).to receive(:some_method).and_return("delegated")
-      expect(command.some_method).to eq("delegated")
-    end
-  end
-end

data/spec/bard/cli/new_spec.rb

@@ -1,73 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-require "bard/cli/new"
-
-describe Bard::CLI::New do
-  let(:new_cli) { Bard::CLI::New.new(double("cli")) }
-
-  before do
-    allow(new_cli).to receive(:puts)
-    allow(new_cli).to receive(:exit)
-    allow(new_cli).to receive(:run!)
-    allow(new_cli).to receive(:green).and_return("")
-    allow(new_cli).to receive(:red).and_return("")
-    allow(new_cli).to receive(:yellow).and_return("")
-    allow(File).to receive(:read).and_return("master_key_content")
-  end
-
-  describe "#new" do
-    context "with invalid project name" do
-      before do
-        allow(new_cli).to receive(:create_project)
-        allow(new_cli).to receive(:push_to_github)
-        allow(new_cli).to receive(:stage)
-      end
-
-      it "should reject names starting with uppercase" do
-        expect(new_cli).to receive(:puts).with(/Invalid project name/)
-        expect(new_cli).to receive(:exit).with(1)
-
-        new_cli.new("InvalidProject")
-      end
-
-      it "should reject names with special characters" do
-        expect(new_cli).to receive(:puts).with(/Invalid project name/)
-        expect(new_cli).to receive(:exit).with(1)
-
-        new_cli.new("invalid-project")
-      end
-
-      it "should reject names starting with numbers" do
-        expect(new_cli).to receive(:puts).with(/Invalid project name/)
-        expect(new_cli).to receive(:exit).with(1)
-
-        new_cli.new("1invalidproject")
-      end
-    end
-  end
-
-  describe "#ruby_version" do
-    it "returns the ruby version" do
-      expect(new_cli.send(:ruby_version)).to eq("ruby-3.4.2")
-    end
-  end
-
-  describe "#template_path" do
-    it "returns the path to the rails template" do
-      expect(new_cli.send(:template_path)).to match(/new_rails_template\.rb$/)
-    end
-  end
-
-  describe "#install_and_extract_version" do
-    it "correctly installs a gem and extracts its version", skip: !!ENV["CI"] do
-      cmd = new_cli.send :build_bash_env do
-        <<~SH
-          #{new_cli.send(:build_gem_install, "bundler", "~> 2.0")}
-          echo ${GEM_VERSION}
-        SH
-      end
-      result = `#{cmd}`.strip
-      expect(result).to match(/^2\.\d+\.\d+/)
-    end
-  end
-end

data/spec/bard/cli/provision_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-require "bard/cli/provision"
-
-describe Bard::CLI::Provision do
-  let(:config) { { production: double("production", ssh: "user@example.com") } }
-  let(:provision_cli) { Bard::CLI::Provision.new(double("cli")) }
-
-  before do
-    allow(provision_cli).to receive(:config).and_return(config)
-    allow(provision_cli).to receive(:options).and_return({ steps: ["SSH", "User"] })
-  end
-
-  describe "STEPS constant" do
-    it "defines the provisioning steps" do
-      expect(Bard::CLI::Provision::STEPS).to include("SSH", "User", "Apt", "MySQL", "Deploy")
-      expect(Bard::CLI::Provision::STEPS).to be_a(Array)
-    end
-  end
-
-  describe "#provision" do
-    it "should run provision steps" do
-      expect(Bard::Provision).to receive(:const_get).with("SSH").and_return(double("ssh_step", call: true))
-      expect(Bard::Provision).to receive(:const_get).with("User").and_return(double("user_step", call: true))
-
-      provision_cli.provision
-    end
-
-    it "should use production ssh by default" do
-      allow(Bard::Provision).to receive(:const_get).and_return(double("step", call: true))
-
-      provision_cli.provision
-    end
-
-    it "should accept custom ssh_url" do
-      custom_ssh = "root@newserver.com"
-      allow(Bard::Provision).to receive(:const_get).and_return(double("step", call: true))
-
-      provision_cli.provision(custom_ssh)
-    end
-  end
-end

data/spec/bard/deprecation_spec.rb

@@ -1,281 +0,0 @@
-require "bard/deprecation"
-require "bard/config"
-require "bard/server"
-
-describe Bard::Deprecation do
-  before do
-    Bard::Deprecation.reset!
-  end
-
-  describe ".warn" do
-    it "outputs a deprecation warning to stderr" do
-      expect {
-        Bard::Deprecation.warn "test message"
-      }.to output(/\[DEPRECATION\] test message/).to_stderr
-    end
-
-    it "includes the callsite location" do
-      output = capture_stderr { Bard::Deprecation.warn "test message" }
-      expect(output).to match(/called from.*deprecation_spec\.rb/)
-    end
-
-    it "only warns once per callsite" do
-      output = capture_stderr do
-        3.times { Bard::Deprecation.warn "repeated message" }
-      end
-      expect(output.scan(/\[DEPRECATION\]/).count).to eq 1
-    end
-
-    it "warns separately for different callsites" do
-      output = capture_stderr do
-        Bard::Deprecation.warn "message 1"
-        Bard::Deprecation.warn "message 2"
-      end
-      expect(output.scan(/\[DEPRECATION\]/).count).to eq 2
-    end
-  end
-
-  describe ".reset!" do
-    it "clears the warning cache" do
-      capture_stderr { Bard::Deprecation.warn "test" }
-      Bard::Deprecation.reset!
-      output = capture_stderr { Bard::Deprecation.warn "test" }
-      expect(output).to include("[DEPRECATION]")
-    end
-  end
-
-  def capture_stderr
-    original_stderr = $stderr
-    $stderr = StringIO.new
-    yield
-    $stderr.string
-  ensure
-    $stderr = original_stderr
-  end
-end
-
-describe "Deprecation warnings" do
-  before do
-    Bard::Deprecation.reset!
-  end
-
-  def capture_stderr
-    original_stderr = $stderr
-    $stderr = StringIO.new
-    yield
-    $stderr.string
-  ensure
-    $stderr = original_stderr
-  end
-
-  describe "Config#server" do
-    it "warns when using server instead of target" do
-      output = capture_stderr do
-        Bard::Config.new("test", source: <<~SOURCE)
-          server :production do
-            ssh "user@host:22"
-          end
-        SOURCE
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("`server` is deprecated")
-      expect(output).to include("use `target` instead")
-    end
-
-    it "does not warn when using target" do
-      output = capture_stderr do
-        Bard::Config.new("test", source: <<~SOURCE)
-          target :production do
-            ssh "user@host:22"
-          end
-        SOURCE
-      end
-      expect(output).not_to include("[DEPRECATION]")
-    end
-  end
-
-  describe "Server SSH options" do
-    it "warns when using separate path method" do
-      output = capture_stderr do
-        Bard::Server.define("test", :production) do
-          ssh "user@host:22"
-          path "/app"
-        end
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("Separate SSH options are deprecated")
-    end
-
-    it "warns when using separate gateway method" do
-      output = capture_stderr do
-        Bard::Server.define("test", :production) do
-          ssh "user@host:22"
-          gateway "bastion@host:22"
-        end
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("Separate SSH options are deprecated")
-    end
-
-    it "warns when using separate ssh_key method" do
-      output = capture_stderr do
-        Bard::Server.define("test", :production) do
-          ssh "user@host:22"
-          ssh_key "~/.ssh/id_rsa"
-        end
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("Separate SSH options are deprecated")
-    end
-
-    it "warns when using separate env method" do
-      output = capture_stderr do
-        Bard::Server.define("test", :production) do
-          ssh "user@host:22"
-          env "RAILS_ENV=production"
-        end
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("Separate SSH options are deprecated")
-    end
-  end
-
-  describe "Server strategy configuration" do
-    it "warns when using strategy method" do
-      output = capture_stderr do
-        Bard::Server.define("test", :production) do
-          ssh "user@host:22"
-          strategy :custom
-        end
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("`strategy` is deprecated")
-    end
-
-    it "warns when using option method" do
-      output = capture_stderr do
-        Bard::Server.define("test", :production) do
-          ssh "user@host:22"
-          option :run_tests, true
-        end
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("`option` is deprecated")
-    end
-
-    it "stores strategy name for backward compatibility" do
-      server = nil
-      capture_stderr do
-        server = Bard::Server.define("test", :production) do
-          ssh "user@host:22"
-          strategy :jets
-        end
-      end
-      expect(server.strategy_name).to eq :jets
-    end
-
-    it "stores strategy options for backward compatibility" do
-      server = nil
-      capture_stderr do
-        server = Bard::Server.define("test", :production) do
-          ssh "user@host:22"
-          option :run_tests, true
-          option :verbose, false
-        end
-      end
-      expect(server.strategy_options).to eq({ run_tests: true, verbose: false })
-    end
-  end
-
-  describe "Target (new API)" do
-    it "does not warn when using hash options with ssh" do
-      output = capture_stderr do
-        Bard::Config.new("test", source: <<~SOURCE)
-          target :production do
-            ssh "user@host:22", path: "/app", gateway: "bastion@host:22"
-          end
-        SOURCE
-      end
-      expect(output).not_to include("[DEPRECATION]")
-    end
-
-    it "warns when using separate path method" do
-      output = capture_stderr do
-        Bard::Config.new("test", source: <<~SOURCE)
-          target :production do
-            ssh "user@host:22"
-            path "/app"
-          end
-        SOURCE
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("Separate `path` call is deprecated")
-    end
-
-    it "warns when using separate gateway method" do
-      output = capture_stderr do
-        Bard::Config.new("test", source: <<~SOURCE)
-          target :production do
-            ssh "user@host:22"
-            gateway "bastion@host:22"
-          end
-        SOURCE
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("Separate `gateway` call is deprecated")
-    end
-
-    it "warns when using separate ssh_key method" do
-      output = capture_stderr do
-        Bard::Config.new("test", source: <<~SOURCE)
-          target :production do
-            ssh "user@host:22"
-            ssh_key "~/.ssh/id_rsa"
-          end
-        SOURCE
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("Separate `ssh_key` call is deprecated")
-    end
-
-    it "warns when using separate env method" do
-      output = capture_stderr do
-        Bard::Config.new("test", source: <<~SOURCE)
-          target :production do
-            ssh "user@host:22"
-            env "RAILS_ENV=production"
-          end
-        SOURCE
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("Separate `env` call is deprecated")
-    end
-
-    it "warns when using strategy method" do
-      output = capture_stderr do
-        Bard::Config.new("test", source: <<~SOURCE)
-          target :production do
-            ssh "user@host:22"
-            strategy :ssh
-          end
-        SOURCE
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("`strategy` is deprecated")
-    end
-
-    it "warns when using option method" do
-      output = capture_stderr do
-        Bard::Config.new("test", source: <<~SOURCE)
-          target :production do
-            ssh "user@host:22"
-            strategy :ssh
-            option :verbose, true
-          end
-        SOURCE
-      end
-      expect(output).to include("[DEPRECATION]")
-      expect(output).to include("`option` is deprecated")
-    end
-  end
-end