bard 1.7.4 → 2.0.0.beta

data/lib/bard/target.rb

@@ -0,0 +1,239 @@
+require "uri"
+require "bard/command"
+require "bard/copy"
+require "bard/deploy_strategy"
+
+module Bard
+  class Target
+    attr_reader :key, :config, :path
+    attr_accessor :server, :gateway, :ssh_key, :env
+
+    def initialize(key, config)
+      @key = key
+      @config = config
+      @capabilities = []
+      @ping_urls = []
+      @strategy_options_hash = {}
+      @deploy_strategy = nil
+      @path = nil
+      @server = nil
+    end
+
+    # Capability tracking
+    def enable_capability(capability)
+      @capabilities << capability unless @capabilities.include?(capability)
+    end
+
+    def has_capability?(capability)
+      @capabilities.include?(capability)
+    end
+
+    def require_capability!(capability)
+      unless has_capability?(capability)
+        error_message = case capability
+        when :ssh
+          "SSH not configured for this target"
+        when :ping
+          "Ping URL not configured for this target"
+        else
+          "#{capability} capability not configured for this target"
+        end
+        raise error_message
+      end
+    end
+
+    # SSH configuration
+    def ssh(uri_or_false = nil, **options)
+      if uri_or_false.nil?
+        # Getter - return false if explicitly disabled, otherwise return server
+        return @ssh_disabled ? false : @server
+      elsif uri_or_false == false
+        # Disable SSH
+        @server = nil
+        @ssh_disabled = true
+        @capabilities.delete(:ssh)
+      else
+        # Enable SSH
+        require "bard/ssh_server"
+        @server = SSHServer.new(uri_or_false, **options)
+        @path = options[:path] if options[:path]
+        @gateway = options[:gateway] if options[:gateway]
+        @ssh_key = options[:ssh_key] if options[:ssh_key]
+        @env = options[:env] if options[:env]
+        enable_capability(:ssh)
+
+        # Set SSH as default deployment strategy if none set
+        @deploy_strategy ||= :ssh
+
+        # Auto-configure ping from hostname
+        hostname = @server.hostname
+        ping(hostname) if hostname
+      end
+    end
+
+    def ssh_uri
+      server&.ssh_uri
+    end
+
+    # Path configuration
+    def path(new_path = nil)
+      if new_path
+        @path = new_path
+      else
+        @path || config.project_name
+      end
+    end
+
+    # Ping configuration
+    def ping(*urls)
+      if urls.empty?
+        # Getter
+        @ping_urls
+      elsif urls.first == false
+        # Disable ping
+        @ping_urls = []
+        @capabilities.delete(:ping)
+      else
+        # Enable ping
+        @ping_urls = urls.flatten
+        enable_capability(:ping)
+      end
+    end
+
+    def ping_urls
+      @ping_urls
+    end
+
+    def ping!
+      require_capability!(:ping)
+      require "bard/ping"
+      failed_urls = Bard::Ping.call(self)
+      if failed_urls.any?
+        raise "Ping failed for: #{failed_urls.join(', ')}"
+      end
+    end
+
+    def open
+      require_capability!(:ping)
+      system "open #{ping_urls.first}"
+    end
+
+    # Deploy strategy
+    attr_reader :deploy_strategy
+
+    # GitHub Pages deployment configuration
+    def github_pages(url = nil)
+      if url.nil?
+        # Getter
+        @github_pages_url
+      else
+        # Setter
+        @deploy_strategy = :github_pages
+        @github_pages_url = url
+        enable_capability(:github_pages)
+      end
+    end
+
+    def strategy_options(strategy_name)
+      @strategy_options_hash[strategy_name] || {}
+    end
+
+    def deploy_strategy_instance
+      raise "No deployment strategy configured for target #{key}" unless @deploy_strategy
+
+      strategy_class = DeployStrategy[@deploy_strategy]
+      raise "Unknown deployment strategy: #{@deploy_strategy}" unless strategy_class
+
+      strategy_class.new(self)
+    end
+
+    # Dynamic strategy DSL via method_missing
+    def method_missing(method, *args, **kwargs, &block)
+      strategy_class = DeployStrategy[method]
+
+      if strategy_class
+        # This is a deployment strategy
+        @deploy_strategy = method
+
+        # Store options
+        @strategy_options_hash[method] = kwargs
+
+        # Auto-configure ping if first arg is a URL
+        if args.first && args.first.to_s =~ /^https?:\/\//
+          ping(args.first)
+        end
+
+        # Call the strategy's initializer if it wants to configure the target
+        # (This will be handled by the strategy class)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      DeployStrategy[method] || super
+    end
+
+    # Remote command execution
+    def run!(command, home: false, verbose: false, quiet: false)
+      require_capability!(:ssh)
+      Command.run!(command, on: server, home: home, verbose: verbose, quiet: quiet)
+    end
+
+    def run(command, home: false, verbose: false, quiet: false)
+      require_capability!(:ssh)
+      Command.run(command, on: server, home: home, verbose: verbose, quiet: quiet)
+    end
+
+    def exec!(command, home: false)
+      require_capability!(:ssh)
+      Command.exec!(command, on: server, home: home)
+    end
+
+    # File transfer
+    def copy_file(path, to:, verbose: false)
+      require_capability!(:ssh)
+      to.require_capability!(:ssh)
+      Copy.file(path, from: self, to: to, verbose: verbose)
+    end
+
+    def copy_dir(path, to:, verbose: false)
+      require_capability!(:ssh)
+      to.require_capability!(:ssh)
+      Copy.dir(path, from: self, to: to, verbose: verbose)
+    end
+
+    # URI methods for compatibility
+    def scp_uri(file_path = nil)
+      uri = URI("scp://#{ssh_uri}")
+      uri.path = "/#{path}"
+      uri.path += "/#{file_path}" if file_path
+      uri
+    end
+
+    def rsync_uri(file_path = nil)
+      uri = URI("ssh://#{ssh_uri}")
+      str = "#{uri.user}@#{uri.host}"
+      str += ":#{path}"
+      str += "/#{file_path}" if file_path
+      str
+    end
+
+    # Utility methods
+    def to_s
+      key.to_s
+    end
+
+    def to_sym
+      key
+    end
+
+    def with(attrs)
+      dup.tap do |t|
+        attrs.each do |key, value|
+          t.send(key, value)
+        end
+      end
+    end
+  end
+end

