travis-akerl 1.8.9

data/lib/travis/client/request.rb

@@ -0,0 +1,36 @@
+require 'travis/client/weak_entity'
+
+module Travis
+  module Client
+    class Request < WeakEntity
+      # @!parse attr_reader :commit_id, :repository_id, :created_at, :owner_id, :owner_type, :event_type, :base_commit, :head_commit, :result, :message, :pull_request, :pull_request_number, :pull_request_title, :branch, :tag
+      attributes :commit_id, :repository_id, :created_at, :owner_id, :owner_type, :event_type, :base_commit, :head_commit, :result, :message, :pull_request, :pull_request_number, :pull_request_title, :branch, :tag
+      time :created_at
+
+      # @!parse attr_reader :repository
+      has :repository, :commit
+
+      one  :request
+      many :requests
+
+      def owner
+        repository.owner
+      end
+
+      def accepted?
+        result == 'accepted'
+      end
+
+      def rejected?
+        result == 'rejected'
+      end
+
+      def inspect_info
+        [
+          repository && repository.slug,
+          event_type, branch || pull_request_number, result
+        ].compact.join(" ")
+      end
+    end
+  end
+end

data/lib/travis/client/restartable.rb

@@ -0,0 +1,23 @@
+require 'travis/client'
+
+module Travis
+  module Client
+    module Restartable
+      def restartable?
+        true
+      end
+
+      def restart
+        session.restart(self)
+      end
+
+      def cancelable?
+        true
+      end
+
+      def cancel
+        session.cancel(self)
+      end
+    end
+  end
+end

data/lib/travis/client/session.rb

