bard 1.7.4 → 2.0.0.beta

data/lib/bard/config.rb

@@ -1,4 +1,5 @@
 require "bard/server"
+require "bard/target"
 
 module Bard
   class Config
@@ -8,69 +9,75 @@ module Bard
       new(project_name, path: path)
     end
 
-    def initialize project_name, path: nil, source: nil
+    attr_reader :project_name, :targets
+
+    def initialize(project_name = nil, path: nil, source: nil)
+      # Support both positional and keyword argument for project_name
       @project_name = project_name
-      @servers = {
-        local: Server.new(
-          project_name,
-          :local,
-          false,
-          "./",
-          ["#{project_name}.local"],
-        ),
-        gubs: Server.new(
-          project_name,
-          :gubs,
-          "botandrose@cloud.hackett.world:22022",
-          "Sites/#{project_name}",
-          false,
-        ),
-        ci: Server.new(
-          project_name,
-          :ci,
-          "jenkins@staging.botandrose.com:22022",
-          "jobs/#{project_name}/workspace",
-          false,
-        ),
-        staging: Server.new(
-          project_name,
-          :staging,
-          "www@staging.botandrose.com:22022",
-          project_name,
-          ["#{project_name}.botandrose.com"],
-        ),
-      }
+      @servers = {}  # Unified hash for both Server and Target instances
+      @data_paths = []
+      @backup = nil
+      @ci_system = nil
+
+      # Load default configuration (creates Server instances for backward compat)
+      load_defaults if project_name
+
+      # Load user configuration
       if path && File.exist?(path)
         source = File.read(path)
       end
       if source
-        instance_eval source
+        instance_eval(source)
       end
     end
 
-    attr_reader :project_name, :servers
+    # Backward compatible accessor
+    def servers
+      @servers
+    end
+
+    # New v2.0 accessor (same as servers)
+    def targets
+      @servers
+    end
 
-    def server key, &block
+    # Old v1.x API - creates Server instances
+    def server(key, &block)
       key = key.to_sym
       @servers[key] = Server.define(project_name, key, &block)
     end
 
-    def [] key
+    # New v2.0 API - creates Target instances
+    def target(key, &block)
       key = key.to_sym
+      @servers[key] ||= Target.new(key, self)
+      @servers[key].instance_eval(&block) if block
+      @servers[key]
+    end
+
+    # Get a server/target by key
+    def [](key)
+      key = key.to_sym
+      # Fallback to staging if production not defined
       if @servers[key].nil? && key == :production
         key = :staging
       end
       @servers[key]
     end
 
-    def data *paths
-      if paths.length == 0
-        Array(@data)
+    # Data paths configuration
+    def data(*paths)
+      if paths.empty?
+        @data_paths
       else
-        @data = paths
+        @data_paths = paths
       end
     end
 
+    def data_paths
+      @data_paths
+    end
+
     def backup(value = nil, &block)
       if block_given?
         @backup = BackupConfig.new(&block)
@@ -83,7 +90,9 @@ module Bard
       end
     end
 
-    # short-hand for michael
+    def backup_enabled?
+      backup == true
+    end
 
     def github_pages url
       urls = []
@@ -94,14 +103,80 @@ module Bard
         urls << "www.#{hostname}"
       end
 
-      server :production do
-        github_pages true
+      target :production do
+        github_pages url
         ssh false
-        ping *urls
+        ping(*urls) if urls.any?
       end
 
       backup false
     end
+
+    # CI configuration
+    def ci(system = nil)
+      if system.nil?
+        @ci_system
+      else
+        @ci_system = system
+      end
+    end
+
+    def ci_system
+      @ci_system
+    end
+
+    def ci_instance(branch)
+      return nil if @ci_system == false
+
+      require "bard/ci"
+
+      # Use the existing CI class which handles auto-detection
+      case @ci_system
+      when :local
+        CI.new(project_name, branch, local: true)
+      when :github_actions, :jenkins, nil
+        # CI class auto-detects between github_actions and jenkins
+        CI.new(project_name, branch)
+      when false
+        nil
+      else
+        CI.new(project_name, branch)
+      end
+    end
+
+    private
+
+    # Load default server configurations (v1.x compatible)
+    def load_defaults
+      @servers[:local] = Server.new(
+        project_name,
+        :local,
+        false,
+        "./",
+        ["#{project_name}.local"],
+      )
+      @servers[:gubs] = Server.new(
+        project_name,
+        :gubs,
+        "botandrose@cloud.hackett.world:22022",
+        "Sites/#{project_name}",
+        false,
+      )
+      @servers[:ci] = Server.new(
+        project_name,
+        :ci,
+        "jenkins@staging.botandrose.com:22022",
+        "jobs/#{project_name}/workspace",
+        false,
+      )
+      @servers[:staging] = Server.new(
+        project_name,
+        :staging,
+        "www@staging.botandrose.com:22022",
+        project_name,
+        ["#{project_name}.botandrose.com"],
+      )
+    end
   end
 
   class BackupConfig