data/lib/bard/version.rb

@@ -1,4 +1,4 @@
 module Bard
-  VERSION = "1.7.4"
+  VERSION = "2.0.0.beta"
 end
 

data/spec/bard/capability_spec.rb

@@ -0,0 +1,97 @@
+require "spec_helper"
+require "bard/target"
+
+describe "Capability System" do
+  let(:config) { double("config", project_name: "testapp") }
+  let(:target) { Bard::Target.new(:production, config) }
+
+  describe "#enable_capability" do
+    it "enables a capability on the target" do
+      target.enable_capability(:ssh)
+      expect(target.has_capability?(:ssh)).to be true
+    end
+
+    it "can enable multiple capabilities" do
+      target.enable_capability(:ssh)
+      target.enable_capability(:ping)
+      expect(target.has_capability?(:ssh)).to be true
+      expect(target.has_capability?(:ping)).to be true
+    end
+  end
+
+  describe "#has_capability?" do
+    it "returns false for capabilities that are not enabled" do
+      expect(target.has_capability?(:ssh)).to be false
+    end
+
+    it "returns true for capabilities that are enabled" do
+      target.enable_capability(:ssh)
+      expect(target.has_capability?(:ssh)).to be true
+    end
+  end
+
+  describe "#require_capability!" do
+    it "does not raise an error if capability is enabled" do
+      target.enable_capability(:ssh)
+      expect { target.require_capability!(:ssh) }.not_to raise_error
+    end
+
+    it "raises an error if capability is not enabled" do
+      expect { target.require_capability!(:ssh) }
+        .to raise_error(/SSH not configured for this target/)
+    end
+
+    it "provides custom error message for ping capability" do
+      expect { target.require_capability!(:ping) }
+        .to raise_error(/Ping URL not configured for this target/)
+    end
+
+    it "provides generic error message for unknown capabilities" do
+      expect { target.require_capability!(:unknown) }
+        .to raise_error(/unknown capability not configured for this target/)
+    end
+  end
+
+  describe "capability dependency checking" do
+    context "SSH-dependent methods" do
+      it "run! requires SSH capability" do
+        expect { target.run!("ls") }
+          .to raise_error(/SSH not configured/)
+      end
+
+      it "run requires SSH capability" do
+        expect { target.run("ls") }
+          .to raise_error(/SSH not configured/)
+      end
+
+      it "exec! requires SSH capability" do
+        expect { target.exec!("ls") }
+          .to raise_error(/SSH not configured/)
+      end
+
+      it "copy_file requires SSH capability" do
+        other_target = Bard::Target.new(:staging, config)
+        expect { target.copy_file("test.txt", to: other_target) }
+          .to raise_error(/SSH not configured/)
+      end
+
+      it "copy_dir requires SSH capability" do
+        other_target = Bard::Target.new(:staging, config)
+        expect { target.copy_dir("test/", to: other_target) }
+          .to raise_error(/SSH not configured/)
+      end
+    end
+
+    context "Ping-dependent methods" do
+      it "ping! requires ping capability" do
+        expect { target.ping! }
+          .to raise_error(/Ping URL not configured/)
+      end
+
+      it "open requires ping capability" do
+        expect { target.open }
+          .to raise_error(/Ping URL not configured/)
+      end
+    end
+  end
+end

