travis 1.0.0

data/lib/travis/cli.rb

@@ -0,0 +1,83 @@
+begin
+  require 'travis/client'
+rescue LoadError => e
+  if e.message == 'no such file to load -- json'
+    $stderr.puts "You should either run `gem install json` or upgrade your Ruby version!"
+    exit 1
+  else
+    raise e
+  end
+end
+
+require 'gh'
+GH.set(:ssl => Travis::Client::Session::SSL_OPTIONS)
+
+module Travis
+  module CLI
+    autoload :ApiCommand,   'travis/cli/api_command'
+    autoload :Command,      'travis/cli/command'
+    autoload :Encrypt,      'travis/cli/encrypt'
+    autoload :Endpoint,     'travis/cli/endpoint'
+    autoload :Help,         'travis/cli/help'
+    autoload :Login,        'travis/cli/login'
+    autoload :Parser,       'travis/cli/parser'
+    autoload :Raw,          'travis/cli/raw'
+    autoload :RepoCommand,  'travis/cli/repo_command'
+    autoload :Version,      'travis/cli/version'
+    autoload :Whoami,       'travis/cli/whoami'
+
+    extend self
+
+    def windows?
+      RUBY_PLATFORM =~ /mswin|mingw/
+    end
+
+    def run(*args)
+      args, opts = preparse(args)
+      name       = args.shift unless args.empty?
+      command    = command(name).new(opts)
+      command.parse(args)
+      command.execute
+    end
+
+    def command(name)
+      const_name = command_name(name)
+      constant   = CLI.const_get(const_name) if const_name =~ /^[A-Z][a-z]+$/ and const_defined? const_name
+      if command? constant
+        constant
+      else
+        $stderr.puts "unknown command #{name}"
+        exit 1
+      end
+    end
+
+    def commands
+      CLI.constants.map { |n| CLI.const_get(n) }.select { |c| command? c }
+    end
+
+    private
+
+      def command?(constant)
+        constant and constant < Command and not constant.abstract?
+      end
+
+      def command_name(name)
+        case name
+        when nil, '-h', '-?' then 'Help'
+        when '-v'            then 'Version'
+        when /^--/           then command_name(name[2..-1])
+        else name.to_s.capitalize
+        end
+      end
+
+      # can't use flatten as it will flatten hashes
+      def preparse(unparsed, args = [], opts = {})
+        case unparsed
+        when Hash  then opts.merge! unparsed
+        when Array then unparsed.each { |e| preparse(e, args, opts) }
+        else args << unparsed.to_s
+        end
+        [args, opts]
+      end
+  end
+end

data/lib/travis/cli/api_command.rb

@@ -0,0 +1,65 @@
+require 'travis/cli'
+
+module Travis
+  module CLI
+    class ApiCommand < Command
+      include Travis::Client::Methods
+      attr_reader :session
+      abstract
+
+      on('-e', '--api-endpoint URL', 'Travis API server to talk to')
+      on('--pro', "short-cut for --api-endpoint '#{Travis::Client::PRO_URI}'") { |c,_| c.api_endpoint = Travis::Client::PRO_URI }
+      on('--org', "short-cut for --api-endpoint '#{Travis::Client::ORG_URI}'") { |c,_| c.api_endpoint = Travis::Client::ORG_URI }
+      on('-t', '--token [ACCESS_TOKEN]', 'access token to use') { |c, t| c.access_token = t }
+
+      def initialize(*)
+        @session = Travis::Client.new
+        super
+      end
+
+      def endpoint_config
+        config['endpoints'] ||= {}
+        config['endpoints'][api_endpoint] ||= {}
+      end
+
+      def setup
+        self.access_token               ||= fetch_token
+        endpoint_config['access_token'] ||= access_token
+        authenticate if pro?
+      end
+
+      def pro?
+        api_endpoint == Travis::Client::PRO_URI
+      end
+
+      def org?
+        api_endpoint == Travis::Client::ORG_URI
+      end
+
+      def detected_endpoint?
+        api_endpoint == detected_endpoint
+      end
+
+      def authenticate
+        error "not logged in, please run #{command("login#{endpoint_option}")}" if access_token.nil?
+      end
+
+      private
+
+        def detected_endpoint
+          Travis::Client::ORG_URI
+        end
+
+        def endpoint_option
+          return ""       if org? and detected_endpoint?
+          return " --org" if org?
+          return " --pro" if pro?
+          " -e %p" % api_endpoint
+        end
+
+        def fetch_token
+          return endpoint_config['access_token'] if endpoint_config['access_token']
+        end
+    end
+  end
+end

