travis-async-listener 1.8.3

data/lib/travis/cli/api_command.rb

@@ -0,0 +1,180 @@
+require 'travis/cli'
+
+module Travis
+  module CLI
+    class ApiCommand < Command
+      include Travis::Client::Methods
+      attr_accessor :enterprise_name
+      attr_reader :session
+      abstract
+
+      on('-e', '--api-endpoint URL', 'Travis API server to talk to')
+      on('-I', '--[no-]insecure', 'do not verify SSL certificate of API endpoint')
+      on('--pro', "short-cut for --api-endpoint '#{Travis::Client::PRO_URI}'") { |c,_| c.api_endpoint = Travis::Client::PRO_URI }
+      on('--org', "short-cut for --api-endpoint '#{Travis::Client::ORG_URI}'") { |c,_| c.api_endpoint = Travis::Client::ORG_URI }
+      on('--staging', 'talks to staging system') { |c,_| c.api_endpoint = c.api_endpoint.gsub(/api/, 'api-staging') }
+      on('-t', '--token [ACCESS_TOKEN]', 'access token to use') { |c, t| c.access_token = t }
+
+      on('--debug', 'show API requests') do |c,_|
+        c.debug = true
+        c.session.instrument do |info, request|
+          c.time(info, request)
+        end
+      end
+
+      on('--debug-http', 'show HTTP(S) exchange') do |c,_|
+        c.session.debug_http = true
+      end
+
+      on('-X', '--enterprise [NAME]', 'use enterprise setup (optionally takes name for multiple setups)') do |c, name|
+        c.enterprise_name = name || 'default'
+      end
+
+      on('--adapter ADAPTER', 'Faraday adapter to use for HTTP requests') do |c, adapter|
+        adapter.gsub! '-', '_'
+        require "faraday/adapter/#{adapter}"
+        require 'typhoeus/adapters/faraday' if adapter == 'typhoeus'
+        c.session.faraday_adapter = adapter.to_sym
+      end
+
+      def initialize(*)
+        @session = Travis::Client.new(:agent_info => "command #{command_name}")
+        super
+      end
+
+      def endpoint_config
+        config['endpoints'] ||= {}
+        config['endpoints'][api_endpoint] ||= {}
+      end
+
+      def setup
+        setup_enterprise
+        self.api_endpoint = default_endpoint if default_endpoint and not explicit_api_endpoint?
+        self.access_token               ||= fetch_token
+        endpoint_config['access_token'] ||= access_token
+        endpoint_config['insecure']       = insecure unless insecure.nil?
+        self.insecure                     = endpoint_config['insecure']
+        session.ssl                       = { :verify => false } if insecure?
+        authenticate if pro? or enterprise?
+      end
+
+      def enterprise?
+        !!endpoint_config['enterprise']
+      end
+
+      def pro?
+        api_endpoint == Travis::Client::PRO_URI
+      end
+
+      def org?
+        api_endpoint == Travis::Client::ORG_URI
+      end
+
+      def detected_endpoint?
+        api_endpoint == detected_endpoint
+      end
+
+      def authenticate
+        error "not logged in, please run #{command("login#{endpoint_option}")}" if access_token.nil?
+      end
+
+      def sync(block = true, dot = '.')
+        user.sync
+
+        steps = count = 1
+        while block and user.reload.syncing?
+          count += 1
+          sleep(1)
+
+          if count % steps == 0
+            steps = count/10 + 1
+            output.print dot
+          end
+        end
+      end
+
+      private
+
+        def setup_enterprise
+          return unless setup_enterprise?
+          c = config['enterprise'] ||= {}
+          c[enterprise_name] = api_endpoint if explicit_api_endpoint?
+          c[enterprise_name] ||= write_to($stderr) do
+            error "enterprise setup not configured" unless interactive?
+            user_input                  = ask(color("Enterprise domain: ", :bold)).to_s
+            domain                      = user_input[%r{^(?:https?://)?(.*?)/?(?:/api/?)?$}, 1]
+            endpoint                    = "https://#{domain}/api"
+            config['default_endpoint']  = endpoint if agree("Use #{color domain, :bold} as default endpoint? ") { |q| q.default = 'yes' }
+            endpoint
+          end
+          self.api_endpoint             = c[enterprise_name]
+          self.insecure                 = true if insecure.nil?
+          endpoint_config['enterprise'] = true
+          @setup_ennterpise             = true
+        end
+
+        def setup_enterprise?
+          @setup_ennterpise ||= false
+          !!enterprise_name and not @setup_ennterpise
+        end
+
+        def load_gh
+          return if defined? GH
+          debug "Loading gh"
+          require 'gh'
+
+          gh_config       = session.config['github']
+          gh_config     &&= gh_config.inject({}) { |h,(k,v)| h.update(k.to_sym => v) }
+          gh_config     ||= {}
+          gh_config[:ssl] = Travis::Client::Session::SSL_OPTIONS
+          gh_config[:ssl] = { :verify => false } if gh_config[:api_url] and gh_config[:api_url] != "https://api.github.com"
+          gh_config.delete :scopes
+
+          gh_config[:instrumenter] = proc do |type, payload, &block|
+            next block.call unless type == 'http.gh'
+            time("GitHub API: #{payload[:verb].to_s.upcase} #{payload[:url]}", block)
+          end if debug?
+
+          GH.set(gh_config)
+        end
+
+        def github_endpoint
+          load_gh
+          GH.with({}).api_host
+        end
+
+        def listen(*args)
+          super(*args) do |listener|
+            on_signal { listener.disconnect }
+            yield listener
+          end
+        end
+
+        def default_endpoint
+          ENV['TRAVIS_ENDPOINT'] || config['default_endpoint']
+        end
+
+        def detected_endpoint
+          default_endpoint || Travis::Client::ORG_URI
+        end
+
+        def endpoint_option
+          return ""       if org? and detected_endpoint?
+          return " --org" if org?
+          return " --pro" if pro?
+
+          if config['enterprise']
+            key, _ = config['enterprise'].detect { |k,v| v.start_with? api_endpoint }
+            return " -X"        if key == "default"
+            return " -X #{key}" if key
+          end
+
+          " -e %p" % api_endpoint
+        end
+
+        def fetch_token
+          ENV['TRAVIS_TOKEN'] || endpoint_config['access_token']
+        end
+    end
+  end
+end

data/lib/travis/cli/branches.rb

@@ -0,0 +1,25 @@
+require 'travis/cli'
+
+module Travis
+  module CLI
+    class Branches < RepoCommand
+      description "displays the most recent build for each branch"
+
+      def run
+        repository.last_on_branch.each do |build|
+          say [
+            color("#{build.branch_info}:".ljust(longest + 2), [:info, :bold]),
+            color("##{build.number.to_s.ljust(4)} #{build.state}".ljust(16), build.color),
+            build.commit.subject
+          ].join(" ").strip + "\n"
+        end
+      end
+
+      private
+
+        def longest
+          repository.branches.keys.map { |b| b.size }.max
+        end
+    end
+  end
+end

data/lib/travis/cli/cache.rb

@@ -0,0 +1,76 @@
+require 'travis/cli'
+
+module Travis
+  module CLI
+    class Cache < RepoCommand
+      description 'lists or deletes repository caches'
+      on '-d', '--delete',        'delete listed caches'
+      on '-b', '--branch BRANCH', 'only list/delete caches on given branch'
+      on '-m', '--match STRING',  'only list/delete caches where slug matches given string'
+      on '-f', '--force',         'do not ask user to confirm deleting the caches'
+
+      def run
+        error "not allowed to access caches for #{color(repository.slug, :bold)}" unless repository.push?
+        branches = caches.group_by(&:branch)
+        check_caches
+
+        warn "Deleted the following caches:\n" if delete?
+        branches.each { |name, list| display_branch(name, list) }
+        size = caches.inject(0) { |s,c| s + c.size }
+        say "Overall size of above caches: " << formatter.file_size(size)
+      end
+
+      private
+
+        def check_caches
+          return if caches.any?
+          say "no caches found"
+          exit
+        end
+
+        def display_branch(name, list)
+          say color(name ? "On branch #{name}:" : "Global:", :important)
+          list.each { |c| display_cache(c) }
+          puts
+        end
+
+        def display_cache(cache)
+          say [
+            color(cache.slug.ljust(space), :bold),
+            "last modified: " << formatter.time(cache.last_modified),
+            "size: " << formatter.file_size(cache.size)
+          ].join("  ") << "\n"
+        end
+
+        def params
+          params = {}
+          params[:branch] = branch if branch?
+          params[:match]  = match  if match?
+          params
+        end
+
+        def caches
+          @caches ||= drop? ? repository.delete_caches(params) : repository.caches(params)
+        end
+
+        def space
+          @space ||= caches.map(&:slug).map(&:size).max
+        end
+
+        def drop?
+          return false unless delete?
+          return true if force?
+          error "not deleting caches without --force" unless interactive?
+          error "aborted" unless danger_zone? "Do you really want to delete #{description}?"
+          true
+        end
+
+        def description
+          description = color("all caches", :important)
+          description << " on branch #{color(branch, :important)}" if branch?
+          description << " that match #{color(match, :important)}" if match?
+          description
+        end
+    end
+  end
+end

data/lib/travis/cli/cancel.rb

@@ -0,0 +1,18 @@
+require 'travis/cli'
+
+module Travis
+  module CLI
+    class Cancel < RepoCommand
+      description "cancels a job or build"
+
+      def run(number = last_build.number)
+        authenticate
+        entity = job(number) || build(number)
+        error "could not find job or build #{repository.slug}##{number}" unless entity
+        entity.cancel
+
+        say "canceled", "#{entity.class.one} ##{entity.number} has been %s"
+      end
+    end
+  end
+end

data/lib/travis/cli/command.rb

@@ -0,0 +1,422 @@
+require 'travis/cli'
+require 'travis/tools/system'
+require 'travis/tools/formatter'
+require 'travis/tools/assets'
+require 'travis/tools/completion'
+require 'travis/version'
+
+require 'highline'
+require 'forwardable'
+require 'yaml'
+require 'timeout'
+
+module Travis
+  module CLI
+    class Command
+      MINUTE = 60
+      HOUR   = 3600
+      DAY    = 86400
+      WEEK   = 604800
+
+      include Tools::Assets
+      extend Parser, Forwardable, Tools::Assets
+      def_delegators :terminal, :agree, :ask, :choose
+
+      HighLine.use_color = Tools::System.unix? && $stdout.tty?
+      HighLine.color_scheme = HighLine::ColorScheme.new do |cs|
+        cs[:command]   = [ :bold             ]
+        cs[:error]     = [ :red              ]
+        cs[:important] = [ :bold, :underline ]
+        cs[:success]   = [ :green            ]
+        cs[:info]      = [ :yellow           ]
+        cs[:debug]     = [ :magenta          ]
+      end
+
+      on('-h', '--help', 'Display help') do |c, _|
+        c.say c.help
+        exit
+      end
+
+      on('-i', '--[no-]interactive', "be interactive and colorful") do |c, v|
+        HighLine.use_color = v if Tools::System.unix?
+        c.force_interactive = v
+      end
+
+      on('-E', '--[no-]explode', "don't rescue exceptions")
+      on('--skip-version-check', "don't check if travis client is up to date")
+      on('--skip-completion-check', "don't check if auto-completion is set up")
+
+      def self.command_name
+        name[/[^:]*$/].split(/(?=[A-Z])/).map(&:downcase).join('-')
+      end
+
+      @@abstract ||= [Command] # ignore the man behind the courtains!
+      def self.abstract?
+        @@abstract.include? self
+      end
+
+      def self.abstract
+        @@abstract << self
+      end
+
+      def self.skip(*names)
+        names.each { |n| define_method(n) {} }
+      end
+
+      def self.description(description = nil)
+        @description = description if description
+        @description ||= ""
+      end
+
+      def self.subcommands(*list)
+        return @subcommands ||= [] if list.empty?
+        @subcommands = list
+
+        define_method :run do |subcommand, *args|
+          error "Unknown subcommand. Available: #{list.join(', ')}." unless list.include? subcommand.to_sym
+          send(subcommand, *args)
+        end
+
+        define_method :usage do
+          usages = list.map { |c| color(usage_for("#{command_name} #{c}", c), :command) }
+          "\nUsage: #{usages.join("\n       ")}\n\n"
+        end
+      end
+
+      attr_accessor :arguments, :config, :force_interactive, :formatter, :debug
+      attr_reader :input, :output
+      alias_method :debug?, :debug
+
+      def initialize(options = {})
+        @on_signal  = []
+        @formatter  = Travis::Tools::Formatter.new
+        self.output = $stdout
+        self.input  = $stdin
+        options.each do |key, value|
+          public_send("#{key}=", value) if respond_to? "#{key}="
+        end
+        @arguments ||= []
+      end
+
+      def terminal
+        @terminal ||= HighLine.new(input, output)
+      end
+
+      def input=(io)
+        @terminal = nil
+        @input = io
+      end
+
+      def output=(io)
+        @terminal = nil
+        @output = io
+      end
+
+      def write_to(io)
+        io_was, self.output = output, io
+        yield
+      ensure
+        self.output = io_was if io_was
+      end
+
+      def parse(args)
+        rest = parser.parse(args)
+        arguments.concat(rest)
+      rescue OptionParser::ParseError => e
+        error e.message
+      end
+
+      def setup
+      end
+
+      def last_check
+        config['last_check'] ||= {
+          # migrate from old values
+          'at'   => config.delete('last_version_check'),
+          'etag' => config.delete('etag')
+        }
+      end
+
+      def check_version
+        last_check.clear if last_check['version'] != Travis::VERSION
+        seconds_since = Time.now.to_i - last_check['at'].to_i
+
+        return if skip_version_check?
+        return if seconds_since < MINUTE
+
+        case seconds_since
+        when MINUTE .. HOUR then timeout = 0.5
+        when HOUR   .. DAY  then timeout = 1.0
+        when DAY    .. WEEK then timeout = 2.0
+        else                     timeout = 10.0
+        end
+
+        Timeout.timeout(timeout) do
+          response              = Faraday.get('https://rubygems.org/api/v1/gems/travis.json', {}, 'If-None-Match' => last_check['etag'].to_s)
+          last_check['etag']    = response.headers['etag']
+          last_check['version'] = JSON.parse(response.body)['version'] if response.status == 200
+        end
+
+        last_check['at'] = Time.now.to_i
+        unless Tools::System.recent_version? Travis::VERSION, last_check['version']
+          warn "Outdated CLI version, run `gem install travis`."
+        end
+      rescue Timeout::Error, Faraday::Error::ClientError => error
+        debug "#{error.class}: #{error.message}"
+      end
+
+      def check_completion
+        return if skip_completion_check? or !interactive?
+
+        if config['checked_completion']
+          Tools::Completion.update_completion if config['completion_version'] != Travis::VERSION
+        else
+          write_to($stderr) do
+            next Tools::Completion.update_completion if Tools::Completion.completion_installed?
+            next unless agree('Shell completion not installed. Would you like to install it now? ') { |q| q.default = "y" }
+            Tools::Completion.install_completion
+          end
+        end
+
+        config['checked_completion'] = true
+        config['completion_version'] = Travis::VERSION
+      end
+
+      def check_ruby
+        return if RUBY_VERSION > '1.9.2' or skip_version_check?
+        warn "Your Ruby version is outdated, please consider upgrading, as we will drop support for #{RUBY_VERSION} soon!"
+      end
+
+      def execute
+        setup_trap
+        check_ruby
+        check_arity(method(:run), *arguments)
+        load_config
+        check_version
+        check_completion
+        setup
+        run(*arguments)
+        clear_error
+        store_config
+      rescue Travis::Client::NotLoggedIn => e
+        raise(e) if explode?
+        error "#{e.message} - try running #{command("login#{endpoint_option}")}"
+      rescue Travis::Client::NotFound => e
+        raise(e) if explode?
+        error "resource not found (#{e.message})"
+      rescue Travis::Client::Error => e
+        raise(e) if explode?
+        error e.message
+      rescue StandardError => e
+        raise(e) if explode?
+        message = e.message
+        message += color("\nfor a full error report, run #{command("report#{endpoint_option}")}", :error) if interactive?
+        store_error(e)
+        error(message)
+      end
+
+      def command_name
+        self.class.command_name
+      end
+
+      def usage
+        "Usage: " << color(usage_for(command_name, :run), :command)
+      end
+
+      def usage_for(prefix, method)
+        usage = "travis #{prefix}"
+        method = method(method)
+        if method.respond_to? :parameters
+          method.parameters.each do |type, name|
+            name = name.upcase
+            name = "[#{name}]"   if type == :opt
+            name = "[#{name}..]" if type == :rest
+            usage << " #{name}"
+          end
+        elsif method.arity != 0
+          usage << " ..."
+        end
+        usage << " [OPTIONS]"
+      end
+
+      def help(info = "")
+        parser.banner = usage
+        self.class.description.sub(/./) { |c| c.upcase } + ".\n" + info + parser.to_s
+      end
+
+      def say(data, format = nil, style = nil)
+        terminal.say format(data, format, style)
+      end
+
+      def debug(line)
+        return unless debug?
+        write_to($stderr) do
+          say color("** #{line}", :debug)
+        end
+      end
+
+      def time(info, callback = Proc.new)
+        return callback.call unless debug?
+        start = Time.now
+        debug(info)
+        callback.call
+        duration = Time.now - start
+        debug("  took %.2g seconds" % duration)
+      end
+
+      def info(line)
+        write_to($stderr) do
+          say color(line, :info)
+        end
+      end
+
+      def on_signal(&block)
+        @on_signal << block
+      end
+
+      private
+
+        def store_error(exception)
+          message = "An error occurred running `travis %s%s`:\n    %p: %s\n" % [command_name, endpoint_option, exception.class, exception.message]
+          exception.backtrace.each { |l| message << "        from #{l}\n" }
+          save_file("error.log", message)
+        end
+
+        def clear_error
+          delete_file("error.log")
+        end
+
+        def setup_trap
+          [:INT, :TERM].each do |signal|
+            trap signal do
+              @on_signal.each { |c| c.call }
+              exit 1
+            end
+          end
+        end
+
+        def format(data, format = nil, style = nil)
+          style ||= :important
+          data = format % color(data, style) if format and interactive?
+          data = data.gsub(/<\[\[/, '<%=').gsub(/\]\]>/, '%>')
+          data.encode! 'utf-8' if data.respond_to? :encode!
+          data
+        end
+
+        def template(*args)
+          File.read(*args).split('__END__', 2)[1].strip
+        end
+
+        def color(line, style)
+          return line.to_s unless interactive?
+          terminal.color(line || '???', Array(style).map(&:to_sym))
+        end
+
+        def interactive?(io = output)
+          return io.tty? if force_interactive.nil?
+          force_interactive
+        end
+
+        def empty_line
+          say "\n"
+        end
+
+        def warn(message)
+          write_to($stderr) do
+            say color(message, :error)
+            yield if block_given?
+          end
+        end
+
+        def error(message, &block)
+          warn(message, &block)
+          exit 1
+        end
+
+        def command(name)
+          color("#{File.basename($0)} #{name}", :command)
+        end
+
+        def success(line)
+          say color(line, :success) if interactive?
+        end
+
+        def config_path(name)
+          path = ENV.fetch('TRAVIS_CONFIG_PATH') { File.expand_path('.travis', Dir.home) }
+          Dir.mkdir(path, 0700) unless File.directory? path
+          File.join(path, name)
+        end
+
+        def load_file(name, default = nil)
+          return default unless path = config_path(name) and File.exist? path
+          debug "Loading %p" % path
+          File.read(path)
+        end
+
+        def delete_file(name)
+          return unless path = config_path(name) and File.exist? path
+          debug "Deleting %p" % path
+          File.delete(path)
+        end
+
+        def save_file(name, content, read_only = false)
+          path = config_path(name)
+          debug "Storing %p" % path
+          File.open(path, 'w') do |file|
+            file.write(content.to_s)
+            file.chmod(0600) if read_only
+          end
+        end
+
+        YAML_ERROR = defined?(Psych::SyntaxError) ? Psych::SyntaxError : ArgumentError
+        def load_config
+          @config          = YAML.load load_file('config.yml', '{}')
+          @config        ||= {}
+          @original_config = @config.dup
+        rescue YAML_ERROR => error
+          raise error if explode?
+          warn "Broken config file: #{color config_path('config.yml'), :bold}"
+          exit 1 unless interactive? and agree("Remove config file? ") { |q| q.default = "no" }
+          @original_config, @config = {}, {}
+        end
+
+        def store_config
+          save_file('config.yml', @config.to_yaml, true)
+        end
+
+        def check_arity(method, *args)
+          return unless method.respond_to? :parameters
+          method.parameters.each do |type, name|
+            return if type == :rest
+            wrong_args("few") unless args.shift or type == :opt or type == :block
+          end
+          wrong_args("many") if args.any?
+        end
+
+        def danger_zone?(message)
+          agree(color("DANGER ZONE: ", [:red, :bold]) << message << " ") { |q| q.default = "no" }
+        end
+
+        def write_file(file, content, force = false)
+          error "#{file} already exists" unless write_file?(file, force)
+          File.write(file, content)
+        end
+
+        def write_file?(file, force)
+          return true if force or not File.exist?(file)
+          return false unless interactive?
+          danger_zone? "Override existing #{color(file, :info)}?"
+        end
+
+        def wrong_args(quantity)
+          error "too #{quantity} arguments" do
+            say help
+          end
+        end
+
+        def endpoint_option
+          ""
+        end
+    end
+  end
+end