reenhanced_bitbucket_api 0.1.6 → 0.3.0

data/lib/bitbucket_rest_api/constants.rb

@@ -27,13 +27,7 @@ module BitBucket
 
     ACCEPT_CHARSET = 'Accept-Charset'.freeze
 
-    # Link headers
-    HEADER_LINK = "Link".freeze
-
-    HEADER_NEXT = "X-Next".freeze
-
-    HEADER_LAST = "X-Last".freeze
-
+    # Link params
     META_REL = "rel".freeze
 
     META_LAST = "last".freeze
@@ -46,8 +40,6 @@ module BitBucket
 
     PARAM_PAGE = "page".freeze
 
-    PARAM_PER_PAGE = "per_page".freeze
-
     PARAM_START_PAGE = "start_page".freeze
 
     # URI parsing

data/lib/bitbucket_rest_api/core_ext/array.rb

@@ -12,6 +12,6 @@ class Array # :nodoc:
 
   def extract_options!
     last.is_a?(::Hash) ? pop : {}
-  end
+  end unless method_defined?(:extract_options!)
 
 end # Array

data/lib/bitbucket_rest_api/error/invalid_options.rb

@@ -8,7 +8,7 @@ module BitBucket #:nodoc
         super(
           generate_message(
             :problem => "Invalid option #{invalid.keys.join(', ')} provided for this request.", 
-            :summary => "BitBucket gem checks the request parameters passed to ensure that github api is not hit unnecessairly and to fail fast.",
+            :summary => "BitBucket gem checks the request parameters passed to ensure that bitbucket api is not hit unnecessairly and to fail fast.",
             :resolution => "Valid options are: #{valid.join(', ')}, make sure these are the ones you are using"
           )
         )

data/lib/bitbucket_rest_api/error/required_params.rb

@@ -8,7 +8,7 @@ module BitBucket #:nodoc
         super(
           generate_message(
             :problem => "Missing required parameters: #{provided.keys.join(', ')} provided for this request.",
-            :summary => "BitBucket gem checks the request parameters passed to ensure that github api is not hit unnecessairly and to fail fast.",
+            :summary => "BitBucket gem checks the request parameters passed to ensure that bitbucket api is not hit unnecessairly and to fail fast.",
             :resolution => "Required parameters are: #{required.join(', ')}, make sure these are the ones you are using"
           )
         )

data/lib/bitbucket_rest_api/error/unknown_value.rb

@@ -8,7 +8,7 @@ module BitBucket #:nodoc
         super(
           generate_message(
             :problem => "Wrong value of '#{value}' for the parameter: #{key} provided for this request.",
-            :summary => "BitBucket gem checks the request parameters passed to ensure that github api is not hit unnecessairly and fails fast.",
+            :summary => "BitBucket gem checks the request parameters passed to ensure that bitbucket api is not hit unnecessairly and fails fast.",
             :resolution => "Permitted values are: #{permitted}, make sure these are the ones you are using"
           )
         )

data/lib/bitbucket_rest_api/ext/faraday.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Faraday
+  module Utils
+
+    class ParamsHash
+      def params_encoder(encoder = nil)
+        if encoder
+          @encoder = encoder
+        else
+          @encoder
+        end
+      end
+
+      def to_query(encoder = nil)
+        Utils.build_nested_query(self, nil, params_encoder)
+      end
+    end
+
+    def build_nested_query(value, prefix = nil, encoder = nil)
+      case value
+      when Array
+        value.map { |v| build_nested_query(v, "#{prefix}%5B%5D", encoder) }.join("&")
+      when Hash
+        value.map { |k, v|
+          processed_value = encoder ? encoder.escape(k) : escape(k)
+          build_nested_query(v, prefix ? "#{prefix}%5B#{processed_value}%5D" : processed_value, encoder)
+        }.join("&")
+      when NilClass
+        prefix
+      else
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        processed_value = encoder ? encoder.escape(value) : escape(value)
+        "#{prefix}=#{processed_value}"
+      end
+    end
+  end
+end

data/lib/bitbucket_rest_api/middleware.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'bitbucket_rest_api/response'
+require 'bitbucket_rest_api/response/mashify'
+require 'bitbucket_rest_api/response/jsonize'
+require 'bitbucket_rest_api/response/raise_error'
+require 'bitbucket_rest_api/response/header'
+
+module BitBucket
+  class Middleware
+    def self.default(options = {})
+      api = options[:api]
+      proc do |builder|
+        builder.use Faraday::Request::Multipart
+        builder.use Faraday::Request::UrlEncoded
+        builder.use FaradayMiddleware::OAuth, {:consumer_key => api.client_id, :consumer_secret => api.client_secret, :token => api.oauth_token, :token_secret => api.oauth_secret} if api.client_id? and api.client_secret?
+        builder.use BitBucket::Request::BasicAuth, api.authentication if api.basic_authed?
+        builder.use FaradayMiddleware::EncodeJson
+
+        builder.use Faraday::Response::Logger if ENV['DEBUG']
+        #builder.use BitBucket::Response::Helpers
+        unless options[:raw]
+          builder.use BitBucket::Response::Mashify
+          builder.use BitBucket::Response::Jsonize
+        end
+        builder.use BitBucket::Response::RaiseError
+        builder.adapter options[:adapter]
+      end
+    end
+  end # Middleware
+end # BitBucket

