circleci-cli 1.0.0 → 3.0.0

data/lib/circleci/cli/command/watch_command.rb

@@ -1,70 +1,73 @@
 # frozen_string_literal: true
 
+require 'circleci/cli/command/watch_command/build_repository'
+require 'circleci/cli/command/watch_command/build_watcher'
+
 module CircleCI
   module CLI
     module Command
       class WatchCommand < BaseCommand
         class << self
-          def run(options)
+          def run(options) # rubocop:disable Metrics/MethodLength
             setup_token
-            setup_client
 
-            build = get_build(options)
+            username, reponame = project_name(options).split('/')
+            @options = options
+            @repository = BuildRepository.new(
+              username,
+              reponame,
+              branch: branch_name(options),
+              user: options.user
+            )
+            @client = Networking::CircleCIPusherClient.new.tap(&:connect)
+            @build_watcher = nil
+
+            bind_status_event
 
-            if build&.running?
-              start_watch(build)
-              wait_until_finish
-              finalize(build, build.channel_name)
-            else
-              say 'The build is not running'
+            loop do
+              stop_existing_watcher_if_needed
+              start_watcher_if_needed
+              sleep 1
             end
+          rescue Interrupt
+            say 'Exited'
           end
 
           private
 
-          def setup_client
-            @client = Networking::CircleCIPusherClient.new
-            @client.connect
+          def bind_status_event
+            @client.bind("private-#{Response::Account.me.pusher_id}", 'call') { @repository.update }
           end
 
-          def get_build(options)
-            username, reponame = project_name(options).split('/')
-            number = build_number options
-            Response::Build.get(username, reponame, number)
-          end
+          def stop_existing_watcher_if_needed
+            return if @build_watcher.nil?
 
-          def start_watch(build)
-            @running = true
-            text = "Start watching #{build.project_name} ##{build.build_number}"
-            print_bordered text
-            TerminalNotifier.notify text
+            build = @repository.build_for(@build_watcher.build.build_number)
+            return if build.nil? || !build.finished?
 
-            bind_event_handling build.channel_name
+            @build_watcher.stop(build.status)
+            @build_watcher = nil
+            show_interrupted_build_results
           end
 
-          def bind_event_handling(channel)
-            @client.bind_event_json(channel, 'newAction') do |json|
-              print_bordered json['log']['name'].green
-            end
-
-            @client.bind_event_json(channel, 'appendAction') do |json|
-              say json['out']['message']
-            end
-
-            @client.bind_event_json(channel, 'updateAction') do |json|
-              @running = json['log']['name'] != 'Disable SSH'
-            end
-          end
+          def start_watcher_if_needed
+            build_to_watch = @repository.builds_to_show.select(&:running?).first
+            return unless build_to_watch && @build_watcher.nil?
 
-          def wait_until_finish
-            sleep(1) while @running
+            show_interrupted_build_results
+            @repository.mark_as_shown(build_to_watch.build_number)
+            @build_watcher = BuildWatcher.new(build_to_watch, verbose: @options.verbose)
+            @build_watcher.start
           end
 
-          def finalize(build, channel)
-            @client.unsubscribe(channel)
-            text = "Finish watching #{build.project_name} ##{build.build_number}"
-            print_bordered text.blue
-            TerminalNotifier.notify text
+          def show_interrupted_build_results # rubocop:disable Metrics/AbcSize
+            @repository.builds_to_show.select(&:finished?).each do |build|
+              b = Response::Build.get(build.username, build.reponame, build.build_number)
+              title = "✅ Result of #{build.project_name} ##{build.build_number} completed in background"
+              say Printer::BuildPrinter.header_for(build, title)
+              say Printer::StepPrinter.new(b.steps, pretty: @options.verbose).to_s
+              @repository.mark_as_shown(b.build_number)
+            end
           end
 
           def print_bordered(text)

data/lib/circleci/cli/command/watch_command/build_repository.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module CircleCI
+  module CLI
+    module Command
+      class BuildRepository
+        def initialize(username, reponame, branch: nil, user: nil)
+          @username = username
+          @user = user
+          @reponame = reponame
+          @branch = branch
+          @builds = Response::Build.all(@username, @reponame)
+          @build_numbers_shown = @builds.select(&:finished?).map(&:build_number)
+        end
+
+        def update
+          response = if @branch
+                       Response::Build.branch(@username, @reponame, @branch)
+                     else
+                       Response::Build.all(@username, @reponame)
+                     end
+
+          @builds = (response + @builds).uniq(&:build_number)
+        end
+
+        def mark_as_shown(build_number)
+          @build_numbers_shown = (@build_numbers_shown + [build_number]).uniq
+        end
+
+        def builds_to_show
+          @builds
+            .reject { |build| @build_numbers_shown.include?(build.build_number) }
+            .select { |build| @branch.nil? || build.branch.to_s == @branch.to_s }
+            .select { |build| @user.nil? || build.user.to_s == @user.to_s }
+            .sort_by(&:build_number)
+        end
+
+        def build_for(build_number)
+          @builds.find { |build| build.build_number == build_number }
+        end
+      end
+    end
+  end
+end