data/spec/bard/config_spec.rb

@@ -161,7 +161,7 @@ describe Bard::Config do
       it "creates a production server with github_pages enabled" do
         production = subject[:production]
         expect(production).not_to be_nil
-        expect(production.github_pages).to eq true
+        expect(production.github_pages).to eq "example.com"
         expect(production.ssh).to eq false
       end
     end

data/spec/bard/deploy_strategy/ssh_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+require "bard/deploy_strategy"
+require "bard/deploy_strategy/ssh"
+
+describe Bard::DeployStrategy::SSH do
+  let(:config) { double("config", project_name: "testapp") }
+  let(:target) do
+    t = Bard::Target.new(:production, config)
+    t.ssh("deploy@example.com:22", path: "/app")
+    t
+  end
+  let(:strategy) { described_class.new(target) }
+
+  describe "#deploy" do
+    it "requires SSH capability" do
+      target_without_ssh = Bard::Target.new(:local, config)
+      strategy_without_ssh = described_class.new(target_without_ssh)
+
+      expect { strategy_without_ssh.deploy }
+        .to raise_error(/SSH not configured/)
+    end
+
+    it "runs git pull on remote server" do
+      expect(target).to receive(:run!)
+        .with(/git pull origin master/)
+
+      allow(target).to receive(:run!).with(/bin\/setup/)
+
+      strategy.deploy
+    end
+
+    it "runs bin/setup on remote server" do
+      allow(target).to receive(:run!).with(/git pull/)
+
+      expect(target).to receive(:run!)
+        .with(/bin\/setup/)
+
+      strategy.deploy
+    end
+
+    it "uses configured branch if specified" do
+      target.instance_variable_set(:@branch, "main")
+
+      expect(target).to receive(:run!)
+        .with(/git pull origin main/)
+
+      allow(target).to receive(:run!).with(/bin\/setup/)
+
+      strategy.deploy
+    end
+  end
+
+  describe "auto-registration" do
+    it "registers as :ssh strategy" do
+      expect(Bard::DeployStrategy[:ssh]).to eq(described_class)
+    end
+  end
+
+  describe "integration with target" do
+    it "is enabled by ssh DSL method" do
+      new_target = Bard::Target.new(:staging, config)
+      new_target.ssh("deploy@staging.example.com:22")
+
+      expect(new_target.deploy_strategy).to eq(:ssh)
+    end
+  end
+end