data/lib/bitbucket_rest_api/null_encoder.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module BitBucket
+
+  # Skip encoding of the key nested parameters
+  module NullParamsEncoder
+    if defined?(Faraday::NestedParamsEncoder)
+      class << self
+        Faraday::NestedParamsEncoder.singleton_methods do |m|
+          define_method m, ::Faraday::NestedParamsEncoder.method(m).to_proc
+        end
+      end
+    end
+
+    def self.escape(s)
+      s.to_s
+    end
+
+    def self.unescape(s)
+      s.to_s
+    end
+  end # NullEncoder
+end # BitBucket

data/lib/bitbucket_rest_api/page_iterator.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+require 'bitbucket_rest_api/utils/url'
+require 'uri'
+
+module BitBucket
+  class PageIterator
+    include BitBucket::Constants
+    include BitBucket::Utils::Url
+    include BitBucket::PagedRequest
+
+    # Setup attribute accesor for all the link types
+    ATTRIBUTES = [ META_FIRST, META_NEXT, META_PREV ]
+
+    ATTRIBUTES.each do |attr|
+      attr_accessor :"#{attr}_page_uri", :"#{attr}_page"
+    end
+
+    attr_reader :current_api
+
+    def initialize(links, current_api)
+      @links        = links
+      @current_api = current_api
+      update_page_links @links
+    end
+
+    def has_next?
+      next_page == 0 || !next_page_uri.nil?
+    end
+
+    # Perform http get request for the first resource
+    #
+    def first
+      return nil unless first_page_uri
+      perform_request(first_page_uri)
+    end
+
+    # Perform http get request for the next resource
+    #
+    def next
+      return nil unless has_next?
+      perform_request(next_page_uri)
+    end
+
+    # Perform http get request for the previous resource
+    #
+    def prev
+      return nil unless prev_page_uri
+      perform_request(prev_page_uri)
+    end
+
+    # Returns the result for a specific page.
+    #
+    def get_page(page_number)
+      # Find URI that we can work with, if we cannot get the first
+      # page URI then there is only one page.
+      return nil unless first_page_uri
+      params = parse_query URI(first_page_uri).query
+      params['page']     = page_number
+
+      response = page_request URI(first_page_uri).path, params
+      update_page_links response.links
+      response
+    end
+
+  private
+
+    def perform_request(attribute)
+      page_uri = URI(attribute)
+      params = parse_query(page_uri.query)
+
+      if next_page and next_page >= 1
+        params['page'] = attribute.to_i
+      end
+
+      response = page_request(page_uri.path, params)
+      update_page_links response.links
+      response
+    end
+
+    # Wholesale update of all link attributes
+    def update_page_links(links) # :nodoc:
+      ATTRIBUTES.each do |attr|
+        self.send(:"#{attr}_page_uri=", links.send(:"#{attr}"))
+        self.send(:"#{attr}_page=", links.send(:"#{attr}"))
+      end
+    end
+
+  end # PageIterator
+end # BitBucket

data/lib/bitbucket_rest_api/page_links.rb

@@ -0,0 +1,33 @@
+module BitBucket
+  # Determines the links in the current response to be used
+  # to find the links to other pages of request responses.
+  class PageLinks
+    include BitBucket::Constants
+
+    FIRST_PAGE_NUMBER = 1 # :nodoc:
+
+    # Hold the extracted values for URI from the response body
+    # for the next and previous page.
+    attr_accessor :response_dup, :first, :next, :prev
+
+    # Parses links from executed request
+    #
+    def initialize(response)
+      self.response_dup = response
+      if response.body.is_a?(Hash) and !response.body[PARAM_PAGE].nil?
+        self.first        = path_for_page(FIRST_PAGE_NUMBER)
+        self.next         = response.body[META_NEXT] unless response.body
+        self.prev         = response.body[META_PREV]
+      end
+    end
+
+    private
+
+    def path_for_page(page_number)
+      if response_dup.respond_to?(:url)
+        self.response_dup.url.to_s.gsub(BitBucket.endpoint, '')
+      end
+    end
+
+  end # PageLinks
+end # BitBucket

