travis 1.0.0

data/lib/travis/cli/login.rb

@@ -0,0 +1,57 @@
+require 'travis/cli'
+require 'travis/tools/token_finder'
+require 'json'
+
+module Travis
+  module CLI
+    class Login < ApiCommand
+      skip :authenticate
+      attr_accessor :github_login, :github_password, :github_token, :callback
+
+      on('--github-token TOKEN', 'identify by GitHub token')
+
+      on('--auto', 'try to figure out who you are automatically (might send another apps token to Travis, token will not be stored)') do |c|
+        c.github_token ||= Travis::Tools::TokenFinder.find(:explode => c.explode?)
+      end
+
+      def run
+        generate_github_token unless github_token
+        endpoint_config['access_token'] = github_auth(github_token)
+        success("Successfully logged in!")
+      ensure
+        callback.call if callback
+      end
+
+      private
+
+        def generate_github_token
+          ask_info
+
+          gh    = GH.with(:username => github_login, :password => github_password)
+          reply = gh.post('/authorizations', :scopes => github_scopes, :note => "temporary token to identify on #{api_endpoint}")
+
+          self.github_token = reply['token']
+          self.callback     = proc { gh.delete reply['_links']['self']['href'] }
+        rescue GH::Error => e
+          raise e if explode?
+          error JSON.parse(e.info[:response_body])["message"]
+        end
+
+        def github_scopes
+          ['user:email', org? ? 'public_repo' : 'repo']
+        end
+
+        def ask_info
+          say "We need your #{color("GitHub login", :important)} to identify you."
+          say "This information will #{color("not be sent to Travis CI", :important)}, only to GitHub."
+          say "The password will not be displayed."
+          empty_line
+          say "Try running with #{color("--github-token", :info)} or #{color("--auto", :info)} if you don't want to enter your password anyways."
+          empty_line
+          self.github_login    = ask("Username: ")
+          self.github_password = ask("Password: ") { |q| q.echo = "*" }
+          empty_line
+        end
+    end
+  end
+end

data/lib/travis/cli/parser.rb

@@ -0,0 +1,43 @@
+require 'travis/cli'
+require 'optparse'
+
+module Travis
+  module CLI
+    module Parser
+      def on_initialize(&block)
+        @on_initialize ||= []
+        @on_initialize << block if block
+        if superclass.respond_to? :on_initialize
+          superclass.on_initialize + @on_initialize
+        else
+          @on_initialize
+        end
+      end
+
+      def on(*args, &block)
+        block ||= begin
+          full_arg = args.detect { |a| a.start_with? '--' }
+          name = full_arg.gsub(/^--(\[no-\])?(\S+).*$/, '\2').gsub('-', '_')
+          attr_reader(name) unless method_defined? name
+          attr_writer(name) unless method_defined? "#{name}="
+          alias_method("#{name}?", name) if full_arg.start_with? '--[no-]' and not method_defined? "#{name}?"
+          proc { |instance, value| instance.public_send("#{name}=", value) }
+        end
+
+        on_initialize do |instance|
+          instance.parser.on(*args) do |value|
+            block.call(instance, value)
+          end
+        end
+      end
+
+      def new(*)
+        attr_accessor :parser unless method_defined? :parser
+        result        = super
+        result.parser = OptionParser.new
+        on_initialize.each { |b| b[result] }
+        result
+      end
+    end
+  end
+end

data/lib/travis/cli/raw.rb

@@ -0,0 +1,16 @@
+require 'travis/cli'
+require 'pp'
+
+module Travis
+  module CLI
+    class Raw < ApiCommand
+      skip :authenticate
+      on('--[no-]json', 'display as json')
+
+      def run(resource)
+        reply = session.get_raw(resource)
+        json? ? say(reply.to_json) : pp(reply)
+      end
+    end
+  end
+end

data/lib/travis/cli/repo_command.rb