data/lib/circleci/cli/command/watch_command/build_watcher.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module CircleCI
+  module CLI
+    module Command
+      class BuildWatcher
+        attr_reader :build
+
+        def initialize(build, verbose: false)
+          @build = build
+          @verbose = verbose
+          @messages = Hash.new { |h, k| h[k] = [] }
+        end
+
+        def start
+          bind_event_handling @build.channel_name
+          notify_started
+        end
+
+        def stop(status)
+          client.unsubscribe("#{@build.channel_name}@0")
+          notify_stopped(status)
+        end
+
+        private
+
+        def bind_event_handling(channel) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          client.bind_event_json(channel, 'newAction') do |json|
+            if @verbose
+              print_bordered json['log']['name']
+            else
+              print json['log']['name']
+            end
+          end
+
+          client.bind_event_json(channel, 'appendAction') do |json|
+            if @verbose
+              Thor::Shell::Basic.new.say(json['out']['message'], nil, false)
+            else
+              @messages[json['step']] << json['out']['message']
+            end
+          end
+
+          client.bind_event_json(channel, 'updateAction') do |json|
+            next if @verbose
+
+            case json['log']['status']
+            when 'success'
+              puts "\e[2K\r#{Printer.colorize_green(json['log']['name'])}"
+            when 'failed'
+              puts "\e[2K\r#{Printer.colorize_red(json['log']['name'])}"
+              @messages[json['step']].each(&method(:say))
+            end
+          end
+        end
+
+        def notify_started
+          say Printer::BuildPrinter.header_for(
+            @build,
+            "👀 Start watching #{@build.project_name} ##{@build.build_number}"
+          )
+        end
+
+        def notify_stopped(status)
+          text = case status
+                 when 'success'
+                   Printer.colorize_green("🎉 #{@build.project_name} ##{@build.build_number} has succeeded!")
+                 when 'failed'
+                   Printer.colorize_red("😥 #{@build.project_name} ##{@build.build_number} has failed...")
+                 end
+
+          @verbose ? print_bordered(text) : say(text)
+        end
+
+        def print_bordered(text)
+          say Terminal::Table.new(rows: [[text]], style: { width: 120 }).to_s
+        end
+
+        def client
+          @client ||= Networking::CircleCIPusherClient.new.tap(&:connect)
+        end
+      end
+    end
+  end
+end

data/lib/circleci/cli/networking/pusher_client.rb

@@ -8,45 +8,39 @@ module CircleCI
       class CircleCIPusherClient
         def connect
           PusherClient.logger.level = Logger::ERROR
-          @socket = PusherClient::Socket.new(app_key, pusher_options)
-          @socket.connect(true)
+          socket.connect(true)
         end
 
-        def bind(channel, event)
-          @socket.subscribe(channel)
-          @socket[channel].bind(event) do |data|
-            yield data
-          end
+        def bind(channel, event, &block)
+          socket.subscribe(channel)
+          socket[channel].bind(event, &block)
         end
 
-        def bind_event_json(channel, event)
-          bind(channel, event) do |data|
-            JSON.parse(data).each { |json| yield(json) }
-          end
+        def bind_event_json(channel, event, &block)
+          bind(channel, event) { |data| JSON.parse(data).each(&block) }
         end
 
         def unsubscribe(channel)
-          @socket.unsubscribe(channel)
+          socket.unsubscribe(channel)
         end
 
         private
 
-        def app_key
-          '1cf6e0e755e419d2ac9a'
-        end
-
-        def pusher_options
-          {
+        def socket
+          @socket ||= PusherClient::Socket.new(
+            '1cf6e0e755e419d2ac9a',
             secure: true,
             auth_method: proc { |a, b| auth(a, b) },
             logger: Logger.new('/dev/null')
-          }
+          )
         end
 
         def auth(socket_id, channel)
-          data = { socket_id: socket_id, channel_name: channel.name }
           token = ENV['CIRCLE_CI_TOKEN'] || ask('Circle CI token ? :')
-          res = connection.post("/auth/pusher?circle-token=#{token}", data)
+          res = connection.post(
+            "/auth/pusher?circle-token=#{token}",
+            { socket_id: socket_id, channel_name: channel.name }
+          )
           JSON.parse(res.body)['auth']
         end
 

data/lib/circleci/cli/printer.rb