data/lib/bitbucket_rest_api/paged_request.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module BitBucket
+
+  # A module that adds http get request to response pagination
+  module PagedRequest
+    include BitBucket::Constants
+    include BitBucket::Normalizer
+
+    FIRST_PAGE = 1 # Default request page if none provided
+
+    NOT_FOUND  = -1 # Page parameter not present
+
+    def default_page
+      current_api.current_page ? current_api.current_page : FIRST_PAGE
+    end
+
+    # Perform http get request with pagination parameters
+    #
+    def page_request(path, params={})
+      if params[PARAM_PAGE] && params[PARAM_PAGE] == NOT_FOUND
+        params[PARAM_PAGE] = default_page
+      end
+
+      current_api.get_request(path, ParamsHash.new(params))
+    end
+
+  end # PagedRequest
+end # BitBucket

data/lib/bitbucket_rest_api/pagination.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+module BitBucket
+
+  # A module that decorates response with pagination helpers
+  module Pagination
+    include BitBucket::Constants
+
+    def paginated?
+      body.is_a?(Hash) and body[PARAM_PAGE].nil?
+    end
+
+    # Return page links
+    def links
+      @links = BitBucket::PageLinks.new(self.response)
+    end
+
+    # Iterate over results set pages by automatically calling `next_page`
+    # until all pages are exhausted. Caution needs to be exercised when
+    # using this feature - 100 pages iteration will perform 100 API calls.
+    # By default this is off. You can set it on the client, individual API
+    # instances or just per given request.
+    #
+    def auto_paginate(auto=false)
+      if (current_api.auto_pagination? || auto)
+        resources_bodies = []
+        each_page do |resource|
+          if resource.body.respond_to?(:values)
+            resources_bodies += resource.body[:values].collect {|value| ::Hashie::Mash.new(value) }
+          else
+            resources_bodies += Array(resource.body)
+          end
+        end
+        self.body = resources_bodies
+      end
+      self
+    end
+
+    # Iterator like each for response pages. If there are no pages to
+    # iterate over this method will return current page.
+    def each_page
+      yield self
+      while page_iterator.has_next?
+        yield next_page
+      end
+    end
+
+    # Retrives the result of the first page. Returns <tt>nil</tt> if there is
+    # no first page - either because you are already on the first page
+    # or there are no pages at all in the result.
+    def first_page
+      first_request = page_iterator.first
+      self.instance_eval { @env = first_request.env } if first_request
+      first_request
+    end
+
+    # Retrives the result of the next page. Returns <tt>nil</tt> if there is
+    # no next page or no pages at all.
+    def next_page
+      next_request = page_iterator.next
+      self.instance_eval { @env = next_request.env } if next_request
+      next_request
+    end
+
+    # Retrives the result of the previous page. Returns <tt>nil</tt> if there is
+    # no previous page or no pages at all.
+    def prev_page
+      prev_request = page_iterator.prev
+      self.instance_eval { @env = prev_request.env } if prev_request
+      prev_request
+    end
+    alias :previous_page :prev_page
+
+    # Retrives a specific result for a page given page number.
+    # The <tt>page_number</tt> parameter is not validate, hitting a page
+    # that does not exist will return BitBucket API error. Consequently, if
+    # there is only one page, this method returns nil
+    def page(page_number)
+      request = page_iterator.get_page(page_number)
+      self.instance_eval { @env = request.env } if request
+      request
+    end
+
+    # Returns <tt>true</tt> if there is another page in the result set,
+    # otherwise <tt>false</tt>
+    def has_next_page?
+      page_iterator.has_next?
+    end
+
+    private
+
+    # Internally used page iterator
+    def page_iterator # :nodoc:
+      @page_iterator = BitBucket::PageIterator.new(links, current_api)
+    end
+
+  end # Pagination
+end # BitBucket

data/lib/bitbucket_rest_api/parameter_filter.rb

@@ -10,7 +10,7 @@ module BitBucket
     #
     def filter!(keys, params, options={:recursive => true})  # :nodoc:
       case params
-      when Hash
+      when Hash, ParamsHash
         params.keys.each do |k, v|
           unless (keys.include?(k) or BitBucket::Validations::VALID_API_KEYS.include?(k))
             params.delete(k)

