travis 1.0.0

data/lib/travis/client/repository.rb

@@ -0,0 +1,66 @@
+require 'travis/client'
+require 'openssl'
+require 'base64'
+
+module Travis
+  module Client
+    class Repository < Entity
+      class Key
+        attr_reader :to_s
+
+        def initialize(data)
+          @to_s = data
+        end
+
+        def encrypt(value)
+          encrypted = to_rsa.public_encrypt(value)
+          Base64.encode64(encrypted).strip
+        end
+
+        def to_rsa
+          @to_rsa ||= OpenSSL::PKey::RSA.new(to_s)
+        rescue OpenSSL::PKey::RSAError
+          public_key = to_s.gsub('RSA PUBLIC KEY', 'PUBLIC KEY')
+          @to_rsa = OpenSSL::PKey::RSA.new(public_key)
+        end
+
+        def ==(other)
+          other.to_s == self
+        end
+      end
+
+      attributes :slug, :description, :last_build_id, :last_build_number, :last_build_state, :last_build_duration, :last_build_language, :last_build_started_at, :last_build_finished_at
+      inspect_info :slug
+
+      one  :repo
+      many :repos
+
+      def public_key
+        attributes["public_key"] ||= begin
+          payload = session.get_raw("/repos/#{id}/key")
+          Key.new(payload.fetch('key'))
+        end
+      end
+
+      def public_key=(key)
+        key = Key.new(key) unless key.is_a? Key
+        set_attribute(:public_key, key)
+      end
+
+      alias key  public_key
+      alias key= public_key=
+
+      def encrypt(value)
+        key.encrypt(value)
+      end
+
+      def last_build_started_at=(time)
+        set_attribute(:last_build_started_at, time(time))
+      end
+
+      def last_build_finished_at=(time)
+        set_attribute(:last_build_finished_at, time(time))
+      end
+    end
+  end
+end

data/lib/travis/client/session.rb

