travis-async-listener 1.8.3

data/lib/travis/client/not_loadable.rb

@@ -0,0 +1,13 @@
+module Travis
+  module Client
+    module NotLoadable
+      def missing?(attribute)
+        false
+      end
+
+      def complete?
+        true
+      end
+    end
+  end
+end

data/lib/travis/client/repository.rb

@@ -0,0 +1,224 @@
+require 'travis/client'
+require 'travis/tools/ssl_key'
+
+module Travis
+  module Client
+    class Repository < Entity
+      class Key
+        attr_reader :to_s, :fingerprint
+
+        def initialize(data, fingerprint)
+          @to_s = data
+          @fingerprint = fingerprint
+        end
+
+        def encrypt(value)
+          encrypted = to_rsa.public_encrypt(value)
+          Base64.encode64(encrypted).gsub(/\s+/, "")
+        end
+
+        def to_rsa
+          Tools::SSLKey.public_rsa_key(to_s)
+        end
+
+        def to_ssh
+          Tools::SSLKey.rsa_ssh(to_rsa)
+        end
+
+        def ==(other)
+          other.to_s == self
+        end
+      end
+
+      include States
+      preloadable
+
+      # @!parse attr_reader :slug, :description
+      attributes :slug, :active, :private, :admin, :description, :last_build_id, :last_build_number, :last_build_state, :last_build_duration, :last_build_started_at, :last_build_finished_at, :github_language
+      inspect_info :slug
+
+      time :last_build_finished_at, :last_build_started_at
+
+      one  :repo
+      many :repos
+      aka  :repository, :permissions, :admin, :pull, :push, :hooks
+
+      has_singleton :ssh_key
+
+      def initialize(*)
+        super
+        attributes['active'] = attributes['private'] = attributes['admin'] = nil
+      end
+
+      def public_key
+        attributes["public_key"] ||= begin
+          payload = session.get_raw("/repos/#{id}/key")
+          Key.new(payload.fetch('key'), payload['fingerprint'])
+        end
+      end
+
+      def name
+        slug[/[^\/]+$/]
+      end
+
+      def public_key=(key)
+        # ignored
+      end
+
+      alias key  public_key
+      alias key= public_key=
+
+      def encrypt(value)
+        key.encrypt(value)
+      end
+
+      # @!parse attr_reader :last_build
+      def last_build
+        return unless last_build_id
+        attributes['last_build'] ||= begin
+          last_build               = session.find_one(Build, last_build_id)
+          last_build.number        = last_build_number
+          last_build.state         = last_build_state
+          last_build.duration      = last_build_duration
+          last_build.started_at    = last_build_started_at
+          last_build.finished_at   = last_build_finished_at
+          last_build.repository_id = id
+          last_build
+        end
+      end
+
+      def builds(params = nil)
+        return each_build unless params
+        session.find_many(Build, params.merge(:repository_id => id))
+      end
+
+      def build(number)
+        builds(:number => number.to_s).first
+      end
+
+      def recent_builds
+        builds({})
+      end
+
+      def last_on_branch(name = nil)
+        return branch(name) if name
+        attributes['last_on_branch'] ||= session.get('branches', :repository_id => id)['branches']
+      end
+
+      def branches
+        last_on_branch.map { |b| { b.commit.branch => b } }.inject(:merge)
+      end
+
+      def branch(name)
+        attributes['branches']       ||= {}
+        attributes['branches'][name] ||= begin
+          build = attributes['last_on_branch'].detect { |b| b.commit.branch == name.to_s } if attributes['last_on_branch']
+          build || session.get("/repos/#{id}/branches/#{name}")['branch']
+        end
+      end
+
+      def each_build(params = nil, &block)
+        return enum_for(__method__, params) unless block_given?
+        params ||= {}
+        chunk = builds(params)
+        until chunk.empty?
+          chunk.each(&block)
+          number = chunk.last.number
+          chunk  = number == '1' ? [] : builds(params.merge(:after_number => number))
+        end
+        self
+      end
+
+      def job(number)
+        build_number = number.to_s[/^\d+/] or return nil
+        build        = build(build_number) or return nil
+        job          = build.jobs.detect { |j| j.number == number } if number != build_number
+        job        ||= build.jobs.first if build and build.jobs.size == 1
+        job
+      end
+
+      def set_hook(flag)
+        result = session.put_raw('/hooks/', :hook => { :id => id, :active => flag })
+        result['result']
+      end
+
+      def disable
+        set_hook(false)
+      end
+
+      def enable
+        set_hook(true)
+      end
+
+      def pusher_channels
+        attributes['pusher_channels'] ||= if session.private_channels?
+          ["user-#{session.user.id}", "repo-#{id}"]
+        else
+          ["common"]
+        end
+      end
+
+      def member?
+        session.user.repositories.include? self
+      end
+
+      def owner_name
+        slug[/^[^\/]+/]
+      end
+
+      def owner
+        session.account(owner_name)
+      end
+
+      def requests
+        attributes['requests'] ||= session.find_many(Request, :repository_id => id)
+      end
+
+      def settings
+        attributes['settings'] ||= begin
+          settings = session.get("/repos/#{id}/settings")['settings']
+          settings.repository = self
+          settings
+        end
+      rescue Travis::Client::NotFound
+        raise Travis::Client::Error, "not allowed to access settings"
+      end
+
+      def caches(params = {})
+        session.get("/repos/#{id}/caches", params)['caches']
+      end
+
+      def delete_caches(params = {})
+        session.delete("/repos/#{id}/caches", params)['caches']
+      end
+
+      def active?
+        # TODO remove once active is properly synced and exposed by api
+        return active unless active.nil?
+        last_build_id?
+      end
+
+      def admin?(user = session.user)
+        user.admin_access? self
+      end
+
+      def push?(user = session.user)
+        user.push_access? self
+      end
+
+      def pull?(user = session.user)
+        user.pull_access? self
+      end
+
+      def env_vars
+        attributes['env_vars'] ||= EnvVar::List.new(self)
+      end
+
+      private
+
+        def state
+          last_build_state
+        end
+    end
+  end
+end

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 SSLError => error
+          self.ssl = {}
+        end
+    end
+  end
+end