bard-new 0.1.0

data/spec/acceptance/docker/test_key

@@ -0,0 +1,27 @@
+-----BEGIN OPENSSH PRIVATE KEY-----
+b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABFwAAAAdzc2gtcn
+NhAAAAAwEAAQAAAQEAuvnrkoVh6AISBhqUOtmvTf6TMoq/Do6i/ayn1aqs9YmbN57tNVnY
+XEKBQ15HL5bquY0A4Fcf5mO73LyrHGdUODrJS6vZo4J8wcoyEyKxOC2UYV5ssCUntq13de
+E4WVHfSykMEo9z3U7bxFSwtwU8ECYQHKLb4OBmQb4hp/nDvx4EM554laBUByGm8fgSKOlY
+GEdWE0KAFVsKfkRW8AiR2RtQ5C1hIT/zCmHo01WTtHMpuyZk4cxpBlS3xz6wsD61f6SgMh
+M0X575jfV/MxhbDd3FGkxIk8kM24DtLfLW9idYWDD25dfQuXK3eQZDJ3vcoKa+2W73XfHd
+fBrAGrvjaQAAA8jQXv0u0F79LgAAAAdzc2gtcnNhAAABAQC6+euShWHoAhIGGpQ62a9N/p
+Myir8OjqL9rKfVqqz1iZs3nu01WdhcQoFDXkcvluq5jQDgVx/mY7vcvKscZ1Q4OslLq9mj
+gnzByjITIrE4LZRhXmywJSe2rXd14ThZUd9LKQwSj3PdTtvEVLC3BTwQJhAcotvg4GZBvi
+Gn+cO/HgQznniVoFQHIabx+BIo6VgYR1YTQoAVWwp+RFbwCJHZG1DkLWEhP/MKYejTVZO0
+cym7JmThzGkGVLfHPrCwPrV/pKAyEzRfnvmN9X8zGFsN3cUaTEiTyQzbgO0t8tb2J1hYMP
+bl19C5crd5BkMne9ygpr7Zbvdd8d18GsAau+NpAAAAAwEAAQAAAQACxR+WkYfNtbQkfNcm
+gmGXZ0wGeGmUCAxwSNMetlMu0GL+jAn0cPg52660ZmHpxFOwu971Xo0QLyOSGwXHm1ydza
+R8TMI3atWO0xWdVMr+gPxdBJavIF8ff3U7h5fmXjEPmRQpn+WbSScL2FEFkRwJRYsWZYTv
+kVt/zKw3zm/g4Fo7ieeM51heWDOVbNdCk0dcy2YK0L7Kb0FO+zvu3vxXrvWAqKmuRjxefc
+FiumkkgaTn78ZIHdfYZa26PmZPIUxVNxRkauvHxYo921t634O0Ji1gwbT5hK8Y7JoGRIp0
+alwgjjdbE80ZPuTspmeHQ7OKephb+c8qvoJu/LC8hQiBAAAAgCFGqbOsY9AcIfXY4hlADt
+94P5ySq5q3FbXeriy/CEklDPVER/w4iZaSRwMUqd7V36iZaLwHZyFQSNgIwiN1ysBPbcsq
+c642pv4XuAyNTMtD+y8CxcH1LgL7EOEn6if8cgTJ7ayTGT4qIDaUgzf6Ot8z4wDGNKyCpE
+lgPfdb8LKiAAAAgQDbrXnetOikB9+p+vf8M59UlfMYx7X9qLDsj0CUn1S0RyxgPWiJDBQl
+fZg7WyYOQwRYF0b0s8JlpGLkhLDM6nhBzT1M+nrN0axTAvYkBZV5MJPNg31F/iHxEtt+/V
+fMkH6VhmscVyiwEJkDP212dTAaDW3UremlRk77NIZ1PpPKKQAAAIEA2eRCJwNOvdsHYoJ6
+k6mEpwISzglbs+y6tTeIwiI7AVGEzvVuKVTCV3n9ljofmnh0UChczIOyywEKSqJi2pos/B
+kJoOmCxYMecB9lCxf61MUKdbpWaKF52+GvqT34Ne+VrYGuUp/0+asSTczVudJWRSzcdCji
+NEMB0tV88Vro90EAAAANYmFyZC10ZXN0LWtleQECAwQFBg==
+-----END OPENSSH PRIVATE KEY-----