data/lib/bard/copy.rb

@@ -21,12 +21,15 @@ module Bard
       end
     end
 
-    def scp_using_local direction, server
-      gateway = server.gateway ? "-oProxyCommand='ssh #{server.ssh_uri(:gateway)} -W %h:%p'" : ""
+    def scp_using_local direction, target_or_server
+      # 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_key = server.ssh_key ? "-i #{server.ssh_key}" : ""
+      gateway = ssh_server.gateway ? "-oProxyCommand='ssh #{ssh_server.gateway} -W %h:%p'" : ""
 
-      from_and_to = [path, server.scp_uri(path)]
+      ssh_key = ssh_server.ssh_key ? "-i #{ssh_server.ssh_key}" : ""
+
+      from_and_to = [path, target_or_server.scp_uri(path)]
       from_and_to.reverse! if direction == :from
 
       command = ["scp", gateway, ssh_key, *from_and_to].join(" ")
@@ -34,7 +37,10 @@ module Bard
     end
 
     def scp_as_mediator
-      raise NotImplementedError if from.gateway || to.gateway || from.ssh_key || to.ssh_key
+      from_server = from.respond_to?(:server) ? from.server : from
+      to_server = to.respond_to?(:server) ? to.server : to
+
+      raise NotImplementedError if from_server.gateway || to_server.gateway || from_server.ssh_key || to_server.ssh_key
       command = "scp -o ForwardAgent=yes #{from.scp_uri(path)} #{to.scp_uri(path)}"
       Bard::Command.run! command, verbose: verbose
     end
@@ -49,13 +55,29 @@ module Bard
       end
     end
 
-    def rsync_using_local direction, server
-      gateway = server.gateway ? "-oProxyCommand=\"ssh #{server.ssh_uri(:gateway)} -W %h:%p\"" : ""
+    def rsync_using_local direction, target_or_server
+      # 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
+
+      # 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\"" : ""
 
-      ssh_key = server.ssh_key ? "-i #{server.ssh_key}" : ""
-      ssh = "-e'ssh #{gateway} -p#{server.ssh_uri.port || 22}'"
+      ssh_key = ssh_server.ssh_key ? "-i #{ssh_server.ssh_key}" : ""
+      ssh = "-e'ssh #{gateway} -p#{ssh_uri.port || 22}'"
 
-      from_and_to = ["./#{path}", server.rsync_uri(path)]
+      from_and_to = ["./#{path}", target_or_server.rsync_uri(path)]
       from_and_to.reverse! if direction == :from
       from_and_to[-1].sub! %r(/[^/]+$), '/'
 
@@ -64,12 +86,34 @@ module Bard
     end
 
     def rsync_as_mediator
-      raise NotImplementedError if from.gateway || to.gateway || from.ssh_key || to.ssh_key
+      from_server = from.respond_to?(:server) ? from.server : from
+      to_server = to.respond_to?(:server) ? to.server : to
+
+      raise NotImplementedError if from_server.gateway || to_server.gateway || from_server.ssh_key || to_server.ssh_key
+
+      # 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.ssh_uri.port || 22} #{from.ssh_uri.user}@#{from.ssh_uri.host}"
+      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.ssh_uri.port || 22} -o StrictHostKeyChecking=no\" --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/default_config.rb

@@ -0,0 +1,35 @@
+module Bard
+  # Default configuration that is loaded before user's bard.rb
+  # Users can override any of these targets in their bard.rb
+  DEFAULT_CONFIG = lambda do |config, project_name|
+    # Local development target
+    config.instance_eval do
+      target :local do
+        ssh false
+        path "./"
+        ping "#{project_name}.local"
+      end
+
+      # Bot and Rose cloud server
+      target :gubs do
+        ssh "botandrose@cloud.hackett.world:22022",
+          path: "Sites/#{project_name}"
+        ping false
+      end
+
+      # CI target (Jenkins)
+      target :ci do
+        ssh "jenkins@staging.botandrose.com:22022",
+          path: "jobs/#{project_name}/workspace"
+        ping false
+      end
+
+      # Staging server
+      target :staging do
+        ssh "www@staging.botandrose.com:22022",
+          path: project_name
+        ping "#{project_name}.botandrose.com"
+      end
+    end
+  end
+end

