travis-akerl 1.8.9

data/lib/travis/pro.rb

@@ -0,0 +1,5 @@
+require 'travis/client'
+
+module Travis
+  Pro = Client::Namespace.new(Client::COM_URI)
+end

data/lib/travis/tools/assets.rb

@@ -0,0 +1,21 @@
+module Travis
+  module Tools
+    module Assets
+      BASE = File.expand_path('../../../../assets', __FILE__)
+      extend self
+
+      def asset_path(file)
+        File.expand_path(file, BASE)
+      end
+
+      def asset(file)
+        File.read(asset_path(file))
+      end
+
+      class << self
+        alias [] asset_path
+        alias read asset
+      end
+    end
+  end
+end

data/lib/travis/tools/completion.rb

@@ -0,0 +1,54 @@
+require 'travis/tools/assets'
+require 'travis/cli'
+require 'fileutils'
+require 'erb'
+
+module Travis
+  module Tools
+    module Completion
+      RCS = ['.zshrc', '.bashrc'].map { |f| File.expand_path(f, ENV['HOME']) }
+      include FileUtils
+      extend self
+
+      def config_path
+        ENV.fetch('TRAVIS_CONFIG_PATH') { File.expand_path('.travis', ENV['HOME']) }
+      end
+
+      def cmp_file
+        File.expand_path('travis.sh', config_path)
+      end
+
+      def install_completion
+        update_completion
+        source = "source " << cmp_file
+
+        RCS.each do |file|
+          next unless File.exist? file and File.writable? file
+          next if File.read(file).include? source
+          File.open(file, "a") { |f| f.puts("", "# added by travis gem", "[ -f #{cmp_file} ] && #{source}") }
+        end
+      end
+
+      def update_completion
+        mkdir_p(config_path)
+        cp(Assets['travis.sh'], cmp_file)
+      end
+
+      def completion_installed?
+        source = "source " << config_path
+        RCS.each do |file|
+          next unless File.exist? file and File.writable? file
+          return false unless File.read(file).include? source
+        end
+        true
+      end
+
+      def compile
+        commands = Travis::CLI.commands.sort_by { |c| c.command_name }
+        template = Assets.read('travis.sh.erb')
+        source   = ERB.new(template).result(binding).gsub(/^ +\n/, '')
+        File.write(Assets['travis.sh'], source)
+      end
+    end
+  end
+end

data/lib/travis/tools/formatter.rb

@@ -0,0 +1,50 @@
+require 'time'
+
+module Travis
+  module Tools
+    class Formatter
+      DAY         = 24 * 60 * 60
+      TIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+      CONFIG_KEYS = ['rvm', 'gemfile', 'env', 'jdk', 'otp_release', 'php', 'node_js', 'perl', 'python', 'scala', 'compiler', 'os']
+
+      def duration(seconds, suffix = nil)
+        return "none" if seconds.nil?
+        seconds          = (Time.now - seconds).to_i if seconds.is_a? Time
+        output           = []
+        minutes, seconds = seconds.divmod(60)
+        hours, minutes   = minutes.divmod(60)
+        output << "#{hours  } hrs" if hours > 0
+        output << "#{minutes} min" if minutes > 0
+        output << "#{seconds} sec" if seconds > 0 or output.empty?
+        output << suffix           if suffix
+        output.join(" ")
+      end
+
+      def file_size(input, human = true)
+        return "#{input} B" unless human
+        format = "B"
+        iec    = %w[KiB MiB GiB TiB PiB EiB ZiB YiB]
+        while human and input > 512 and iec.any?
+          input /= 1024.0
+          format = iec.shift
+        end
+        input = input.round(2) if input.is_a? Float
+        "#{input} #{format}"
+      end
+
+      def time(time)
+        return "not yet" if time.nil? # or time > Time.now
+        #return duration(time, "ago") if Time.now - time < DAY
+        time.localtime.strftime(TIME_FORMAT)
+      end
+
+      def job_config(config)
+        output = []
+        config.each_pair do |key, value|
+          output << "#{key}: #{value}" if CONFIG_KEYS.include? key
+        end
+        output.join(", ")
+      end
+    end
+  end
+end

data/lib/travis/tools/github.rb