data/spec/acceptance/docker/test_key.pub

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC6+euShWHoAhIGGpQ62a9N/pMyir8OjqL9rKfVqqz1iZs3nu01WdhcQoFDXkcvluq5jQDgVx/mY7vcvKscZ1Q4OslLq9mjgnzByjITIrE4LZRhXmywJSe2rXd14ThZUd9LKQwSj3PdTtvEVLC3BTwQJhAcotvg4GZBviGn+cO/HgQznniVoFQHIabx+BIo6VgYR1YTQoAVWwp+RFbwCJHZG1DkLWEhP/MKYejTVZO0cym7JmThzGkGVLfHPrCwPrV/pKAyEzRfnvmN9X8zGFsN3cUaTEiTyQzbgO0t8tb2J1hYMPbl19C5crd5BkMne9ygpr7Zbvdd8d18GsAau+Np bard-test-key

data/spec/bard/new/cli/new_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+describe "bard new" do
+  let(:cli) { Bard::CLI.new }
+
+  before do
+    allow(cli).to receive(:puts)
+    allow(cli).to receive(:exit)
+    allow(cli).to receive(:run!)
+    allow(cli).to receive(:green).and_return("")
+    allow(cli).to receive(:red).and_return("")
+    allow(cli).to receive(:yellow).and_return("")
+    allow(File).to receive(:read).and_return("master_key_content")
+  end
+
+  describe "#new" do
+    context "with --skip-github and --skip-stage" do
+      let(:cli) { Bard::CLI.new([], skip_github: true, skip_stage: true) }
+
+      before do
+        allow(cli).to receive(:new_create_project)
+      end
+
+      it "skips github and stage steps" do
+        expect(cli).not_to receive(:new_push_to_github)
+        expect(cli).not_to receive(:new_stage)
+        cli.new("testproject")
+      end
+    end
+
+    context "with invalid project name" do
+      before do
+        allow(cli).to receive(:new_create_project)
+        allow(cli).to receive(:new_push_to_github)
+        allow(cli).to receive(:new_stage)
+      end
+
+      it "should reject names starting with uppercase" do
+        expect(cli).to receive(:puts).with(/Invalid project name/)
+        expect(cli).to receive(:exit).with(1)
+
+        cli.new("InvalidProject")
+      end
+
+      it "should reject names with special characters" do
+        expect(cli).to receive(:puts).with(/Invalid project name/)
+        expect(cli).to receive(:exit).with(1)
+
+        cli.new("invalid-project")
+      end
+
+      it "should reject names starting with numbers" do
+        expect(cli).to receive(:puts).with(/Invalid project name/)
+        expect(cli).to receive(:exit).with(1)
+
+        cli.new("1invalidproject")
+      end
+    end
+  end
+
+  describe "#new_ruby_version" do
+    it "returns the ruby version" do
+      expect(cli.send(:new_ruby_version)).to eq("ruby-4.0.2")
+    end
+  end
+
+  describe "#new_template_path" do
+    it "returns the path to the rails template" do
+      expect(cli.send(:new_template_path)).to match(/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 = cli.send :new_build_bash_env do
+        <<~SH
+          #{cli.send(:new_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/new/cli/provision_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe "bard provision" do
+  let(:config) { { production: double("production", ssh: "user@example.com") } }
+  let(:cli) { Bard::CLI.new }
+
+  before do
+    allow(cli).to receive(:config).and_return(config)
+    allow(cli).to receive(:options).and_return({ steps: ["SSH", "User"] })
+  end
+
+  describe "PROVISION_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))
+
+      cli.provision
+    end
+
+    it "should use production ssh by default" do
+      allow(Bard::Provision).to receive(:const_get).and_return(double("step", call: true))
+
+      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))
+
+      cli.provision(custom_ssh)
+    end
+  end
+end

data/spec/bard/new/provision/app_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "bard/new/provision/base"
+require "bard/new/provision/app"
+
+describe Bard::Provision::App do
+  let(:config) { { production: double("production") } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:app) { Bard::Provision::App.new(config, ssh_url) }
+
+  before do
+    allow(app).to receive(:provision_server).and_return(provision_server)
+    allow(app).to receive(:print)
+    allow(app).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "runs bin/setup on the server" do
+      expect(provision_server).to receive(:run!).with("bin/setup")
+
+      app.call
+    end
+
+    it "prints status messages" do
+      allow(provision_server).to receive(:run!)
+
+      expect(app).to receive(:print).with("App:")
+      expect(app).to receive(:puts).with(" ✓")
+
+      app.call
+    end
+  end
+end