@@ -0,0 +1,54 @@
+require 'travis/cli'
+
+module Travis
+  module CLI
+    class RepoCommand < ApiCommand
+      GIT_REGEX = %r{Fetch URL: (?:https://|git://|git@)github\.com[:/](.*/.+?)(\.git)?$}
+      on('-r', '--repo SLUG') { |c| c.slug = slug }
+
+      attr_accessor :slug
+      abstract
+
+      def setup
+        error "Can't figure out GitHub repo name. Are you in the right directory?" unless self.slug ||= find_slug
+        self.api_endpoint = detect_api_endpoint
+        super
+      end
+
+      def repository
+        repo(slug)
+      rescue Travis::Client::NotFound
+        error "repository not known to travis: #{color(slug, :important)}"
+      end
+
+      private
+
+        def detected_endpoint?
+          !explicit_api_endpoint?
+        end
+
+        def find_slug
+          git_info = `git remote show origin 2>&1`
+          $1 if git_info =~ GIT_REGEX
+        end
+
+        def repo_config
+          config['repos'] ||= {}
+          config['repos'][slug] ||= {}
+        end
+
+        def detect_api_endpoint
+          if explicit_api_endpoint?
+            repo_config['endpoint'] = api_endpoint
+          else
+            repo_config['endpoint'] ||= begin
+              GH.head("/repos/#{slug}")
+              Travis::Client::ORG_URI
+            rescue GH::Error
+              Travis::Client::PRO_URI
+            end
+          end
+        end
+    end
+  end
+end

data/lib/travis/cli/version.rb

@@ -0,0 +1,12 @@
+require 'travis/cli'
+require 'travis/version'
+
+module Travis
+  module CLI
+    class Version < Command
+      def run
+        say Travis::VERSION
+      end
+    end
+  end
+end

data/lib/travis/cli/whoami.rb

@@ -0,0 +1,12 @@
+require 'travis/cli'
+
+module Travis
+  module CLI
+    class Whoami < ApiCommand
+      def run
+        authenticate
+        say user.login, "You are %s (#{user.name})"
+      end
+    end
+  end
+end

data/lib/travis/client.rb

@@ -0,0 +1,20 @@
+require 'backports/1.9.3' if RUBY_VERSION < '1.9.3'
+require 'travis/client/error'
+require 'travis/client/methods'
+require 'travis/client/session'
+require 'travis/client/entity'
+require 'travis/client/user'
+require 'travis/client/repository'
+require 'travis/client/namespace'
+
+module Travis
+  module Client
+    ORG_URI = 'https://api.travis-ci.org/'
+    PRO_URI = 'https://api.travis-ci.com/'
+
+    def self.new(options = {})
+      options['uri'] ||= ORG_URI if options.is_a? Hash
+      Session.new(options)
+    end
+  end
+end

data/lib/travis/client/entity.rb

@@ -0,0 +1,139 @@
+require 'travis/client'
+require 'time'
+
+module Travis
+  module Client
+    class Entity
+      attr_reader :attributes, :id, :session
+      attr_accessor :curry
+
+      MAP = {}
+
+      def self.subclasses
+        MAP.values.uniq
+      end
+
+      def self.subclass_for(key)
+        MAP.fetch(key)
+      end
+
+      def self.one(key = nil)
+        MAP[key.to_s] = self if key
+        @one ||= key.to_s
+      end
+
+      def self.many(key = nil)
+        MAP[key.to_s] = self if key
+        @many ||= key.to_s
+      end
+
+      def self.attributes(*list)
+        @attributes ||= []
+        list.each do |name|
+          name = name.to_s
+          @attributes << name
+          define_method(name) { load_attribute(name) }
+          define_method("#{name}=") { |value| set_attribute(name, value) }
+          define_method("#{name}?") { !!send(name) }
+        end
+        @attributes
+      end
+
+      def self.inspect_info(name)
+        alias_method(:inspect_info, name)
+        private(:inspect_info)
+      end
+
+      def initialize(session, id)
+        @attributes = {}
+        @session    = session
+        @id         = Integer(id)
+      end
+
+      def update_attributes(data)
+        data.each_pair do |key, value|
+          self[key] = value
+        end
+      end
+
+      def attribute_names
+        self.class.attributes
+      end
+
+      def [](key)
+        send(key) if include? key
+      end
+
+      def []=(key, value)
+        send("#{key}=", value) if include? key
+      end
+
+      def include?(key)
+        attributes.include? key or attribute_names.include? key.to_s
+      end
+
+      def reload
+        session.reload(self)
+      end
+
+      def load
+        reload unless complete?
+      end
+
+      def missing?(key)
+        return false unless include? key
+        !attributes.include?(key.to_s)
+      end
+
+      def complete?
+        attribute_names.all? { |key| attributes.include? key }
+      end
+
+      def inspect
+        klass = self.class
+        klass = curry if curry and curry.name and curry.to_s.size < klass.to_s.size
+        "#<#{klass}: #{inspect_info}>"
+      end
+
+      private
+
+        def inspect_info
+          id
+        end
+
+        def set_attribute(name, value)
+          attributes[name.to_s] = value
+        end
+
+        def load_attribute(name)
+          reload if missing? name
+          attributes[name.to_s]
+        end
+
+        # shamelessly stolen from sinatra
+        def time(value)
+          if value.respond_to? :to_time
+            value.to_time
+          elsif value.is_a? Time
+            value
+          elsif value.respond_to? :new_offset
+            d = value.new_offset 0
+            t = Time.utc d.year, d.mon, d.mday, d.hour, d.min, d.sec + d.sec_fraction
+            t.getlocal
+          elsif value.respond_to? :mday
+            Time.local(value.year, value.mon, value.mday)
+          elsif value.is_a? Numeric
+            Time.at value
+          elsif value.nil? or value.empty?
+            nil
+          else
+            Time.parse value.to_s
+          end
+        rescue ArgumentError => boom
+          raise boom
+        rescue Exception
+          raise ArgumentError, "unable to convert #{value.inspect} to a Time object"
+        end
+    end
+  end
+end

data/lib/travis/client/error.rb

@@ -0,0 +1,11 @@
+require 'travis/client'
+
+module Travis
+  module Client
+    class Error < StandardError
+    end
+
+    class NotFound < Error
+    end
+  end
+end

data/lib/travis/client/methods.rb

@@ -0,0 +1,45 @@
+require 'travis/client'
+
+module Travis
+  module Client
+    module Methods
+      def access_token
+        session.access_token
+      end
+
+      def access_token=(token)
+        session.access_token = token
+      end
+
+      def api_endpoint
+        session.uri
+      end
+
+      def github_auth(github_token)
+        reply = session.post_raw("/auth/github?github_token=#{github_token}")
+        session.access_token = reply["access_token"]
+      end
+
+      def explicit_api_endpoint?
+        @explicit_api_endpoint ||= false
+      end
+
+      def api_endpoint=(uri)
+        @explicit_api_endpoint = true
+        session.uri = uri
+      end
+
+      def repos(params = {})
+        session.find_many(Repository, params)
+      end
+
+      def repo(id_or_slug)
+        session.find_one(Repository, id_or_slug)
+      end
+
+      def user
+        session.find_one(User)
+      end
+    end
+  end
+end

data/lib/travis/client/namespace.rb

@@ -0,0 +1,78 @@
+require 'travis/client'
+
+module Travis
+  module Client
+    class Namespace < Module
+      class Curry < Module
+        attr_accessor :namespace, :type
+
+        def initialize(namespace, type)
+          @namespace, @type = namespace, type
+        end
+
+        def find_one(id = nil)
+          result = session.find_one(type, id)
+          result.curry = self
+          result
+        end
+
+        def current
+          result = session.find_one_or_many(type)
+          Array(result).each { |e| e.curry = self }
+          result
+        end
+
+        def find_many(params = {})
+          session.find_many(type, params).each do |entity|
+            entity.curry = self
+          end
+        end
+
+        alias find     find_one
+        alias find_all find_many
+
+        private
+
+          def session
+            namespace.session
+          end
+      end
+
+
+      include Methods
+      attr_accessor :session
+
+      def initialize(session = nil)
+        session  = Travis::Client.new(session || {}) unless session.is_a? Session
+        @session = session
+
+        Entity.subclasses.each do |subclass|
+          name = subclass.name[/[^:]+$/]
+          const_set(name, Curry.new(self, subclass))
+        end
+      end
+
+      def included(klass)
+        fix_names(klass)
+        delegate_session(klass)
+      end
+
+      private
+
+        def fix_names(klass)
+          constants.each do |name|
+            const = klass.const_get(name)
+            klass.const_set(name, const) if const == const_get(name)
+          end
+        end
+
+        def delegate_session(klass)
+          return if klass == Object or klass == Kernel
+          klass.extend(Methods)
+          namespace = self
+          klass.define_singleton_method(:session)  { namespace.session }
+          klass.define_singleton_method(:session=) { |value| namespace.session = value }
+        end
+    end
+  end
+end