@@ -0,0 +1,339 @@
+require 'travis/client'
+require 'travis/version'
+
+require 'faraday'
+require 'faraday_middleware'
+require 'travis/tools/system'
+require 'travis/tools/assets'
+
+begin
+  require 'typhoeus/adapters/faraday' unless Travis::Tools::System.windows?
+rescue LoadError
+end
+
+require 'json'
+
+module Travis
+  module Client
+    class Session
+      PRIMITIVE   = [nil, false, true]
+      SSL_OPTIONS = { :ca_file => Tools::Assets['cacert.pem'] }
+
+      include Methods
+      attr_reader :connection, :headers, :access_token, :instruments, :faraday_adapter, :agent_info, :ssl
+      attr_accessor :debug_http
+
+      def initialize(options = Travis::Client::ORG_URI)
+        @headers         = {}
+        @cache           = {}
+        @instruments     = []
+        @agent_info      = []
+        @config          = nil
+        @faraday_adapter = defined?(Typhoeus) ? :typhoeus : :net_http
+        @ssl             = SSL_OPTIONS
+
+        options = { :uri => options } unless options.respond_to? :each_pair
+        options.each_pair { |key, value| public_send("#{key}=", value) }
+
+        raise ArgumentError, "neither :uri nor :connection specified" unless connection
+        headers['Accept'] = 'application/vnd.travis-ci.2+json'
+        set_user_agent
+        check_ssl
+      end
+
+      def uri
+        connection.url_prefix.to_s if connection
+      end
+
+      def agent_info=(info)
+        @agent_info = [info].flatten.freeze
+        set_user_agent
+      end
+
+      def ssl=(options)
+        @ssl     = options.dup.freeze
+        self.uri = uri if uri
+      end
+
+      def uri=(uri)
+        clear_cache!
+        self.connection = Faraday.new(:url => uri, :ssl => ssl) do |faraday|
+          faraday.request  :url_encoded
+          faraday.response :logger if debug_http
+          faraday.adapter(*faraday_adapter)
+        end
+      end
+
+      def faraday_adapter=(adapter)
+        @faraday_adapter = adapter
+        self.uri &&= uri
+        set_user_agent
+      end
+
+      def access_token=(token)
+        clear_cache!
+        @access_token = token
+        headers['Authorization'] = "token #{token}"
+        headers.delete('Authorization') unless token
+      end
+
+      def connection=(connection)
+        clear_cache!
+        connection.headers.merge! headers
+        @config     = nil
+        @connection = connection
+        @headers    = connection.headers
+      end
+
+      def headers=(headers)
+        clear_cache!
+        connection.headers = headers if connection
+        @headers = headers
+      end
+
+      def find_one(entity, id = nil)
+        raise Travis::Client::Error, "cannot fetch #{entity}" unless entity.respond_to?(:many) and entity.many
+        return create_entity(entity, entity.id_field => id) if entity.id? id
+        cached(entity, :by, id) { fetch_one(entity, id) }
+      end
+
+      def find_many(entity, args = {})
+        raise Travis::Client::Error, "cannot fetch #{entity}" unless entity.respond_to?(:many) and entity.many
+        cached(entity, :many, args) { fetch_many(entity, args) }
+      end
+
+      def find_one_or_many(entity, args = nil)
+        raise Travis::Client::Error, "cannot fetch #{entity}" unless entity.respond_to?(:many) and entity.many
+        cached(entity, :one_or_many, args) do
+          path       = "/#{entity.many}"
+          path, args = "#{path}/#{args}", {} unless args.is_a? Hash
+          result     = get(path, args)
+          one        = result[entity.one]
+
+          if result.include? entity.many
+            Array(one) + Array(result[entity.many])
+          else
+            one
+          end
+        end
+      end
+
+      def reset(entity)
+        entity.attributes.clear
+        entity
+      end
+
+      def reload(entity)
+        reset(entity)
+        result = fetch_one(entity.class, entity.id)
+        entity.update_attributes(result.attributes) if result.attributes != entity.attributes
+        result
+      end
+
+      def config
+        @config ||= get_raw('/config')['config'] || {}
+      end
+
+      def load(data)
+        result = {}
+        (data || {}).each_pair do |key, value|
+          entity      = load_entity(key, value)
+          result[key] = entity if entity
+        end
+        result
+      end
+
+      def load_entity(key, value)
+        type = Entity.subclass_for(key)
+        if value.respond_to? :to_ary
+          value.to_ary.map { |e| create_entity(type, e) }
+        else
+          create_entity(type, value)
+        end
+      rescue IndexError
+      end
+
+      def preload(list)
+        list.group_by(&:class).each do |type, instances|
+          next unless type.preloadable?
+          ids = instances.map { |e| e.id unless e.complete? }.compact
+          find_many(type, :ids => ids) if ids.any?
+        end
+        list
+      end
+
+      def get(*args)
+        load get_raw(*args)
+      end
+
+      def delete(*args)
+        load delete_raw(*args)
+      end
+
+      def patch(*args)
+        load patch_raw(*args)
+      end
+
+      def post(*args)
+        load post_raw(*args)
+      end
+
+      def put(*args)
+        load put_raw(*args)
+      end
+
+      def get_raw(*args)
+        raw(:get, *args)
+      end
+
+      def post_raw(*args)
+        raw(:post, *args)
+      end
+
+      def put_raw(*args)
+        raw(:put, *args)
+      end
+
+      def patch_raw(*args)
+        raw(:patch, *args)
+      end
+
+      def delete_raw(*args)
+        raw(:delete, *args)
+      end
+
+      def raw(verb, url, *args)
+        url     = url.sub(/^\//, '')
+        result  = instrumented(verb.to_s.upcase, url, *args) do
+          if url !~ /^https?:/ or url.start_with? api_endpoint
+            connection.public_send(verb, url, *args)
+          else
+            Faraday.public_send(verb, url, *args) { |r| r.headers.delete("Authorization") }
+          end
+        end
+
+        case result.status
+        when 0             then raise Travis::Client::SSLError, 'SSL error: could not verify peer'
+        when 200..299      then JSON.parse(result.body) rescue result.body
+        when 301, 303      then raw(:get, result.headers['Location'])
+        when 302, 307, 308 then raw(verb, result.headers['Location'])
+        when 401           then raise Travis::Client::NotLoggedIn,      'not logged in'
+        when 403           then raise Travis::Client::NotLoggedIn,      'invalid access token'
+        when 404           then raise Travis::Client::NotFound,         result.body
+        when 422           then raise Travis::Client::ValidationFailed, result.body
+        when 400..499      then raise Travis::Client::Error,            "%s: %p" % [result.status, result.body]
+        when 500..599      then raise Travis::Client::Error,            "server error (%s: %p)" % [result.status, result.body]
+        else raise Travis::Client::Error, "unhandled status code #{result.status}"
+        end
+      end
+
+      def inspect
+        "#<#{self.class}: #{uri}>"
+      end
+
+      def clear_cache
+        reset_entities
+        clear_find_cache
+        self
+      end
+
+      def clear_cache!
+        reset_entities
+        @cache.clear
+        self
+      end
+
+      def session
+        self
+      end
+
+      def instrument(&block)
+        instruments << block
+      end
+
+      def private_channels?
+        !!config['pusher']['private']
+      end
+
+      private
+
+        def set_user_agent
+          adapter = Array === faraday_adapter ? faraday_adapter.first : faraday_adapter
+          adapter = adapter.to_s.capitalize.gsub(/_http_(.)/) { "::HTTP::#{$1.upcase}" }.gsub(/_http/, '::HTTP')
+          headers['User-Agent'] = "Travis/#{Travis::VERSION} (#{Travis::Tools::System.description(agent_info)}) Faraday/#{Faraday::VERSION} #{adapter}/#{adapter_version(adapter)}"
+        end
+
+        def adapter_version(adapter)
+          version = Object.const_get(adapter).const_get("VERSION")
+          [*version].join('.')
+        rescue Exception
+          "unknown"
+        end
+
+        def instrumented(name, *args)
+          name   = [name, *args.map(&:inspect)].join(" ") if args.any?
+          result = nil
+          chain  = instruments + [proc { |n,l| result = yield }]
+          lift   = proc { chain.shift.call(name, lift) }
+          lift.call
+          result
+        end
+
+        def create_entity(type, data)
+          return data if primitive?(data)
+          data   = { type.id_field => data } if type.id? data
+          id     = type.cast_id(data.fetch(type.id_field)) unless type.weak?
+          entity = id ? cached(type, :id, id) { type.new(self, id) } : type.new(self, nil)
+          entity.update_attributes(data)
+          entity
+        end
+
+        def primitive?(data)
+          PRIMITIVE.include? data
+        end
+
+        def error_message(e)
+          message = e.response[:body].to_str rescue e.message
+          JSON.parse(message).fetch('error').fetch('message') rescue message
+        end
+
+        def reset_entities
+          subcaches do |subcache|
+            subcache[:id].each_value { |e| e.attributes.clear } if subcache.include? :id
+          end
+        end
+
+        def clear_find_cache
+          subcaches do |subcache|
+            subcache.delete_if { |k, v| k != :id }
+          end
+        end
+
+        def subcaches
+          @cache.each_value do |subcache|
+            yield subcache if subcache.is_a? Hash
+          end
+        end
+
+        def fetch_one(entity, id = nil)
+          get("/#{entity.base_path}/#{id}")[entity.one]
+        end
+
+        def fetch_many(entity, params = {})
+          get("/#{entity.base_path}/", params)[entity.many]
+        end
+
+        def cached(*keys)
+          last  = keys.pop
+          cache = keys.inject(@cache) { |store, key| store[key] ||= {} }
+          cache[last] ||= yield
+        end
+
+        def check_ssl
+          raw(:head, '/') if ssl == SSL_OPTIONS
+        rescue Exception => error
+          self.ssl = {} if error.class == Travis::Client::SSLError
+        end
+    end
+  end
+end

data/lib/travis/client/settings.rb

@@ -0,0 +1,25 @@
+require 'travis/client/weak_entity'
+require 'json'
+
+module Travis
+  module Client
+    class Settings < WeakEntity
+      attr_accessor :repository
+      # @!parse attr_reader :builds_only_with_travis_yml, :build_pushes, :build_pull_requests, :maximum_number_of_builds, :auto_cancel_pushes, :auto_cancel_pull_requests
+      attributes :builds_only_with_travis_yml, :build_pushes, :build_pull_requests, :maximum_number_of_builds, :auto_cancel_pushes, :auto_cancel_pull_requests
+      one :settings
+      many :settings
+
+      def save
+        raise "repository unknown" unless repository
+        result = session.patch("/repos/#{repository.id}/settings", JSON.dump("settings" => attributes))
+        attributes.replace(result['settings'].attributes)
+        self
+      end
+
+      def inspect_info
+        repository ? repository.slug : repository
+      end
+    end
+  end
+end

data/lib/travis/client/singleton_setting.rb

@@ -0,0 +1,36 @@
+require 'json'
+
+module Travis
+  module Client
+    class SingletonSetting < Entity
+      def self.base_path
+        "settings/#{one}"
+      end
+
+      has :repository
+
+      def repository_id
+        id
+      end
+
+      def path
+        "#{self.class.base_path}/#{id}"
+      end
+
+      def update(values = {})
+        values = { 'value' => values } unless values.is_a? Hash
+        values.each { |key, value| attributes[key.to_s] = value.to_s }
+        session.patch_raw(path, JSON.dump(self.class.one => attributes))
+        reload
+      end
+
+      def delete
+        session.delete_raw(path)
+        reload
+        true
+      end
+
+      alias save update
+    end
+  end
+end

data/lib/travis/client/ssh_key.rb

@@ -0,0 +1,11 @@
+require 'json'
+
+module Travis
+  module Client
+    class SshKey < SingletonSetting
+      attributes :description, :fingerprint
+      one        :ssh_key
+      many       :ssh_keys
+    end
+  end
+end

data/lib/travis/client/states.rb

@@ -0,0 +1,98 @@
+require 'travis/client'
+
+module Travis
+  module Client
+    module States
+      STATES  = %w[created queued received started passed failed errored canceled ready]
+
+      def ready?
+        state == 'ready'
+      end
+
+      def pending?
+        check_state
+        %w[created started queued received ].include? state
+      end
+
+      def started?
+        check_state
+        state != 'created' and state != 'received' and state != 'queued'
+      end
+
+      def received?
+        check_state
+        state != 'created' and state != 'queued'
+      end
+
+      def queued?
+        check_state
+        state != 'created'
+      end
+
+      def finished?
+        not pending?
+      end
+
+      def passed?
+        check_state
+        state == 'passed'
+      end
+
+      def errored?
+        check_state
+        state == 'errored'
+      end
+
+      def failed?
+        check_state
+        state == 'failed'
+      end
+
+      def canceled?
+        check_state
+        state == 'canceled'
+      end
+
+      def unsuccessful?
+        errored? or failed? or canceled?
+      end
+
+      def created?
+        check_state
+        !!state
+      end
+
+      def color
+        case state
+        when 'created', 'queued', 'received', 'started' then 'yellow'
+        when 'passed', 'ready'                then 'green'
+        when 'errored', 'canceled', 'failed'  then 'red'
+        end
+      end
+
+      def yellow?
+        color == 'yellow'
+      end
+
+      def green?
+        color == 'green'
+      end
+
+      def red?
+        color == 'red'
+      end
+
+      def running?
+        state == 'started'
+      end
+
+      alias successful? passed?
+
+      private
+
+        def check_state
+          raise Error, "unknown state %p for %p" % [state, self] unless STATES.include? state
+        end
+    end
+  end
+end

data/lib/travis/client/user.rb

@@ -0,0 +1,67 @@
+require 'travis/client'
+
+module Travis
+  module Client
+    class User < Entity
+      # @!parse attr_reader :login, :name, :email, :gravatar_id, :locale, :is_syncing, :synced_at, :correct_scopes
+      attributes :login, :name, :email, :gravatar_id, :locale, :is_syncing, :synced_at, :correct_scopes, :channels
+      inspect_info :login
+
+      one  :user
+      many :users
+
+      def synced_at=(time)
+        set_attribute(:synced_at, time(time))
+      end
+
+      def sync
+        session.post_raw('/users/sync')
+        reload
+      end
+
+      def channels
+        load_attribute(:is_syncing) # dummy to trigger load, as channels might not be included
+        attributes['channels'] ||= ['common']
+      end
+
+      def permissions
+        attributes['permissions'] ||= begin
+          repos = session.get('/users/permissions')
+          repos.each_value { |r| r.compact! }
+          repos
+        end
+      end
+
+      def repositories
+        permissions['permissions']
+      end
+
+      def push_access
+        permissions['push']
+      end
+
+      def pull_access
+        permissions['pull']
+      end
+
+      def admin_access
+        permissions['admin']
+      end
+
+      def push_access?(repo)
+        push_access.include? repo
+      end
+
+      def pull_access?(repo)
+        pull_access.include? repo
+      end
+
+      def admin_access?(repo)
+        admin_access.include? repo
+      end
+
+      alias syncing? is_syncing
+      alias correct_scopes? correct_scopes
+    end
+  end
+end

data/lib/travis/client/weak_entity.rb

@@ -0,0 +1,26 @@
+require 'travis/client'
+
+module Travis
+  module Client
+    class WeakEntity < Entity
+      include NotLoadable
+
+      def self.weak?
+        true
+      end
+
+      def self.id_field
+        raise "weak entities do not have id fields"
+      end
+
+      def self.id?(object)
+        object.nil?
+      end
+
+      def self.cast_id(object)
+        return object if id? object
+        raise "weak entities do not have id fields"
+      end
+    end
+  end
+end

data/lib/travis/client.rb

@@ -0,0 +1,38 @@
+require 'backports/2.0.0' if RUBY_VERSION < '2.0.0'
+require 'travis/client/error'
+require 'travis/client/states'
+require 'travis/client/restartable'
+require 'travis/client/not_loadable'
+require 'travis/client/has_uuid'
+require 'travis/client/methods'
+require 'travis/client/session'
+require 'travis/client/entity'
+require 'travis/client/user'
+require 'travis/client/repository'
+require 'travis/client/env_var'
+require 'travis/client/build'
+require 'travis/client/artifact'
+require 'travis/client/cache'
+require 'travis/client/commit'
+require 'travis/client/job'
+require 'travis/client/namespace'
+require 'travis/client/account'
+require 'travis/client/broadcast'
+require 'travis/client/settings'
+require 'travis/client/singleton_setting'
+require 'travis/client/ssh_key'
+require 'travis/client/request'
+require 'travis/client/listener'
+require 'travis/client/lint_result'
+
+module Travis
+  module Client
+    ORG_URI = 'https://api.travis-ci.org/'
+    COM_URI = 'https://api.travis-ci.com/'
+
+    def self.new(options = {})
+      options[:uri] ||= ORG_URI if options.is_a? Hash and not options['uri']
+      Session.new(options)
+    end
+  end
+end

data/lib/travis/pro/auto_login.rb

@@ -0,0 +1,3 @@
+require 'travis/pro'
+require 'travis/client/auto_login'
+Travis::Client::AutoLogin.new(Travis::Pro).authenticate