data/spec/bard/new/provision/apt_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+require "bard/new/provision/base"
+require "bard/new/provision/apt"
+
+describe Bard::Provision::Apt do
+  let(:config) { { production: double("production") } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:apt) { Bard::Provision::Apt.new(config, ssh_url) }
+
+  before do
+    allow(apt).to receive(:provision_server).and_return(provision_server)
+    allow(apt).to receive(:print)
+    allow(apt).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "updates and installs packages on the server" do
+      expected_commands = [
+        %(echo "\\$nrconf{restart} = \\"a\\";" | sudo tee /etc/needrestart/conf.d/90-autorestart.conf),
+        "sudo apt-get update -y",
+        "sudo apt-get upgrade -y",
+        "sudo apt-get install -y curl build-essential libsodium-dev"
+      ].join("; ")
+
+      expect(provision_server).to receive(:run!).with(expected_commands, home: true)
+
+      apt.call
+    end
+
+    it "prints status messages" do
+      allow(provision_server).to receive(:run!)
+      expect(apt).to receive(:print).with("Apt:")
+      expect(apt).to receive(:puts).with(" ✓")
+
+      apt.call
+    end
+  end
+end

data/spec/bard/new/provision/authorizedkeys_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "bard/new/provision/base"
+require "bard/new/provision/authorizedkeys"
+
+describe Bard::Provision::AuthorizedKeys do
+  let(:config) { { production: double("production") } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:authorized_keys) { Bard::Provision::AuthorizedKeys.new(config, ssh_url) }
+
+  before do
+    allow(authorized_keys).to receive(:provision_server).and_return(provision_server)
+    allow(authorized_keys).to receive(:print)
+    allow(authorized_keys).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "adds authorized keys to the server" do
+      expect(provision_server).to receive(:run!).at_least(:once).with(/grep -F -q/, home: true)
+
+      authorized_keys.call
+    end
+
+    it "prints status messages" do
+      allow(provision_server).to receive(:run!)
+      expect(authorized_keys).to receive(:print).with("Authorized Keys:")
+      expect(authorized_keys).to receive(:puts).with(" ✓")
+
+      authorized_keys.call
+    end
+  end
+
+  describe "KEYS constant" do
+    it "should have predefined SSH keys" do
+      expect(Bard::Provision::AuthorizedKeys::KEYS).to be_a(Hash)
+      expect(Bard::Provision::AuthorizedKeys::KEYS).not_to be_empty
+      expect(Bard::Provision::AuthorizedKeys::KEYS.keys.first).to match(/@/)
+    end
+  end
+end

data/spec/bard/new/provision/base_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "bard/new/provision/base"
+
+describe Bard::Provision do
+  let(:config) { { production: double("production", key: :production) } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision) { Bard::Provision.new(config, ssh_url) }
+
+  describe ".call" do
+    it "creates a new instance and calls it" do
+      expect_any_instance_of(Bard::Provision).to receive(:call)
+      Bard::Provision.call(config, ssh_url)
+    end
+  end
+
+  describe "#target" do
+    it "returns the production target from config" do
+      expect(provision.send(:target)).to eq(config[:production])
+    end
+  end
+
+  describe "#provision_server" do
+    it "returns a target with the provision ssh_url" do
+      target = config[:production]
+      allow(target).to receive(:ssh).and_return(nil)
+      duped = double("duped_target")
+      allow(target).to receive(:dup).and_return(duped)
+      allow(duped).to receive(:ssh)
+
+      result = provision.send(:provision_server)
+      expect(result).to eq(duped)
+    end
+  end
+end