@@ -0,0 +1,293 @@
+require 'travis/tools/system'
+require 'yaml'
+require 'json'
+
+module Travis
+  module Tools
+    class Github
+      TOKEN_SIZE  = 40
+      GITHUB_API  = 'api.github.com'
+      GITHUB_HOST = 'github.com'
+
+      attr_accessor :api_url, :scopes, :github_token, :github_login, :drop_token, :callback, :explode, :after_tokens,
+        :ask_login, :ask_password, :ask_otp, :login_header, :auto_token, :auto_password, :manual_login, :note,
+        :netrc_path, :hub_path, :oauth_paths, :composer_path, :git_config_keys, :debug, :no_token, :check_token
+
+      def initialize(options = nil)
+        @check_token     = true
+        @manual_login    = true
+        @ask_login       = proc { raise "ask_login callback not set" }
+        @after_tokens    = proc { }
+        @ask_password    = proc { |_| raise "ask_password callback not set" }
+        @ask_otp         = proc { |_| raise "ask_otp callback not set" }
+        @debug           = proc { |_| }
+        @netrc_path      = '~/.netrc'
+        @hub_path        = ENV['HUB_CONFIG'] || '~/.config/hub'
+        @oauth_paths     = ['~/.github-oauth-token']
+        @composer_path   = "~/.composer/config.json"
+        @note            = 'temporary token'
+        @git_config_keys = %w[github.token github.oauth-token]
+        @scopes          = ['user', 'user:email', 'repo'] # overridden by value from /config
+        options.each_pair { |k,v| send("#{k}=", v) if respond_to? "#{k}=" } if options
+        yield self if block_given?
+      end
+
+      def with_token
+        each_token { |t| break yield(t) }
+      end
+
+      def with_basic_auth(&block)
+        user, password = ask_credentials
+        basic_auth(user, password, true) do |gh, _|
+          gh['user'] # so otp kicks in
+          yield gh
+        end
+      end
+
+      def each_token
+        require 'gh' unless defined? GH
+        possible_tokens { |t| yield(t) if acceptable?(t) }
+      ensure
+        callback, self.callback = self.callback, nil
+        callback.call if callback
+      end
+
+      def with_session(&block)
+        with_token { |t| GH.with(:token => t) { yield(t) } }
+      end
+
+      def possible_tokens(&block)
+        return block[github_token] if github_token
+
+        if auto_token
+          netrc_tokens(&block)
+          git_tokens(&block)
+          hub_tokens(&block)
+          oauth_file_tokens(&block)
+          github_for_mac_token(&block)
+          issuepost_token(&block)
+          composer_token(&block)
+        end
+
+        if auto_password
+          possible_logins do |user, password|
+            yield login(user, password, false)
+          end
+        end
+
+        if manual_login
+          user, password = ask_credentials
+          yield login(user, password, true)
+        end
+
+        after_tokens.call
+      end
+
+      def ask_credentials
+        login_header.call if login_header
+        user     = github_login || ask_login.call
+        password = ask_password.arity == 0 ? ask_password.call : ask_password.call(user)
+        [user, password]
+      end
+
+      def possible_logins(&block)
+        netrc_logins(&block)
+        hub_logins(&block)
+        keychain_login(&block)
+      end
+
+      def netrc_tokens
+        netrc.each do |entry|
+          next unless entry["machine"] == api_host or entry["machine"] == host
+          entry.values_at("token", "login", "password").each do |entry|
+            next if entry.to_s.size != TOKEN_SIZE
+            debug "found oauth token in netrc"
+            yield entry
+          end
+        end
+      end
+
+      def git_tokens
+        return unless System.has? 'git'
+        git_config_keys.each do |key|
+          `git config --get-all #{key}`.each_line do |line|
+            token = line.strip
+            yield token unless token.empty?
+          end
+        end
+      end
+
+      def composer_token
+        file(composer_path) do |content|
+          token = JSON.parse(content)['config'].fetch('github-oauth', {})[host]
+          yield token if token
+        end
+      end
+
+      def hub_tokens
+        hub.fetch(host, []).each do |entry|
+          next if github_login and github_login != entry["user"]
+          yield entry["oauth_token"] if entry["oauth_token"]
+        end
+      end
+
+      def oauth_file_tokens(&block)
+        oauth_paths.each do |path|
+          file(path) do |content|
+            token = content.strip
+            yield token unless token.empty?
+          end
+        end
+      end
+
+      def netrc_logins
+        netrc.each do |entry|
+          next unless entry["machine"] == api_host or entry["machine"] == host
+          next if github_login and github_login != entry["login"]
+          yield entry["login"], entry["password"] if entry["login"] and entry["password"]
+        end
+      end
+
+      def hub_logins
+        hub.fetch(host, []).each do |entry|
+          next if github_login and github_login != entry["user"]
+          yield entry["user"], entry["password"] if entry["user"] and entry["password"]
+        end
+      end
+
+      def keychain_login
+        if github_login
+          security(:internet, :w, "-s #{host} -a #{github_login}", "#{host} password for #{github_login}") do |password|
+            yield github_login, password if password and not password.empty?
+          end
+        else
+          security(:internet, :g, "-s #{host}", "#{host} login and password") do |data|
+            username = data[/^\s+"acct"<blob>="(.*)"$/, 1].to_s
+            password = data[/^password: "(.*)"$/, 1].to_s
+            yield username, password unless username.empty? or password.empty?
+          end
+        end
+      end
+
+      def netrc
+        file(netrc_path, []) do |contents|
+          contents.scan(/^\s*(\S+)\s+(\S+)\s*$/).inject([]) do |mapping, (key, value)|
+            mapping << {} if key == "machine"
+            mapping.last[key] = value if mapping.last
+            mapping
+          end
+        end
+      end
+
+      def hub
+        file(hub_path, {}) do |contents|
+          YAML.load(contents)
+        end
+      end
+
+      def issuepost_token(&block)
+        security(:generic, :w, "-l issuepost.github.access_token",  "issuepost token", &block) if host == 'github.com'
+      end
+
+      def github_for_mac_token(&block)
+        command = '-s "github.com/mac"'
+        command << " -a #{github_login}" if github_login
+        security(:internet, :w, command, "GitHub for Mac token", &block) if host == 'github.com'
+      end
+
+      def host
+        api_host == GITHUB_API ? GITHUB_HOST : api_host
+      end
+
+      def api_host
+        return GITHUB_API unless api_url
+        api_url[%r{^(?:https?://)?([^/]+)}, 1]
+      end
+
+      def basic_auth(user, password, die = true, otp = nil, &block)
+        gh = GH.with(:username => user, :password => password)
+        with_otp(gh, user, otp, &block)
+      rescue GH::Error => error
+        raise gh_error(error) if die
+      end
+
+      def login(user, password, die = true, otp = nil)
+        basic_auth(user, password, die, otp) do |gh, new_otp|
+          reply         = create_token(gh)
+          auth_href     = reply['_links']['self']['href']
+          self.callback = proc { with_otp(gh, user, new_otp) { |g| g.delete(auth_href) } } if drop_token
+          reply['token']
+        end
+      end
+
+      def create_token(gh)
+        gh.post('/authorizations', :scopes => scopes, :note => note)
+      rescue GH::Error => error
+        # token might already exist due to bug in earlier CLI version, we'll have to delete it first
+        raise error unless error.info[:response_status] == 422 and error.info[:response_body].to_s =~ /already_exists/
+        raise error unless reply = gh['/authorizations'].detect { |a| a['note'] == note }
+        gh.delete(reply['_links']['self']['href'])
+        retry
+      end
+
+      def with_otp(gh, user, otp, &block)
+        gh = GH.with(gh.options.merge(:headers => { "X-GitHub-OTP" => otp })) if otp
+        block.call(gh, otp)
+      rescue GH::Error => error
+        raise error unless error.info[:response_status] == 401 and error.info[:response_headers]['x-github-otp'].to_s =~ /required/
+        otp = ask_otp.arity == 0 ? ask_otp.call : ask_otp.call(user)
+        retry
+      end
+
+      def acceptable?(token)
+        return true unless check_token
+        gh   = GH.with(:token => token)
+        user = gh['user']
+
+        if github_login and github_login != user['login']
+          debug "token is not acceptable: identifies %p instead of %p" % [user['login'], github_login]
+          false
+        else
+          true
+        end
+      rescue GH::Error => error
+        debug "token is not acceptable: #{gh_error(error)}"
+        false
+      end
+
+      private
+
+        def gh_error(error)
+          raise error if explode
+          JSON.parse(error.info[:response_body])["message"].to_s
+        end
+
+        def debug(line)
+          return unless @debug
+          @debug.call "Tools::Github: #{line}"
+        end
+
+        def security(type, key, arg, name)
+          return false unless System.has? 'security'
+          return false unless system "security find-#{type}-password #{arg} 2>/dev/null >/dev/null"
+          debug "requesting to load #{name} from keychain"
+          result = %x[security find-#{type}-password #{arg} -#{key} 2>&1].chomp
+          $?.success? ? yield(result) : debug("request denied")
+        rescue => e
+          raise e if explode
+        end
+
+        def file(path, default = nil)
+          path        &&= File.expand_path(path)
+          @file       ||= {}
+          @file[path] ||= if path and File.readable?(path)
+            debug "reading #{path}"
+            yield File.read(path)
+          end
+          @file[path] || default
+        rescue => e
+          raise e if explode
+        end
+    end
+  end
+end

data/lib/travis/tools/notification.rb

@@ -0,0 +1,69 @@
+require "travis"
+require "travis/tools/system"
+require "travis/tools/assets"
+require "cgi"
+
+module Travis
+  module Tools
+    module Notification
+      extend self
+      DEFAULT = [:osx, :growl, :libnotify]
+      ICON    = Assets['notifications/icon.png']
+
+      def new(*list)
+        list.concat(DEFAULT) if list.empty?
+        notification = list.map { |n| get(n) }.detect { |n| n.available? }
+        raise ArgumentError, "no notification system found (looked for #{list.join(", ")})" unless notification
+        notification
+      end
+
+      def get(name)
+        const = constants.detect { |c| c.to_s[/[^:]+$/].downcase == name.to_s }
+        raise ArgumentError, "unknown notifications type %p" % name unless const
+        const_get(const).new
+      end
+
+      class Dummy
+        BIN_PATH = Assets['Travis CI.app/Contents/MacOS/Travis CI']
+        def notify(title, body)
+        end
+
+        def available?
+          true
+        end
+      end
+
+      class OSX
+        BIN_PATH = Assets["notifications/Travis CI.app/Contents/MacOS/Travis CI"]
+
+        def notify(title, body)
+          system BIN_PATH, '-message', body.to_s, '-title', title.to_s, '-sender', 'org.travis-ci.Travis-CI'
+        end
+
+        def available?
+          System.mac? and System.recent_version?(System.os_version.to_s, '10.8') and System.running? "NotificationCenter"
+        end
+      end
+
+      class Growl
+        def notify(title, body)
+          system 'growlnotify', '-n', 'Travis', '--image', ICON, '-m', body, title
+        end
+
+        def available?
+          System.has? 'growlnotify' and System.running? "Growl"
+        end
+      end
+
+      class LibNotify
+        def notify(title, body)
+          system 'notify-send', '--expire-time=10000', '-h', 'int:transient:1', '-i', ICON, title, CGI.escapeHTML(body)
+        end
+
+        def available?
+          System.has? 'notify-send'
+        end
+      end
+    end
+  end
+end

data/lib/travis/tools/safe_string.rb

@@ -0,0 +1,22 @@
+module Travis
+  module Tools
+    module SafeString
+      extend self
+
+      def encoded(string)
+        return string unless string.respond_to? :encode
+        string.encode 'utf-8'
+      rescue Encoding::UndefinedConversionError
+        string.force_encoding 'utf-8'
+      end
+
+      def colorized(string)
+        encoded(string).gsub(/[^[:print:]\e\n]/, '')
+      end
+
+      def clean(string)
+        colorized(string).gsub(/\e[^m]+m/, '')
+      end
+    end
+  end
+end

data/lib/travis/tools/ssl_key.rb

@@ -0,0 +1,48 @@
+require 'openssl'
+require 'base64'
+
+module Travis
+  module Tools
+    module SSLKey
+      extend self
+
+      def generate_rsa(size = 2048)
+        OpenSSL::PKey::RSA.generate(size)
+      end
+
+      def public_rsa_key(string)
+        @to_rsa ||= OpenSSL::PKey::RSA.new(string)
+      rescue OpenSSL::PKey::RSAError
+        public_key = string.gsub('RSA PUBLIC KEY', 'PUBLIC KEY')
+        @to_rsa = OpenSSL::PKey::RSA.new(public_key)
+      end
+
+      def has_passphrase?(key)
+        OpenSSL::PKey::RSA.new(key, key)
+        false
+      rescue OpenSSL::PKey::RSAError
+        true
+      end
+
+      def remove_passphrase(key, passphrase)
+        OpenSSL::PKey::RSA.new(key, passphrase).to_s
+      rescue OpenSSL::PKey::RSAError
+        false
+      end
+
+      def rsa_ssh(key)
+        ['ssh-rsa ', "\0\0\0\assh-rsa#{sized_bytes(key.e)}#{sized_bytes(key.n)}"].pack('a*m').gsub("\n", '')
+      end
+
+      def sized_bytes(value)
+        bytes = to_byte_array(value.to_i)
+        [bytes.size, *bytes].pack('NC*')
+      end
+
+      def to_byte_array(num, *significant)
+        return significant if num.between?(-1, 0) and significant[0][7] == num[7]
+        to_byte_array(*num.divmod(256)) + significant
+      end
+    end
+  end
+end

data/lib/travis/tools/system.rb

@@ -0,0 +1,88 @@
+module Travis
+  module Tools
+    module System
+      extend self
+
+      def recent_version?(version, minimum)
+        version = version.split('.').map { |s| s.to_i }
+        minimum = minimum.split('.').map { |s| s.to_i }
+        (version <=> minimum) >= 0
+      end
+
+      def windows?
+        File::ALT_SEPARATOR == "\\"
+      end
+
+      def mac?
+        RUBY_PLATFORM =~ /darwin/i
+      end
+
+      def linux?
+        RUBY_PLATFORM =~ /linux/i
+      end
+
+      def unix?
+        not windows?
+      end
+
+      def os
+        os_name ? "#{os_name} #{os_version}".strip : os_type
+      end
+
+      def full_os
+        os_name == os_type ? os : "#{os} like #{os_type}"
+      end
+
+      def os_version
+        @os_version ||= has?(:sw_vers)     && `sw_vers -productVersion`.chomp
+        @os_version ||= has?(:lsb_release) && `lsb_release -r -s`.chomp
+      end
+
+      def os_name
+        @os_name ||= has?(:sw_vers)     && `sw_vers -productName`.chomp
+        @os_name ||= has?(:lsb_release) && `lsb_release -i -s`.chomp
+      end
+
+      def os_type
+        @os_type ||= windows? ? 'Windows' : `uname`.chomp
+      end
+
+      def ruby_engine
+        defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
+      end
+
+      def ruby_version
+        "%s-p%s" % [RUBY_VERSION, RUBY_PATCHLEVEL]
+      end
+
+      def ruby
+        case ruby_engine
+        when 'ruby'  then "Ruby #{ruby_version}"
+        when 'jruby' then "JRuby #{JRUBY_VERSION} like Ruby #{ruby_version}"
+        when 'rbx'   then "Rubinius #{Rubinius.version[/\d\S+/]} like Ruby #{ruby_version}"
+        else              "#{ruby_engine} like Ruby #{ruby_version}"
+        end
+      end
+
+      def rubygems
+        return "no RubyGems" unless defined? Gem
+        "RubyGems #{Gem::VERSION}"
+      end
+
+      def description(*args)
+        [ full_os, ruby, rubygems, *args.flatten].compact.uniq.join("; ")
+      end
+
+      def has?(command)
+        return false unless unix?
+        @has ||= {}
+        @has.fetch(command) { @has[command] = system "which #{command} 2>/dev/null >/dev/null" }
+      end
+
+      def running?(app)
+        return false unless unix?
+        system "pgrep -u $(whoami) #{app} >/dev/null"
+      end
+    end
+  end
+end

data/lib/travis/version.rb

@@ -0,0 +1,3 @@
+module Travis
+  VERSION = '1.8.9'
+end

data/lib/travis.rb

@@ -0,0 +1,8 @@
+module Travis
+  autoload :Client,   'travis/client'
+  autoload :CLI,      'travis/cli'
+  autoload :Pro,      'travis/pro'
+  autoload :Version,  'travis/version'
+
+  include Client::Namespace.new(Client::ORG_URI)
+end