gitlab 3.0.0 → 4.0.0

data/lib/gitlab/file_response.rb

@@ -0,0 +1,46 @@
+module Gitlab
+  # Wrapper class of file response.
+  class FileResponse
+    HEADER_CONTENT_DISPOSITION = 'Content-Disposition'.freeze
+
+    attr_reader :filename
+
+    def initialize(file)
+      @file = file
+    end
+
+    # @return [bool] Always false
+    def empty?
+      false
+    end
+
+    # @return [Hash] A hash consisting of filename and io object
+    def to_hash
+      { filename: @filename, data: @file }
+    end
+    alias_method :to_h, :to_hash
+
+    # @return [String] Formatted string with the class name, object id and filename.
+    def inspect
+      "#<#{self.class}:#{object_id} {filename: #{filename.inspect}}>"
+    end
+
+    def method_missing(name, *args, &block)
+      if @file.respond_to?(name)
+        @file.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      super || @file.respond_to?(method_name, include_private)
+    end
+
+    # Parse filename from the 'Content Disposition' header.
+    def parse_headers!(headers)
+      @filename = headers[HEADER_CONTENT_DISPOSITION].split("filename=")[1]
+      @filename = @filename[1...-1] if @filename[0] == '"' # Unquote filenames
+    end
+  end
+end

data/lib/gitlab/help.rb

@@ -0,0 +1,95 @@
+require 'gitlab'
+require 'gitlab/cli_helpers'
+
+module Gitlab::Help
+  extend Gitlab::CLI::Helpers
+
+  class << self
+    # Returns the (modified) help from the 'ri' command or returns an error.
+    #
+    # @return [String]
+    def get_help(cmd)
+      cmd_namespace = namespace cmd
+
+      if cmd_namespace
+        ri_output = `#{ri_cmd} -T #{cmd_namespace} 2>&1`.chomp
+
+        if $CHILD_STATUS == 0
+          change_help_output! cmd, ri_output
+          yield ri_output if block_given?
+
+          ri_output
+        else
+          "Ri docs not found for #{cmd}, please install the docs to use 'help'."
+        end
+      else
+        "Unknown command: #{cmd}."
+      end
+    end
+
+    # Finds the location of 'ri' on a system.
+    #
+    # @return [String]
+    def ri_cmd
+      which_ri = `which ri`.chomp
+      if which_ri.empty?
+        fail "'ri' tool not found in $PATH. Please install it to use the help."
+      end
+
+      which_ri
+    end
+
+    # A hash map that contains help topics (Branches, Groups, etc.)
+    # and a list of commands that are defined under a topic (create_branch,
+    # branches, protect_branch, etc.).
+    #
+    # @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
+      end
+    end
+
+    # Table with available commands.
+    #
+    # @return [Terminal::Table]
+    def actions_table(topic=nil)
+      rows = topic ? help_map[topic] : help_map.keys
+      table do |t|
+        t.title = topic || "Help Topics"
+
+        # add_row expects an array and we have strings hence the map.
+        rows.sort.map { |r| [r] }.each_with_index do |row, index|
+          t.add_row row
+          t.add_separator unless rows.size - 1 == index
+        end
+      end
+    end
+
+    # 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
+    end
+
+    # Massage output from 'ri'.
+    def change_help_output!(cmd, output_str)
+      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')
+      output_str.gsub!(/\{(.+)\}/, '"{\1}"')
+      
+    end
+  end # class << self
+end

data/lib/gitlab/objectified_hash.rb

@@ -1,18 +1,34 @@
 module Gitlab
   # Converts hashes to the objects.
   class ObjectifiedHash
-    # Creates a new ObjectifiedHash.
+    # Creates a new ObjectifiedHash object.
     def initialize(hash)
-      @data = hash.inject({}) do |data, (key,value)|
+      @hash = hash
+      @data = hash.inject({}) do |data, (key, value)|
         value = ObjectifiedHash.new(value) if value.is_a? Hash
         data[key.to_s] = value
         data
       end
     end
 