data/lib/bard/deploy_strategy/github_pages.rb

@@ -0,0 +1,135 @@
+require "bard/deploy_strategy"
+require "bard/git"
+require "fileutils"
+require "uri"
+
+module Bard
+  class DeployStrategy
+    class GithubPages < DeployStrategy
+      def initialize(target, url = nil, **options)
+        super(target)
+        @url = url
+        @options = options
+
+        # Auto-configure ping URL if provided
+        target.ping(url) if url
+      end
+
+      def deploy
+        @sha = Git.sha_of(Git.current_branch)
+        @build_dir = "tmp/github-build-#{@sha}"
+        @branch = "gh-pages"
+        @domain = extract_domain
+
+        puts "Starting deployment to GitHub Pages..."
+
+        build_site
+        tree_sha = create_tree_from_build
+        new_commit = create_commit(tree_sha)
+        commit_and_push(new_commit)
+      end
+
+      private
+
+      def extract_domain
+        return nil unless @url
+        domain = @url
+        domain = URI.parse(domain).hostname if domain =~ /^http/
+        domain
+      end
+
+      def build_site
+        system "rm -rf #{@build_dir.sub(@sha, "*")}"
+        run! <<~SH
+          set -e
+          RAILS_ENV=production bundle exec rails s -p 3000 -d --pid tmp/pids/server.pid
+          OUTPUT=$(bundle exec rake assets:clean assets:precompile 2>&1) || echo "$OUTPUT"
+
+          # Create the output directory and enter it
+          BUILD=#{@build_dir}
+          rm -rf $BUILD
+          mkdir -p $BUILD
+          cp -R public/assets $BUILD/
+          cd $BUILD
+
+          # wait until server responds
+          echo waiting...
+          curl -s --retry 5 --retry-delay 2 http://localhost:3000 >/dev/null 2>&1
+
+          echo copying...
+          # Mirror the site to the build folder, ignoring links with query params
+          wget -nv -r -l inf --no-remove-listing -FEnH --reject-regex "(\\.*)\\?(.*)" http://localhost:3000/ 2>&1
+
+          echo #{@domain} > CNAME
+        SH
+      ensure
+        # cleanup
+        run! <<~SH
+          cat tmp/pids/server.pid | xargs -I {} kill {}
+          rm -rf public/assets
+        SH
+      end
+
+      def create_tree_from_build
+        # Create temporary index
+        git_index_file = ".git/tmp-index"
+        git = "GIT_INDEX_FILE=#{git_index_file} git"
+        run! "#{git} read-tree --empty"
+
+        # Add build files to temporary index
+        Dir.chdir(@build_dir) do
+          Dir.glob('**/*', File::FNM_DOTMATCH).each do |file|
+            next if file == '.' || file == '..'
+            if File.file?(file)
+              run! "#{git} update-index --add --cacheinfo 100644 $(#{git} hash-object -w #{file}) #{file}"
+            end
+          end
+        end
+
+        # Create tree object from index
+        tree_sha = `#{git} write-tree`.chomp
+
+        # Clean up temporary index
+        FileUtils.rm_f(git_index_file)
+
+        tree_sha
+      end
+
+      def create_commit(tree_sha)
+        # Get parent commit if branch exists
+        parent = get_parent_commit
+
+        # Create commit object
+        message = "'Deploying to #{@branch} from @ #{@sha} 🚀'"
+        args = ['commit-tree', tree_sha]
+        args += ['-p', parent] if parent
+        args += ['-m', message]
+
+        commit_sha = `git #{args.join(' ')}`.chomp
+
+        commit_sha
+      end
+
+      def get_parent_commit
+        Git.sha_of("#{@branch}^{commit}")
+      end
+
+      def commit_and_push(commit_sha)
+        if branch_exists?
+          run! "git update-ref refs/heads/#{@branch} #{commit_sha}"
+        else
+          run! "git branch #{@branch} #{commit_sha}"
+        end
+        run! "git push -f origin #{@branch}:refs/heads/#{@branch}"
+      end
+
+      def branch_exists?
+        system("git show-ref --verify --quiet refs/heads/#{@branch}")
+      end
+
+      def cleanup
+        # Cleanup method for tests
+      end
+    end
+  end
+end