data/spec/bard/deploy_strategy_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+require "bard/deploy_strategy"
+
+describe Bard::DeployStrategy do
+  describe "auto-registration" do
+    it "registers strategies via inherited hook" do
+      # Define a test strategy
+      class Bard::DeployStrategy::TestStrategy < Bard::DeployStrategy
+      end
+
+      expect(Bard::DeployStrategy[:test_strategy]).to eq(Bard::DeployStrategy::TestStrategy)
+    end
+
+    it "extracts strategy name from class name" do
+      class Bard::DeployStrategy::MyCustomStrategy < Bard::DeployStrategy
+      end
+
+      expect(Bard::DeployStrategy[:my_custom_strategy]).to eq(Bard::DeployStrategy::MyCustomStrategy)
+    end
+
+
+    it "allows retrieval of registered strategies" do
+      class Bard::DeployStrategy::RetrievalTest < Bard::DeployStrategy
+      end
+
+      strategy_class = Bard::DeployStrategy[:retrieval_test]
+      expect(strategy_class).to eq(Bard::DeployStrategy::RetrievalTest)
+      expect(strategy_class.superclass).to eq(Bard::DeployStrategy)
+    end
+  end
+
+  describe ".strategies" do
+    it "returns a hash of all registered strategies" do
+      class Bard::DeployStrategy::Strategy1 < Bard::DeployStrategy
+      end
+      class Bard::DeployStrategy::Strategy2 < Bard::DeployStrategy
+      end
+
+      strategies = Bard::DeployStrategy.strategies
+      expect(strategies).to be_a(Hash)
+      expect(strategies[:strategy1]).to eq(Bard::DeployStrategy::Strategy1)
+      expect(strategies[:strategy2]).to eq(Bard::DeployStrategy::Strategy2)
+    end
+  end
+
+  describe ".[]" do
+    it "retrieves a strategy by symbol" do
+      class Bard::DeployStrategy::LookupTest < Bard::DeployStrategy
+      end
+
+      expect(Bard::DeployStrategy[:lookup_test]).to eq(Bard::DeployStrategy::LookupTest)
+    end
+
+    it "returns nil for unknown strategies" do
+      expect(Bard::DeployStrategy[:unknown_strategy]).to be_nil
+    end
+  end
+
+  describe "#initialize" do
+    let(:target) { double("target") }
+
+    it "stores the target" do
+      strategy = described_class.new(target)
+      expect(strategy.target).to eq(target)
+    end
+  end
+
+  describe "#deploy" do
+    let(:target) { double("target") }
+    let(:strategy) { described_class.new(target) }
+
+    it "raises NotImplementedError" do
+      expect { strategy.deploy }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "helper methods" do
+    let(:target) { double("target") }
+    let(:strategy) { described_class.new(target) }
+
+    describe "#run!" do
+      it "delegates to Bard::Command.run!" do
+        expect(Bard::Command).to receive(:run!).with("ls -l")
+        strategy.run!("ls -l")
+      end
+    end
+
+    describe "#run" do
+      it "delegates to Bard::Command.run" do
+        expect(Bard::Command).to receive(:run).with("ls -l")
+        strategy.run("ls -l")
+      end
+    end
+
+    describe "#system!" do
+      it "delegates to Kernel.system with error checking" do
+        expect(Kernel).to receive(:system).with("ls -l").and_return(true)
+        strategy.system!("ls -l")
+      end
+
+      it "raises error if command fails" do
+        expect(Kernel).to receive(:system).with("false").and_return(false)
+        expect { strategy.system!("false") }.to raise_error(/Command failed/)
+      end
+    end
+  end
+end