data/lib/travis/cli/command.rb

@@ -0,0 +1,212 @@
+require 'travis/cli'
+require 'highline'
+require 'forwardable'
+require 'delegate'
+require 'yaml'
+
+module Travis
+  module CLI
+    class Command
+      extend Parser
+      extend Forwardable
+      def_delegators :terminal, :agree, :ask, :choose
+
+      HighLine.use_color = !CLI.windows?
+      HighLine.color_scheme = HighLine::ColorScheme.new do |cs|
+        cs[:command]   = [ :bold             ]
+        cs[:error]     = [ :red              ]
+        cs[:important] = [ :bold, :underline ]
+        cs[:success]   = [ :green            ]
+        cs[:info]      = [ :yellow           ]
+      end
+
+      on('-h', '--help', 'Display help') do |c, _|
+        c.say c.help
+        exit
+      end
+
+      on('-i', '--[no-]interactive', "be interactive and colorful") do |c, v|
+        c.force_interactive = v
+      end
+
+      on('-E', '--[no-]explode', "don't rescue exceptions")
+
+      def self.command_name
+        name[/[^:]*$/].downcase
+      end
+
+      @@abstract ||= [Command] # ignore the man behind the courtains!
+      def self.abstract?
+        @@abstract.include? self
+      end
+
+      def self.abstract
+        @@abstract << self
+      end
+
+      def self.skip(name)
+        define_method(name) {}
+      end
+
+      attr_accessor :arguments, :config, :terminal, :force_interactive
+
+      def initialize(options = {})
+        @output   = SimpleDelegator.new($stdout)
+        @input    = SimpleDelegator.new($stdin)
+        @terminal = HighLine.new(@input, @output)
+        options.each do |key, value|
+          public_send("#{key}=", value) if respond_to? "#{key}="
+        end
+        @arguments ||= []
+      end
+
+      def input
+        @input.__getobj__
+      end
+
+      def input=(io)
+        @input.__setobj__(io)
+      end
+
+      def output
+        @output.__getobj__
+      end
+
+      def output=(io)
+        @output.__setobj__(io)
+      end
+
+      def write_to(io)
+        io_was, self.output = output, io
+        yield
+      ensure
+        self.output = io_was if io_was
+      end
+
+      def parse(args)
+        rest = parser.parse(args)
+        arguments.concat(rest)
+      rescue OptionParser::ParseError => e
+        error e.message
+      end
+
+      def setup
+      end
+
+      def execute
+        check_arity(method(:run), *arguments)
+        load_config
+        setup
+        run(*arguments)
+        store_config
+      rescue StandardError => e
+        raise(e) if explode?
+        error e.message
+      end
+
+      def command_name
+        self.class.command_name
+      end
+
+      def usage
+        usage  = "#$0 #{command_name} [options]"
+        method = method(:run)
+        if method.respond_to? :parameters
+          method.parameters.each do |type, name|
+            name = "[#{name}]"      if type == :opt
+            name = "[#{name}..]" if type == :rest
+            usage << " #{name}"
+          end
+        else
+          usage << " ..."
+        end
+        "Usage: " << color(usage, :command)
+      end
+
+      def help
+        parser.banner = usage
+        parser.to_s
+      end
+
+      def say(data, format = nil)
+        data = format % color(data, :important) if format and interactive?
+        terminal.say data.gsub(/<\[\[/, '<%=').gsub(/\]\]>/, '%>')
+      end
+
+      private
+
+        def template(file)
+          File.read(file).split('__END__', 2)[1].strip
+        end
+
+        def color(line, *args)
+          return line unless interactive?
+          terminal.color(line, *args)
+        end
+
+        def interactive?(io = output)
+          return io.tty? if force_interactive.nil?
+          force_interactive
+        end
+
+        def empty_line
+          say "\n"
+        end
+
+        def error(message)
+          write_to($stderr) do
+            say color(message, :error)
+            yield if block_given?
+            exit 1
+          end
+        end
+
+        def command(name)
+          color("#$0 #{name}", :command)
+        end
+
+        def success(line)
+          say color(line, :success) if interactive?
+        end
+
+        def asset_path(name)
+          path = ENV.fetch('TRAVIS_CONFIG_PATH') { File.expand_path('.travis', Dir.home) }
+          Dir.mkdir(path, 0700) unless File.directory? path
+          File.join(path, name)
+        end
+
+        def load_asset(name, default = nil)
+          path = asset_path(name)
+          File.exist?(path) ? File.read(path) : default
+        end
+
+        def save_asset(name, content)
+          File.write(asset_path(name), content.to_s)
+        end
+
+        def load_config
+          @config = YAML.load load_asset('config.yml', '{}')
+          @original_config = @config.dup
+        end
+
+        def store_config
+          save_asset('config.yml', @config.to_yaml)
+        end
+
+        def check_arity(method, *args)
+          return unless method.respond_to? :parameters
+          method.parameters.each do |type, name|
+            return if type == :rest
+            wrong_args("few") unless args.shift or type == :opt
+          end
+          wrong_args("many") if args.any?
+        end
+
+        def wrong_args(quantity)
+          error "too #{quantity} arguments" do
+            say help
+          end
+        end
+    end
+  end
+end