data/lib/bard/deploy_strategy/ssh.rb

@@ -0,0 +1,19 @@
+require "bard/deploy_strategy"
+
+module Bard
+  class DeployStrategy
+    class SSH < DeployStrategy
+      def deploy
+        # Require SSH capability
+        target.require_capability!(:ssh)
+
+        # Determine branch
+        branch = target.instance_variable_get(:@branch) || "master"
+
+        # Run git pull and setup on remote server
+        target.run! "git pull origin #{branch}"
+        target.run! "bin/setup"
+      end
+    end
+  end
+end

data/lib/bard/deploy_strategy.rb

@@ -0,0 +1,60 @@
+require "bard/command"
+
+module Bard
+  class DeployStrategy
+    @strategies = {}
+
+    class << self
+      attr_reader :strategies
+
+      def inherited(subclass)
+        super
+        # Extract strategy name from class name
+        # e.g., Bard::DeployStrategy::SSH -> :ssh
+        name = extract_strategy_name(subclass)
+        strategies[name] = subclass
+      end
+
+      def [](name)
+        strategies[name.to_sym]
+      end
+
+      private
+
+      def extract_strategy_name(klass)
+        # Get the class name without module prefix
+        class_name = klass.name.split('::').last
+        # Convert from CamelCase to snake_case
+        class_name
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+          .to_sym
+      end
+    end
+
+    attr_reader :target
+
+    def initialize(target)
+      @target = target
+    end
+
+    def deploy
+      raise NotImplementedError, "Subclasses must implement #deploy"
+    end
+
+    # Helper methods for strategies
+    def run!(command)
+      Command.run!(command)
+    end
+
+    def run(command)
+      Command.run(command)
+    end
+
+    def system!(command)
+      result = Kernel.system(command)
+      raise "Command failed: #{command}" unless result
+    end
+  end
+end

data/lib/bard/ssh_server.rb

@@ -0,0 +1,100 @@
+require "uri"
+require "bard/command"
+
+module Bard
+  class SSHServer
+    attr_reader :user, :host, :port, :path, :gateway, :ssh_key, :env
+
+    def initialize(uri_string, **options)
+      @uri_string = uri_string
+      @options = options
+
+      # Parse URI
+      uri = parse_uri(uri_string)
+      @user = uri.user || ENV['USER']
+      @host = uri.host
+      @port = uri.port ? uri.port.to_s : "22"
+
+      # Store options
+      @path = options[:path]
+      @gateway = options[:gateway]
+      @ssh_key = options[:ssh_key]
+      @env = options[:env]
+    end
+
+    def ssh_uri
+      "#{user}@#{host}:#{port}"
+    end
+
+    def hostname
+      host
+    end
+
+    def connection_string
+      "#{user}@#{host}"
+    end
+
+    def run(command)
+      full_command = build_command(command)
+      Open3.capture3(full_command)
+    end
+
+    def run!(command)
+      output, error, status = run(command)
+      if status.to_i.nonzero?
+        raise Command::Error, "Command failed: #{command}\n#{error}"
+      end
+      output
+    end
+
+    def exec!(command)
+      full_command = build_command(command)
+      exec(full_command)
+    end
+
+    private
+
+    def parse_uri(uri_string)
+      # Handle user@host:port format
+      if uri_string =~ /^([^@]+@)?([^:]+)(?::(\d+))?$/
+        user_part = $1&.chomp('@')
+        host_part = $2
+        port_part = $3
+
+        URI::Generic.build(
+          scheme: 'ssh',
+          userinfo: user_part,
+          host: host_part,
+          port: port_part&.to_i
+        )
+      else
+        URI.parse("ssh://#{uri_string}")
+      end
+    end
+
+    def build_command(command)
+      cmd = "ssh -tt"
+
+      # Add port
+      cmd += " -p #{port}" if port != "22"
+
+      # Add gateway
+      cmd += " -o ProxyJump=#{gateway}" if gateway
+
+      # Add SSH key
+      cmd += " -i #{ssh_key}" if ssh_key
+
+      # Add user@host
+      cmd += " #{user}@#{host}"
+
+      # Add command with path and env
+      remote_cmd = ""
+      remote_cmd += "#{env} " if env
+      remote_cmd += "cd #{path} && " if path
+      remote_cmd += command
+
+      cmd += " '#{remote_cmd}'"
+      cmd
+    end
+  end
+end