data/spec/bard/dynamic_dsl_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+require "bard/target"
+require "bard/deploy_strategy"
+
+describe "Dynamic DSL Methods" do
+  let(:config) { double("config", project_name: "testapp") }
+  let(:target) { Bard::Target.new(:production, config) }
+
+  before do
+    # Register test strategies
+    class Bard::DeployStrategy::Jets < Bard::DeployStrategy
+      def deploy
+        # test implementation
+      end
+    end
+
+    class Bard::DeployStrategy::Docker < Bard::DeployStrategy
+      def deploy
+        # test implementation
+      end
+    end
+  end
+
+  describe "method_missing for strategies" do
+    it "enables strategy when method name matches registered strategy" do
+      target.jets("https://api.example.com")
+      expect(target.deploy_strategy).to eq(:jets)
+    end
+
+    it "stores strategy options" do
+      target.jets("https://api.example.com", run_tests: true, env: "production")
+      options = target.strategy_options(:jets)
+      expect(options[:run_tests]).to be true
+      expect(options[:env]).to eq("production")
+    end
+
+    it "auto-configures ping URL from first argument if it's a URL" do
+      target.jets("https://api.example.com")
+      expect(target.ping_urls).to include("https://api.example.com")
+    end
+
+    it "works with multiple strategies" do
+      target1 = Bard::Target.new(:production, config)
+      target2 = Bard::Target.new(:staging, config)
+
+      target1.jets("https://api.example.com")
+      target2.docker("https://app.example.com")
+
+      expect(target1.deploy_strategy).to eq(:jets)
+      expect(target2.deploy_strategy).to eq(:docker)
+    end
+
+    it "raises NoMethodError for unknown methods" do
+      expect { target.unknown_method("arg") }
+        .to raise_error(NoMethodError)
+    end
+  end
+
+  describe "strategy DSL integration" do
+    it "allows chaining with other configuration methods" do
+      target.jets("https://api.example.com", run_tests: true)
+      target.ssh("deploy@example.com:22", path: "app")
+
+      expect(target.deploy_strategy).to eq(:jets)
+      expect(target.has_capability?(:ssh)).to be true
+    end
+
+    it "allows strategy configuration without ping URL" do
+      target.docker(skip_build: true)
+      options = target.strategy_options(:docker)
+      expect(options[:skip_build]).to be true
+    end
+  end
+
+  describe "#strategy_options" do
+    it "returns options for the specified strategy" do
+      target.jets("https://api.example.com", run_tests: true, env: "prod")
+      options = target.strategy_options(:jets)
+      expect(options[:run_tests]).to be true
+      expect(options[:env]).to eq("prod")
+    end
+
+    it "returns empty hash if strategy not configured" do
+      options = target.strategy_options(:unknown)
+      expect(options).to eq({})
+    end
+
+    it "filters out URL from options" do
+      target.jets("https://api.example.com", run_tests: true)
+      options = target.strategy_options(:jets)
+      expect(options[:run_tests]).to be true
+      expect(options).not_to have_key(:url)
+    end
+  end
+
+  describe "#deploy_strategy" do
+    it "returns the configured strategy symbol" do
+      target.jets("https://api.example.com")
+      expect(target.deploy_strategy).to eq(:jets)
+    end
+
+    it "returns nil if no strategy configured" do
+      expect(target.deploy_strategy).to be_nil
+    end
+  end
+
+  describe "#deploy_strategy_instance" do
+    it "creates an instance of the strategy class" do
+      target.jets("https://api.example.com")
+      instance = target.deploy_strategy_instance
+      expect(instance).to be_a(Bard::DeployStrategy::Jets)
+      expect(instance.target).to eq(target)
+    end
+
+    it "raises error if no strategy configured" do
+      expect { target.deploy_strategy_instance }
+        .to raise_error(/No deployment strategy configured/)
+    end
+
+    it "raises error if strategy class not found" do
+      target.instance_variable_set(:@deploy_strategy, :unknown)
+      expect { target.deploy_strategy_instance }
+        .to raise_error(/Unknown deployment strategy: unknown/)
+    end
+  end
+end