-    # Delegate to ObjectifiedHash
+    # @return [Hash] The original hash.
+    def to_hash
+      @hash
+    end
+    alias_method :to_h, :to_hash
+
+    # @return [String] Formatted string with the class name, object id and original hash.
+    def inspect
+      "#<#{self.class}:#{object_id} {hash: #{@hash.inspect}}"
+    end
+
+    # Delegate to ObjectifiedHash.
     def method_missing(key)
       @data.key?(key.to_s) ? @data[key.to_s] : nil
     end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @hash.keys.map(&:to_sym).include?(method_name.to_sym) || super
+    end
   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_missing?(method_name, include_private = false)
+      super || @array.respond_to?(method_name, include_private)
+    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

@@ -1,4 +1,5 @@
 require 'httparty'
+require 'json'
 
 module Gitlab
   # @private
@@ -6,7 +7,9 @@ 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
 
     # Converts the response body to an ObjectifiedHash.
     def self.parse(body)
@@ -15,7 +18,13 @@ 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
+        false
+      elsif body.nil?
+        false
       else
         raise Error::Parsing.new "Couldn't parse a response body"
       end
@@ -23,63 +32,86 @@ 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={})
-      validate self.class.get(path, options)
+      set_httparty_config(options)
+      set_authorization_header(options)
+      validate self.class.get(@endpoint + path, options)
     end
 
     def post(path, options={})
-      validate self.class.post(path, options)
+      set_httparty_config(options)
+      set_authorization_header(options, path)
+      validate self.class.post(@endpoint + path, options)
     end
 
     def put(path, options={})
-      validate self.class.put(path, options)
+      set_httparty_config(options)
+      set_authorization_header(options)
+      validate self.class.put(@endpoint + path, options)
     end
 
-    def delete(path)
-      validate self.class.delete(path)
+    def delete(path, options={})
+      set_httparty_config(options)
+      set_authorization_header(options)
+      validate self.class.delete(@endpoint + path, options)
     end
 
     # Checks the response code for common errors.
     # 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 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)
+      error_klass = case response.code
+      when 400 then Error::BadRequest
+      when 401 then Error::Unauthorized
+      when 403 then Error::Forbidden
+      when 404 then Error::NotFound
+      when 405 then Error::MethodNotAllowed
+      when 409 then Error::Conflict
+      when 422 then Error::Unprocessable
+      when 500 then Error::InternalServerError
+      when 502 then Error::BadGateway
+      when 503 then Error::ServiceUnavailable
       end
 
-      response.parsed_response
+      fail error_klass.new(response) if error_klass
+
+      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 or private_token not set.
-    def set_request_defaults(endpoint, private_token, sudo=nil)
-      raise Error::MissingCredentials.new("Please set an endpoint to API") unless endpoint
-      raise Error::MissingCredentials.new("Please set a private_token for user") unless private_token
-
-      self.class.base_uri endpoint
-      self.class.default_params :private_token => private_token, :sudo => sudo
+    # @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.delete(:sudo) if sudo.nil?
     end
 
     private
 
-    def error_message(response)
-      "Server responded with code #{response.code}, message: #{response.parsed_response.message}. " \
-      "Request URI: #{response.request.base_uri}#{response.request.path}"
+    # Sets a PRIVATE-TOKEN or Authorization header for requests.
+    # @raise [Error::MissingCredentials] if private_token and auth_token are not set.
+    def set_authorization_header(options, path=nil)
+      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 }
+        else
+          options[:headers] = { 'Authorization' => "Bearer #{@private_token}" }
+        end
+      end
+    end
+
+    # Set HTTParty configuration
+    # @see https://github.com/jnunemaker/httparty
+    def set_httparty_config(options)
+      options.merge!(httparty) if httparty
     end
   end
 end