gitlab 3.5.0 → 3.6.0

data/lib/gitlab/help.rb

@@ -5,7 +5,6 @@ module Gitlab::Help
   extend Gitlab::CLI::Helpers
 
   class << self
-
     # Returns the (modified) help from the 'ri' command or returns an error.
     #
     # @return [String]
@@ -15,7 +14,7 @@ module Gitlab::Help
       if cmd_namespace
         ri_output = `#{ri_cmd} -T #{cmd_namespace} 2>&1`.chomp
 
-        if $? == 0
+        if $CHILD_STATUS == 0
           change_help_output! cmd, ri_output
           yield ri_output if block_given?
 
@@ -34,7 +33,7 @@ module Gitlab::Help
     def ri_cmd
       which_ri = `which ri`.chomp
       if which_ri.empty?
-        raise "'ri' tool not found in $PATH. Please install it to use the help."
+        fail "'ri' tool not found in $PATH. Please install it to use the help."
       end
 
       which_ri
@@ -47,19 +46,19 @@ module Gitlab::Help
     # @return [Hash<Array>]
     def help_map
       @help_map ||= begin
-          actions.each_with_object({}) do |action, hsh|
-            key = client.method(action).
-                         owner.to_s.gsub(/Gitlab::(?:Client::)?/, '')
-            hsh[key] ||= []
-            hsh[key] << action.to_s
-          end
+        actions.each_with_object({}) do |action, hsh|
+          key = client.method(action).
+                owner.to_s.gsub(/Gitlab::(?:Client::)?/, '')
+          hsh[key] ||= []
+          hsh[key] << action.to_s
+        end
       end
     end
 
     # Table with available commands.
     #
     # @return [Terminal::Table]
-    def actions_table(topic = nil)
+    def actions_table(topic=nil)
       rows = topic ? help_map[topic] : help_map.keys
       table do |t|
         t.title = topic || "Help Topics"
@@ -75,16 +74,21 @@ module Gitlab::Help
     # Returns full namespace of a command (e.g. Gitlab::Client::Branches.cmd)
     def namespace(cmd)
       method_owners.select { |method| method[:name] === cmd }.
-                    map    { |method| method[:owner] + '.' + method[:name] }.
-                    shift
+        map { |method| method[:owner] + '.' + method[:name] }.
+        shift
     end
 
     # Massage output from 'ri'.
     def change_help_output!(cmd, output_str)