data/spec/bard/new/provision/data_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+require "bard/new/provision/base"
+require "bard/new/provision/data"
+
+describe Bard::Provision::Data do
+  let(:target) { double("target", key: :production) }
+  let(:config) { double("config", data: ["uploads", "assets"]) }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:data_provisioner) { Bard::Provision::Data.new(config, ssh_url) }
+
+  before do
+    allow(data_provisioner).to receive(:target).and_return(target)
+    allow(data_provisioner).to receive(:config).and_return(config)
+    allow(data_provisioner).to receive(:provision_server).and_return(provision_server)
+    allow(data_provisioner).to receive(:print)
+    allow(data_provisioner).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "dumps, transfers, and loads database data" do
+      expect(target).to receive(:run!).with("bin/rake db:dump")
+      expect(target).to receive(:copy_file).with("db/data.sql.gz", to: provision_server, verbose: false)
+      expect(provision_server).to receive(:run!).with("bin/rake db:load")
+
+      allow(target).to receive(:copy_dir)
+
+      data_provisioner.call
+    end
+
+    it "synchronizes configured data directories" do
+      allow(target).to receive(:run!)
+      allow(target).to receive(:copy_file)
+      allow(provision_server).to receive(:run!)
+
+      expect(target).to receive(:copy_dir).with("uploads", to: provision_server, verbose: false)
+      expect(target).to receive(:copy_dir).with("assets", to: provision_server, verbose: false)
+
+      data_provisioner.call
+    end
+
+    it "prints status messages" do
+      allow(target).to receive(:run!)
+      allow(target).to receive(:copy_file)
+      allow(target).to receive(:copy_dir)
+      allow(provision_server).to receive(:run!)
+
+      expect(data_provisioner).to receive(:print).with("Data:")
+      expect(data_provisioner).to receive(:puts).with(" ✓")
+
+      data_provisioner.call
+    end
+  end
+end

data/spec/bard/new/provision/deploy_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "bard/new/provision/base"
+require "bard/new/provision/deploy"
+
+describe Bard::Provision::Deploy do
+  let(:config) { { production: double("production") } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:deploy) { Bard::Provision::Deploy.new(config, ssh_url) }
+
+  before do
+    allow(deploy).to receive(:provision_server).and_return(provision_server)
+    allow(deploy).to receive(:print)
+    allow(deploy).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "runs bin/setup on the server" do
+      expect(provision_server).to receive(:run!).with("bin/setup")
+
+      deploy.call
+    end
+
+    it "prints status messages" do
+      allow(provision_server).to receive(:run!)
+
+      expect(deploy).to receive(:print).with("Deploy:")
+      expect(deploy).to receive(:puts).with(" ✓")
+
+      deploy.call
+    end
+  end
+end

data/spec/bard/new/provision/http_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+require "bard/new/provision/base"
+require "bard/new/provision/http"
+
+describe Bard::Provision::HTTP do
+  let(:target) { double("target", url: "https://example.com") }
+  let(:config) { { production: target } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:http) { Bard::Provision::HTTP.new(config, ssh_url) }
+
+  before do
+    allow(http).to receive(:target).and_return(target)
+    allow(http).to receive(:provision_server).and_return(provision_server)
+    allow(provision_server).to receive_message_chain(:ssh_uri, :host).and_return("192.168.1.100")
+    allow(http).to receive(:print)
+    allow(http).to receive(:puts)
+    allow(http).to receive(:system)
+  end
+
+  describe "#call" do
+    context "when HTTP test passes" do
+      it "shows success message" do
+        allow(http).to receive(:system).and_return(true)
+
+        expect(http).to receive(:puts).with(" ✓")
+
+        http.call
+      end
+    end
+
+    context "when HTTP test fails" do
+      it "shows failure message" do
+        allow(http).to receive(:system).and_return(false)
+
+        expect(http).to receive(:puts).with(" !!! not serving a rails app from 192.168.1.100")
+
+        http.call
+      end
+    end
+
+    it "prints status header" do
+      allow(http).to receive(:system).and_return(true)
+
+      expect(http).to receive(:print).with("HTTP:")
+
+      http.call
+    end
+
+    it "tests the correct URL" do
+      expected_command = /curl -sf --resolve example\.com:80:192\.168\.1\.100 http:\/\/example\.com -o \/dev\/null/
+      expect(http).to receive(:system).with(expected_command)
+
+      http.call
+    end
+  end
+end