data/lib/bitbucket_rest_api/params_hash.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+require 'delegate'
+require 'base64'
+
+module BitBucket
+
+  # Class responsible for holding request parameters
+  class ParamsHash < DelegateClass(Hash)
+    include Normalizer
+
+    def initialize(hash)
+      super(normalize!(Hash[hash]))
+    end
+
+    # Create empty hash
+    #
+    def self.empty
+      new({})
+    end
+
+    # Extract and parse media type param
+    #
+    #  [.version].param[+json]
+    #
+    def media
+      parse(delete('media'))
+    end
+
+    # Return accept header if present
+    #
+    def accept
+      if has_key?('accept')
+        delete('accept')
+      elsif has_key?('media')
+        media
+      else
+        nil
+      end
+    end
+
+    # Extract request data from parameters
+    #
+    def data
+      if has_key?('data') && !self['data'].nil?
+        return delete('data')
+      else
+        return to_hash
+      end
+    end
+
+    def encoder
+      if has_key?('encoder') && self['encoder']
+        return delete('encoder')
+      else
+        return {}
+      end
+    end
+
+    # Any client configuration options
+    #
+    def options
+      opts = has_key?('options') ? delete('options') : {}
+      headers = opts.fetch(:headers) { {} }
+      if value = accept
+        headers[:accept] = value
+      end
+      if value = delete('content_type')
+        headers[:content_type] = value
+      end
+      opts[:raw] = has_key?('raw') ? delete('raw') : false
+      opts[:headers] = headers unless headers.empty?
+      opts
+    end
+
+    # Update hash with default parameters for non existing keys
+    #
+    def merge_default(defaults)
+      if defaults && !defaults.empty?
+        defaults.each do |key, value|
+          self[key] = value unless self.has_key?(key)
+        end
+      end
+      self
+    end
+
+    # Base64 encode string removing newline characters
+    #
+    def strict_encode64(key)
+      value = self[key]
+      encoded = if Base64.respond_to?(:strict_encode64)
+        Base64.strict_encode64(value)
+      else
+        [value].pack("m0")
+      end
+      self[key] = encoded.delete("\n\r")
+    end
+
+  end # ParamsHash
+end # BitBucket

data/lib/bitbucket_rest_api/request/basic_auth.rb

@@ -4,12 +4,14 @@ require 'faraday'
 require 'base64'
 
 module BitBucket
-  module Request
+  class Request
     class BasicAuth < Faraday::Middleware
       dependency 'base64'
 
       def call(env)
-        env[:request_headers].merge!('Authorization' => "Basic #{@auth}\"")
+        unless @auth.to_s.empty?
+          env[:request_headers].merge!('Authorization' => "Basic #{@auth}\"")
+        end
 
         @app.call env
       end

data/lib/bitbucket_rest_api/request/jsonize.rb

@@ -14,6 +14,11 @@ module BitBucket
       if request_with_body?(env)
         env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
         env[:body] = encode_body env unless env[:body].respond_to?(:to_str)
+      else
+        # Ensure valid body for put and post requests
+        if [:put, :patch, :post].include? env[:method]
+          env[:body] = encode_body({})
+        end
       end
       @app.call env
     end

data/lib/bitbucket_rest_api/request/oauth.rb

@@ -3,7 +3,7 @@
 require 'faraday'
 
 module BitBucket
-  module Request
+  class Request
     class OAuth < Faraday::Middleware
       include BitBucket::Utils::Url
 
@@ -18,12 +18,12 @@ module BitBucket
         if (@token and @secret) and (!@token.empty? and !@secret.empty?)
           access_token = ::OAuth::AccessToken.new(@consumer, @token, @secret)
           env[:url].query = build_query params
-          
+
           puts oauth_helper.header
           puts oauth_helper.header.class
           env[:request_headers].merge!(AUTH_HEADER => oauth_helper.header)
         end
-          
+
           env[:url].query = build_query params
 
 

data/lib/bitbucket_rest_api/request/verbs.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module BitBucket
+  # A class responsible for dispatching http requests
+  class Request
+
+    # Defines HTTP verbs
+    module Verbs
+      # Make a get request
+      #
+      # @api public
+      def get_request(path, params = ParamsHash.empty)
+        request = Request.new(:get, path, self).call(current_options, params)
+        request.auto_paginate
+      end
+
+      # Make a patch request
+      #
+      # @api public
+      def patch_request(path, params = ParamsHash.empty)
+        Request.new(:patch, path, self).call(current_options, params)
+      end
+
+      # Make a post request
+      #
+      # @api public
+      def post_request(path, params = ParamsHash.empty)
+        Request.new(:post, path, self).call(current_options, params)
+      end
+
+      # Make a put request
+      #
+      # @api public
+      def put_request(path, params = ParamsHash.empty)
+        Request.new(:put, path, self).call(current_options, params)
+      end
+
+      # Make a delete request
+      #
+      # @api public
+      def delete_request(path, params = ParamsHash.empty)
+        Request.new(:delete, path, self).call(current_options, params)
+      end
+
+      # Make a options request
+      #
+      # @api public
+      def options_request(path, params = ParamsHash.empty)
+        Request.new(:options, path, self).call(current_options, params)
+      end
+    end # Verbs
+  end # Request
+end # BitBucket