-      output_str.gsub!(/#{cmd}\((.*?)\)/m, cmd+' \1')
+      output_str.gsub!(/#{cmd}\((.*?)\)/m, cmd + ' \1')
       output_str.gsub!(/\,[\s]*/, ' ')
+      
+      # Ensure @option descriptions are on a single line
+      output_str.gsub!(/\n\[/, " \[")
+      output_str.gsub!(/\s(@)/, "\n@")
+      output_str.gsub!(/(\])\n(\:)/, '\1 \2')
+      output_str.gsub!(/(\:.*)(\n)(.*\.)/, '\1 \3')
+      
     end
-
   end # class << self
 end
-

data/lib/gitlab/objectified_hash.rb

@@ -4,7 +4,7 @@ module Gitlab
     # Creates a new ObjectifiedHash object.
     def initialize(hash)
       @hash = hash
-      @data = hash.inject({}) do |data, (key,value)|
+      @data = hash.inject({}) do |data, (key, value)|
         value = ObjectifiedHash.new(value) if value.is_a? Hash
         data[key.to_s] = value
         data
@@ -27,7 +27,7 @@ module Gitlab
       @data.key?(key.to_s) ? @data[key.to_s] : nil
     end
 
-    def respond_to?(method_name, include_private = false)
+    def respond_to?(method_name, include_private=false)
       @hash.keys.map(&:to_sym).include?(method_name.to_sym) || super
     end
   end

data/lib/gitlab/page_links.rb

@@ -0,0 +1,33 @@
+module Gitlab
+  # Parses link header.
+  #
+  # @private
+  class PageLinks
+    HEADER_LINK = 'Link'.freeze
+    DELIM_LINKS = ','.freeze
+    LINK_REGEX = /<([^>]+)>; rel=\"([^\"]+)\"/
+    METAS = %w(last next first prev)
+
+    attr_accessor(*METAS)
+
+    def initialize(headers)
+      link_header = headers[HEADER_LINK]
+
+      if link_header && link_header =~ /(next|first|last|prev)/
+        extract_links(link_header)
+      end
+    end
+
+    private
+
+    def extract_links(header)
+      header.split(DELIM_LINKS).each do |link|
+        LINK_REGEX.match(link.strip) do |match|
+          url, meta = match[1], match[2]
+          next if !url || !meta || METAS.index(meta).nil?
+          self.send("#{meta}=", url)
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/paginated_response.rb

@@ -0,0 +1,97 @@
+module Gitlab
+  # Wrapper class of paginated response.
+  class PaginatedResponse
+    attr_accessor :client
+
+    def initialize(array)
+      @array = array
+    end
+
+    def ==(other)
+      @array == other
+    end
+
+    def inspect
+      @array.inspect
+    end
+
+    def method_missing(name, *args, &block)
+      if @array.respond_to?(name)
+        @array.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to?(method, include_all=false)
+      super || @array.respond_to?(method, include_all)
+    end
+
+    def parse_headers!(headers)
+      @links = PageLinks.new headers
+    end
+
+    def each_page
+      current = self
+      yield current
+      while current.has_next_page?
+        current = current.next_page
+        yield current
+      end
+    end
+
+    def auto_paginate
+      response = block_given? ? nil : []
+      each_page do |page|
+        if block_given?
+          page.each do |item|
+            yield item
+          end
+        else
+          response += page
+        end
+      end
+      response
+    end
+
+    def has_last_page?
+      !(@links.nil? || @links.last.nil?)
+    end
+
+    def last_page
+      return nil if @client.nil? || !has_last_page?
+      path = @links.last.sub(/#{@client.endpoint}/, '')
+      @client.get(path)
+    end
+
+    def has_first_page?
+      !(@links.nil? || @links.first.nil?)
+    end
+
+    def first_page
+      return nil if @client.nil? || !has_first_page?
+      path = @links.first.sub(/#{@client.endpoint}/, '')
+      @client.get(path)
+    end
+
+    def has_next_page?
+      !(@links.nil? || @links.next.nil?)
+    end
+
+    def next_page
+      return nil if @client.nil? || !has_next_page?
+      path = @links.next.sub(/#{@client.endpoint}/, '')
+      @client.get(path)
+    end
+
+    def has_prev_page?
+      !(@links.nil? || @links.prev.nil?)
+    end
+
+    def prev_page
+      return nil if @client.nil? || !has_prev_page?
+      path = @links.prev.sub(/#{@client.endpoint}/, '')
+      @client.get(path)
+    end
+  end
+end

data/lib/gitlab/request.rb

@@ -7,7 +7,7 @@ module Gitlab
     include HTTParty
     format :json
     headers 'Accept' => 'application/json'
-    parser Proc.new { |body, _| parse(body) }
+    parser proc { |body, _| parse(body) }
 
     attr_accessor :private_token, :endpoint
 
@@ -18,7 +18,7 @@ module Gitlab
       if body.is_a? Hash
         ObjectifiedHash.new body
       elsif body.is_a? Array
-        body.collect! { |e| ObjectifiedHash.new(e) }
+        PaginatedResponse.new(body.collect! { |e| ObjectifiedHash.new(e) })
       elsif body
         true
       elsif !body
@@ -32,11 +32,9 @@ module Gitlab
 
     # Decodes a JSON response into Ruby object.
     def self.decode(response)
-      begin
-        JSON.load response
-      rescue JSON::ParserError
-        raise Error::Parsing.new "The response is not a valid JSON"
-      end
+      JSON.load response
+    rescue JSON::ParserError
+      raise Error::Parsing.new "The response is not a valid JSON"
     end
 
     def get(path, options={})
@@ -67,26 +65,29 @@ module Gitlab
     # Returns parsed response for successful requests.
     def validate(response)
       case response.code
-        when 400; raise Error::BadRequest.new error_message(response)
-        when 401; raise Error::Unauthorized.new error_message(response)
-        when 403; raise Error::Forbidden.new error_message(response)
-        when 404; raise Error::NotFound.new error_message(response)
-        when 405; raise Error::MethodNotAllowed.new error_message(response)
-        when 409; raise Error::Conflict.new error_message(response)
-        when 422; raise Error::Unprocessable.new error_message(response)
-        when 500; raise Error::InternalServerError.new error_message(response)
-        when 502; raise Error::BadGateway.new error_message(response)
-        when 503; raise Error::ServiceUnavailable.new error_message(response)
+      when 400 then fail Error::BadRequest.new error_message(response)
+      when 401 then fail Error::Unauthorized.new error_message(response)
+      when 403 then fail Error::Forbidden.new error_message(response)
+      when 404 then fail Error::NotFound.new error_message(response)
+      when 405 then fail Error::MethodNotAllowed.new error_message(response)
+      when 409 then fail Error::Conflict.new error_message(response)
+      when 422 then fail Error::Unprocessable.new error_message(response)
+      when 500 then fail Error::InternalServerError.new error_message(response)
+      when 502 then fail Error::BadGateway.new error_message(response)
+      when 503 then fail Error::ServiceUnavailable.new error_message(response)
       end
 
-      response.parsed_response
+      parsed = response.parsed_response
+      parsed.client = self if parsed.respond_to?(:client=)
+      parsed.parse_headers!(response.headers) if parsed.respond_to?(:parse_headers!)
+      parsed
     end
 
     # Sets a base_uri and default_params for requests.
     # @raise [Error::MissingCredentials] if endpoint not set.
     def set_request_defaults(sudo=nil)
+      self.class.default_params sudo: sudo
       raise Error::MissingCredentials.new("Please set an endpoint to API") unless @endpoint
-      self.class.default_params :sudo => sudo
       self.class.default_params.delete(:sudo) if sudo.nil?
     end
 
@@ -98,9 +99,9 @@ module Gitlab
       unless path == '/session'
         raise Error::MissingCredentials.new("Please provide a private_token or auth_token for user") unless @private_token
         if @private_token.length <= 20
-          options[:headers] = {'PRIVATE-TOKEN' => @private_token}
+          options[:headers] = { 'PRIVATE-TOKEN' => @private_token }
         else
-          options[:headers] = {'Authorization' => "Bearer #{@private_token}"}
+          options[:headers] = { 'Authorization' => "Bearer #{@private_token}" }
         end
       end
     end
@@ -108,9 +109,7 @@ module Gitlab
     # Set HTTParty configuration
     # @see https://github.com/jnunemaker/httparty
     def set_httparty_config(options)
-      if self.httparty
-        options.merge!(self.httparty)
-      end
+      options.merge!(httparty) if httparty
     end
 
     def error_message(response)
@@ -127,7 +126,7 @@ module Gitlab
       case message
       when Gitlab::ObjectifiedHash
         message.to_h.sort.map do |key, val|
-          "'#{key}' #{(val.is_a?(Hash) ? val.sort.map { |k,v| "(#{k}: #{v.join(' ')})"} : val).join(' ')}"
+          "'#{key}' #{(val.is_a?(Hash) ? val.sort.map { |k, v| "(#{k}: #{v.join(' ')})" } : val).join(' ')}"
         end.join(', ')
       when Array
         message.join(' ')
@@ -135,6 +134,5 @@ module Gitlab
         message
       end
     end
-
   end
 end

data/lib/gitlab/shell.rb

@@ -62,13 +62,13 @@ class Gitlab::Shell
     end
 
     # Execute a given command with arguements
-    def execute(cmd = command, args = arguments)
+    def execute(cmd=command, args=arguments)
       if actions.include?(cmd.to_sym)
         confirm_command(cmd)
         gitlab_helper(cmd, args)
       else
-        raise "Unknown command: #{cmd}. " +
-              "See the 'help' for a list of valid commands."
+        fail "Unknown command: #{cmd}. " \
+             "See the 'help' for a list of valid commands."
       end
     end
 
@@ -80,6 +80,5 @@ class Gitlab::Shell
     def history
       @history ||= History.new
     end
-
-  end  # class << self
+  end # class << self
 end

data/lib/gitlab/shell_history.rb

@@ -3,7 +3,7 @@ class Gitlab::Shell
     DEFAULT_HISTFILESIZE = 200
     DEFAULT_FILE_PATH = File.join(Dir.home, '.gitlab_shell_history')
 
-    def initialize(options = {})
+    def initialize(options={})
       @file_path = options[:file_path] || DEFAULT_FILE_PATH
       Readline::HISTORY.clear
     end
@@ -47,15 +47,13 @@ class Gitlab::Shell
     def read_from_file
       path = history_file_path
 
-      if File.exist?(path)
-        File.foreach(path) { |line| yield(line) }
-      end
+      File.foreach(path) { |line| yield(line) } if File.exist?(path)
     rescue => error
       warn "History file not loaded: #{error.message}"
     end
 
     def max_lines
-      (ENV['GITLAB_HISTFILESIZE']|| DEFAULT_HISTFILESIZE).to_i
+      (ENV['GITLAB_HISTFILESIZE'] || DEFAULT_HISTFILESIZE).to_i
     end
   end
 end

data/lib/gitlab/version.rb

@@ -1,3 +1,3 @@
 module Gitlab
-  VERSION = "3.5.0"
+  VERSION = "3.6.0"
 end

data/spec/gitlab/cli_helpers_spec.rb

@@ -7,8 +7,8 @@ describe Gitlab::CLI::Helpers do
     end
     it "should return Array of Hashes containing method names and owners" do
       expect(@methods).to be_a Array
-      expect(@methods.all? { |m| m.is_a? Hash} ).to be true
-      expect(@methods.all? { |m| m.keys.sort === [:name, :owner]} ).to be true
+      expect(@methods.all? { |m| m.is_a? Hash }).to be true
+      expect(@methods.all? { |m| m.keys.sort === [:name, :owner] }).to be true
     end
   end
 
@@ -24,15 +24,15 @@ describe Gitlab::CLI::Helpers do
   describe ".symbolize_keys" do
     context "when input is a Hash" do
       it "should return a Hash with symbols for keys" do
-        hash = {'key1' => 'val1', 'key2' => 'val2'}
+        hash = { 'key1' => 'val1', 'key2' => 'val2' }
         symbolized_hash = Gitlab::CLI::Helpers.symbolize_keys(hash)
-        expect(symbolized_hash).to eq({key1: 'val1', key2: 'val2'})
+        expect(symbolized_hash).to eq(key1: 'val1', key2: 'val2')
       end
     end
     context "when input is NOT a Hash" do
       it "should return input untouched" do
         array = [1, 2, 3]
-        new_array = Gitlab::CLI::Helpers.symbolize_keys(array) 
+        new_array = Gitlab::CLI::Helpers.symbolize_keys(array)
         expect(new_array).to eq([1, 2, 3])
       end
     end
@@ -41,18 +41,17 @@ describe Gitlab::CLI::Helpers do
   describe ".yaml_load" do
     context "when argument is a YAML string" do
       it "should return Ruby objects" do
-        argument = "{foo: bar, sna: fu}" 
+        argument = "{foo: bar, sna: fu}"
         output = Gitlab::CLI::Helpers.yaml_load argument
-        expect(output).to eq({'foo' => 'bar', 'sna' => 'fu'})
+        expect(output).to eq('foo' => 'bar', 'sna' => 'fu')
       end
     end
 
     context "when input is NOT valid YAML" do
       it "should raise" do
         ruby_array = [1, 2, 3, 4]
-        expect { Gitlab::CLI::Helpers.yaml_load ruby_array}.to raise_error TypeError
+        expect { Gitlab::CLI::Helpers.yaml_load ruby_array }.to raise_error TypeError
       end
     end
   end
-
 end