@@ -6,6 +6,30 @@ require 'circleci/cli/printer/step_printer'
 
 module CircleCI
   module CLI
-    module Printer; end
+    module Printer
+      class << self
+        def colorize_red(string)
+          colorize(string, '0;31;49')
+        end
+
+        def colorize_green(string)
+          colorize(string, '0;32;49')
+        end
+
+        def colorize_yellow(string)
+          colorize(string, '0;33;49')
+        end
+
+        def colorize_light_black(string)
+          colorize(string, '0;90;49')
+        end
+
+        private
+
+        def colorize(string, color_code)
+          "\e[#{color_code}m#{string}\e[0m"
+        end
+      end
+    end
   end
 end

data/lib/circleci/cli/printer/build_printer.rb

@@ -4,8 +4,21 @@ module CircleCI
   module CLI
     module Printer
       class BuildPrinter
-        def initialize(builds, pretty: true)
-          @builds = builds
+        class << self
+          def header_for(build, title)
+            texts = [
+              ["Project:  #{build.project_name}"],
+              ["Build:    #{build.build_number}"],
+              ["Author:   #{build.author_name}"],
+              ["Workflow: #{build.workflow_name}/#{build.workflow_job_name}"]
+            ]
+            Terminal::Table.new(title: title, rows: texts, style: { width: 120 }).to_s
+          end
+        end
+
+        def initialize(builds, project_name, pretty: true)
+          @builds_to_show = builds
+          @project_name = project_name
           @pretty = pretty
         end
 
@@ -24,8 +37,7 @@ module CircleCI
         end
 
         def title
-          build = @builds.first
-          "Recent Builds / #{build.project_name}".green
+          Printer.colorize_green("Recent Builds / #{@project_name}")
         end
 
         def headings
@@ -33,11 +45,11 @@ module CircleCI
         end
 
         def rows
-          @builds.map(&:information)
+          @builds_to_show.map(&:information)
         end
 
         def max_row_widths
-          @builds
+          @builds_to_show
             .map(&:information)
             .map { |array| array.map(&:to_s).map(&:size) }
             .transpose

data/lib/circleci/cli/printer/project_printer.rb

@@ -5,6 +5,7 @@ module CircleCI
     module Printer
       class ProjectPrinter
         attr_accessor :compact
+
         def initialize(projects, pretty: true)
           @projects = projects
           @pretty = pretty
@@ -26,7 +27,7 @@ module CircleCI
 
         def print_pretty
           Terminal::Table.new(
-            title: 'Projects'.green,
+            title: Printer.colorize_green('Projects'),
             headings: ['User name', 'Repository name'],
             rows: @projects.map(&:information)
           ).to_s

data/lib/circleci/cli/printer/step_printer.rb

@@ -9,26 +9,36 @@ module CircleCI
           @pretty = pretty
         end
 
-        def to_s
-          Terminal::Table.new do |t|
-            @steps
-              .group_by(&:type)
-              .each do |key, steps|
-              t << :separator
-              t << [{ value: key.green, alignment: :center, colspan: 2 }]
-              steps.each { |s| print_actions(t, s) }
-            end
-          end.to_s
+        def to_s # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          if @pretty
+            Terminal::Table.new do |t|
+              @steps
+                .group_by(&:type)
+                .each do |key, steps|
+                t << :separator
+                t << [{ value: Printer.colorize_green(key), alignment: :center, colspan: 2 }]
+                steps.each { |s| print_actions(t, s) }
+              end
+            end.to_s
+          else
+            @steps.group_by(&:type).map do |_, steps|
+              steps.map do |step|
+                step.actions.map do |a|
+                  "#{colorize_by_status(a.name.slice(0..120), a.status)}\n#{"#{a.log}\n" if a.failed? && a.log}"
+                end
+              end.flatten.join('')
+            end.join("\n")
+          end
         end
 
         private
 
         def colorize_by_status(string, status)
           case status
-          when 'success', 'fixed' then string.green
-          when 'canceled' then string.yellow
-          when 'failed', 'timedout' then string.red
-          when 'no_tests', 'not_run' then string.light_black
+          when 'success', 'fixed' then Printer.colorize_green(string)
+          when 'canceled' then Printer.colorize_yellow(string)
+          when 'failed', 'timedout' then Printer.colorize_red(string)
+          when 'no_tests', 'not_run' then Printer.colorize_light_black(string)
           else string
           end
         end
@@ -36,8 +46,8 @@ module CircleCI
         def format_time(time)
           return '' unless time
 
-          minute = format('%02d', time / 1000 / 60)
-          second = format('%02d', (time / 1000) % 60)
+          minute = format('%<time>02d', time: time / 1000 / 60)
+          second = format('%<time>02d', time: (time / 1000) % 60)
           "#{minute}:#{second}"
         end