@@ -0,0 +1,191 @@
+require 'travis/client'
+
+require 'faraday'
+require 'faraday_middleware'
+require 'json'
+
+module Travis
+  module Client
+    class Session
+      SSL_OPTIONS = { :ca_file => File.expand_path("../../cacert.pem", __FILE__) }
+      include Methods
+      attr_reader :connection, :headers, :access_token
+
+      def initialize(options = Travis::Client::ORG_URI)
+        @headers = {}
+        @cache   = {}
+
+        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, */*; q=0.01'
+      end
+
+      def uri
+        connection.url_prefix.to_s if connection
+      end
+
+      def uri=(uri)
+        clear_cache!
+        self.connection = Faraday.new(:url => uri, :ssl => SSL_OPTIONS) do |faraday|
+          faraday.request   :json
+          faraday.response  :json
+          faraday.response  :follow_redirects
+          faraday.response  :raise_error
+          faraday.adapter(*faraday_adapter)
+        end
+      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
+        @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::Error, "cannot fetch #{entity}" unless entity.respond_to?(:many) and entity.many
+        return create_entity(entity, "id" => id) if id.is_a? Integer
+        cached(entity, :by, id) { fetch_one(entity, id) }
+      end
+
+      def find_many(entity, args = {})
+        raise Travis::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::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 reload(entity)
+        result = fetch_one(entity.class, entity.id)
+        entity.update_attributes(result.attributes) if result.attributes != entity.attributes
+        result
+      end
+
+      def get(*args)
+        result = {}
+        get_raw(*args).each_pair do |key, value|
+          type = Entity.subclass_for(key)
+          if value.respond_to? :to_ary
+            result[key] = value.to_ary.map { |e| create_entity(type, e) }
+          else
+            result[key] = create_entity(type, value)
+          end
+        end
+        result
+      end
+
+      def get_raw(*args)
+        connection.get(*args).body
+      rescue Faraday::Error::ClientError => e
+        handle_error(e)
+      end
+
+      def post_raw(*args)
+        connection.post(*args).body
+      rescue Faraday::Error::ClientError => e
+        handle_error(e)
+      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
+
+      private
+
+        def create_entity(type, data)
+          id     = Integer(data.fetch('id'))
+          entity = cached(type, :id, id) { type.new(self, id) }
+          entity.update_attributes(data)
+          entity
+        end
+
+        def handle_error(e)
+          message = e.response[:body].to_str rescue e.message
+          klass   = Travis::Client::NotFound if e.is_a? Faraday::Error::ResourceNotFound
+          klass ||= Travis::Client::Error
+          raise klass, message, e.backtrace
+        end
+
+        def faraday_adapter
+          Faraday.default_adapter
+        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.many}/#{id}")[entity.one]
+        end
+
+        def fetch_many(entity, params = {})
+          get("/#{entity.many}/", params)[entity.many]
+        end
+
+        def cached(*keys)
+          last  = keys.pop
+          cache = keys.inject(@cache) { |store, key| store[key] ||= {} }
+          cache[last] ||= yield
+        end
+    end
+  end
+end

data/lib/travis/client/user.rb

@@ -0,0 +1,20 @@
+require 'travis/client'
+
+module Travis
+  module Client
+    class User < Entity
+      attributes :login, :name, :email, :gravatar_id, :locale, :is_syncing, :synced_at, :correct_scopes
+      inspect_info :login
+
+      one  :user
+      many :users
+
+      def synced_at=(time)
+        set_attribute(:synced_at, time(time))
+      end
+
+      alias syncing? is_syncing
+      alias correct_scopes? correct_scopes
+    end
+  end
+end

data/lib/travis/pro.rb

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

data/lib/travis/tools/token_finder.rb

@@ -0,0 +1,51 @@
+require 'netrc'
+require 'yaml'
+
+module Travis
+  module Tools
+    # This is used when running `travis login --auto`
+    class TokenFinder
+      attr_accessor :netrc, :hub, :explode, :github
+
+      def self.find(options = {})
+        new(options).find
+      end
+
+      def initialize(options = {})
+        self.netrc   = options[:netrc]  || Netrc.default_path
+        self.hub     = options[:hub]    || ENV['HUB_CONFIG'] || '~/.config/hub'
+        self.github  = options[:github] || 'github.com'
+        self.explode = options[:explode]
+      end
+
+      def hub=(file)
+        @hub = File.expand_path(file)
+      end
+
+      def netrc=(file)
+        @netrc = File.expand_path(file)
+      end
+
+      def find
+        find_netrc || find_hub
+      end
+
+      def find_netrc
+        return unless File.readable? netrc
+        data = Netrc.read(netrc)[github]
+        data.detect { |e| e.size == 40 } if data
+      rescue => e
+        raise e if explode
+      end
+
+      def find_hub
+        return unless File.readable? hub
+        data   = YAML.load_file(File.expand_path(hub))
+        data &&= Array(data[github])
+        data.first['oauth_token'] if data.size == 1
+      rescue => e
+        raise e if explode
+      end
+    end
+  end
+end

data/lib/travis/version.rb

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

data/spec/cli/encrypt_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Travis::CLI::Endpoint do
+  example "travis encrypt foo" do
+    run_cli('encrypt', 'foo').should be_success
+    stdout.should match(/^".{60,}"\n$/)
+  end
+
+  example "travis encrypt foo -i" do
+    run_cli('encrypt', 'foo', '-i').should be_success
+    stdout.should start_with("Please add the following to your \e[33m.travis.yml\e[0m file:\n\n  secure: ")
+  end
+
+  example "cat foo | travis encrypt" do
+    run_cli('encrypt') { |i| i.puts('foo') }
+    stdout.should match(/^".{60,}"\n$/)
+  end
+end

data/spec/cli/endpoint_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Travis::CLI::Endpoint do
+  example "travis endpoint" do
+    run_cli('endpoint').should be_success
+    stdout.should be == "https://api.travis-ci.org/\n"
+  end
+
+  example "travis endpoint --pro" do
+    run_cli('endpoint', '--pro').should be_success
+    stdout.should be == "https://api.travis-ci.com/\n"
+  end
+
+  example "travis endpoint -e http://localhost:3000/" do
+    run_cli('endpoint', '-e', 'http://localhost:3000/').should be_success
+    stdout.should be == "http://localhost:3000/\n"
+  end
+
+  example "travis endpoint -i" do
+    run_cli('endpoint', '-i').should be_success
+    stdout.should be == "API endpoint: \e[1m\e[4mhttps://api.travis-ci.org/\e[0m\n"
+  end
+end

data/spec/cli/help_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Travis::CLI::Help do
+  example "travis help" do
+    run_cli('help').should be_success
+    stdout.should start_with("Usage: #$0 COMMAND")
+  end
+
+  example "travis --help" do
+    run_cli('--help').should be_success
+    stdout.should start_with("Usage: #$0 COMMAND")
+  end
+
+  example "travis -h" do
+    run_cli('-h').should be_success
+    stdout.should start_with("Usage: #$0 COMMAND")
+  end
+
+  example "travis -?" do
+    run_cli('-?').should be_success
+    stdout.should start_with("Usage: #$0 COMMAND")
+  end
+
+  example "travis help endpoint" do
+    run_cli('help', 'endpoint').should be_success
+    stdout.should start_with("Usage: #$0 endpoint [options]")
+  end
+
+  example "travis endpoint --help" do
+    run_cli('endpoint', '--help').should be_success
+    stdout.should start_with("Usage: #$0 endpoint [options]")
+  end
+end

data/spec/cli/login_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Travis::CLI::Login do
+  example "travis login" do
+    run_cli('login') { |i| i.puts('rkh', 'password') }.should be_success
+    run_cli('whoami').out.should be == "rkh\n"
+  end
+
+  example "travis login (with bad credentials)" do
+    run_cli('login') { |i| i.puts('rkh', 'wrong password') }.should_not be_success
+    run_cli('whoami').should_not be_success
+  end
+end

data/spec/cli/version_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Travis::CLI::Version do
+  example do
+    run_cli('-v').should be_success
+    stdout.should be == "#{Travis::VERSION}\n"
+  end
+
+  example do
+    run_cli('--version').should be_success
+    stdout.should be == "#{Travis::VERSION}\n"
+  end
+
+  example do
+    run_cli('version').should be_success
+    stdout.should be == "#{Travis::VERSION}\n"
+  end
+end