data/lib/travis/cli/encrypt.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+require 'travis/cli'
+require 'yaml'
+
+module Travis
+  module CLI
+    class Encrypt < RepoCommand
+      attr_accessor :config_key
+
+      on('--add [KEY]', 'adds it to .travis.yml under KEY (default: env.global)') do |c, value|
+        c.config_key = value || 'env.global'
+      end
+
+      def run(*args)
+        data = args.join(" ")
+
+        if data.empty?
+          say color("Reading from stdin, press Ctrl+D when done", :info) if $stdin.tty?
+          data = $stdin.read
+        end
+
+        encrypted = repository.encrypt(data)
+
+        if config_key
+          travis_config = YAML.load_file(travis_yaml)
+          keys          = config_key.split('.')
+          last_key      = keys.pop
+          nested_config = keys.inject(travis_config) { |c,k| c[k] ||= {}}
+          nested_config[last_key] ||= [] << encrypted
+          File.write(travis_yaml, travis_config.to_yaml)
+        else
+          say encrypted.inspect, template(__FILE__)
+        end
+      end
+
+      private
+
+        def travis_yaml(dir = Dir.pwd)
+          path = File.expand_path('.travis.yml', dir)
+          if File.exist? path
+            path
+          else
+            parent = File.expand_path('..', dir)
+            travis_yaml(parent) if parent != dir
+          end
+        end
+    end
+  end
+end
+
+__END__
+Please add the following to your <[[ color('.travis.yml', :info) ]]> file:
+
+  secure: %s
+
+Pro Tip<[[ "™" unless Travis::CLI.windows? ]]>: You can add it automatically by running with <[[ color('--add', :info) ]]>.
+

data/lib/travis/cli/endpoint.rb

@@ -0,0 +1,13 @@
+require 'travis/cli'
+
+module Travis
+  module CLI
+    class Endpoint < ApiCommand
+      skip :authenticate
+
+      def run
+        say api_endpoint, "API endpoint: %s"
+      end
+    end
+  end
+end

data/lib/travis/cli/help.rb

@@ -0,0 +1,21 @@
+require 'travis/cli'
+
+module Travis
+  module CLI
+    class Help < Command
+      def run(command = nil)
+        if command
+          say CLI.command(command).new.help
+        else
+          say "Usage: #$0 COMMAND ...\n\nAvailable commands:\n\n"
+          commands.each { |c| say "\t#{c.command_name}" }
+          say "\nrun `#$0 help COMMAND` for more infos"
+        end
+      end
+
+      def commands
+        CLI.commands.sort_by { |c| c.command_name }
+      end
+    end
+  end
+end