data/spec/bard/new/provision/logrotation_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "bard/new/provision/base"
+require "bard/new/provision/logrotation"
+
+describe Bard::Provision::LogRotation do
+  let(:target) { double("target", project_name: "test_app") }
+  let(:config) { double("config", project_name: "test_app", :[] => target) }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:logrotation) { Bard::Provision::LogRotation.new(config, ssh_url) }
+
+  before do
+    allow(logrotation).to receive(:target).and_return(target)
+    allow(logrotation).to receive(:provision_server).and_return(provision_server)
+    allow(logrotation).to receive(:print)
+    allow(logrotation).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "sets up log rotation config on the target" do
+      expect(provision_server).to receive(:run!).with(/file=\/etc\/logrotate\.d\/test_app/, quiet: true)
+
+      logrotation.call
+    end
+
+    it "prints status messages" do
+      allow(provision_server).to receive(:run!)
+      expect(logrotation).to receive(:print).with("Log Rotation:")
+      expect(logrotation).to receive(:puts).with(" ✓")
+
+      logrotation.call
+    end
+  end
+end

data/spec/bard/new/provision/masterkey_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+require "bard/new/provision/base"
+require "bard/new/provision/masterkey"
+
+describe Bard::Provision::MasterKey do
+  let(:local) { double("local") }
+  let(:config) { { production: double("production"), local: local } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:master_key) { Bard::Provision::MasterKey.new(config, ssh_url) }
+
+  before do
+    allow(master_key).to receive(:provision_server).and_return(provision_server)
+    allow(master_key).to receive(:print)
+    allow(master_key).to receive(:puts)
+  end
+
+  describe "#call" do
+    context "when master.key exists locally" do
+      before do
+        allow(File).to receive(:exist?).with("config/master.key").and_return(true)
+      end
+
+      it "uploads master.key if not present on server" do
+        allow(provision_server).to receive(:run).with("[ -f config/master.key ]", quiet: true).and_return(false)
+
+        expect(Bard::Copy).to receive(:file).with("config/master.key", from: local, to: provision_server)
+
+        master_key.call
+      end
+
+      it "skips upload if master.key already exists on server" do
+        allow(provision_server).to receive(:run).with("[ -f config/master.key ]", quiet: true).and_return(true)
+
+        expect(Bard::Copy).not_to receive(:file)
+
+        master_key.call
+      end
+    end
+
+    context "when master.key doesn't exist locally" do
+      before do
+        allow(File).to receive(:exist?).with("config/master.key").and_return(false)
+      end
+
+      it "skips the upload" do
+        expect(Bard::Copy).not_to receive(:file)
+
+        master_key.call
+      end
+    end
+
+    it "prints status messages" do
+      allow(File).to receive(:exist?).and_return(false)
+
+      expect(master_key).to receive(:print).with("Master Key:")
+      expect(master_key).to receive(:puts).with(" ✓")
+
+      master_key.call
+    end
+  end
+end

data/spec/bard/new/provision/mysql_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+require "bard/new/provision/base"
+require "bard/new/provision/mysql"
+
+describe Bard::Provision::MySQL do
+  let(:config) { { production: double("production") } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:mysql) { Bard::Provision::MySQL.new(config, ssh_url) }
+
+  before do
+    allow(mysql).to receive(:provision_server).and_return(provision_server)
+    allow(mysql).to receive(:print)
+    allow(mysql).to receive(:puts)
+  end
+
+  describe "#call" do
+    context "when MySQL is not responding" do
+      it "installs MySQL" do
+        allow(mysql).to receive(:mysql_responding?).and_return(false)
+
+        expect(provision_server).to receive(:run!).with(/DEBIAN_FRONTEND=noninteractive.*apt-get install -y mysql-server/, home: true)
+
+        mysql.call
+      end
+    end
+
+    context "when MySQL is already responding" do
+      it "skips installation" do
+        allow(mysql).to receive(:mysql_responding?).and_return(true)
+
+        expect(provision_server).not_to receive(:run!)
+
+        mysql.call
+      end
+    end
+
+    it "prints status messages" do
+      allow(mysql).to receive(:mysql_responding?).and_return(true)
+
+      expect(mysql).to receive(:print).with("MySQL:")
+      expect(mysql).to receive(:puts).with(" ✓")
+
+      mysql.call
+    end
+  end
+
+  describe "#mysql_responding?" do
+    it "checks if MySQL service is active" do
+      expect(provision_server).to receive(:run).with("sudo systemctl is-active --quiet mysql", home: true, quiet: true)
+
+      mysql.mysql_responding?
+    end
+  end
+end