codenamev_bitbucket_api 0.4.0

data/lib/bitbucket_rest_api/error/unauthorized.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module BitBucket #:nodoc
+  # Raised when BitBucket returns the HTTP status code 401
+  module Error
+    class Unauthorized < BitBucketError
+      def initialize(env)
+        super(env)
+      end
+    end
+  end # Error
+end # BitBucket

data/lib/bitbucket_rest_api/error/unknown_value.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module BitBucket #:nodoc
+  # Raised when invalid options are passed to a request body
+  module Error
+    class UnknownValue < ClientError
+      def initialize(key, value, permitted)
+        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 bitbucket api is not hit unnecessairly and fails fast.",
+            :resolution => "Permitted values are: #{permitted}, make sure these are the ones you are using"
+          )
+        )
+      end
+    end
+  end # Error
+end # BitBucket

data/lib/bitbucket_rest_api/error/unprocessable_entity.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module BitBucket #:nodoc
+  # Raised when BitBucket returns the HTTP status code 422
+  module Error
+    class UnprocessableEntity < BitBucketError
+      def initialize(env)
+        super(env)
+      end
+    end
+  end # Error
+end # BitBucket

data/lib/bitbucket_rest_api/error/validations.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module BitBucket #:nodoc
+  # Raised when passed parameters are missing or contain wrong values.
+  module Error
+    class Validations < ClientError
+      def initialize(errors)
+        super(
+          generate_message(
+            :problem => '',
+            :summary => '',
+            :resolution => ''
+          )
+        )
+      end
+    end
+  end # Error
+end # BitBucket

data/lib/bitbucket_rest_api/error.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module BitBucket
+  module Error
+    class BitBucketError < StandardError
+      attr_reader :response_message, :response_headers
+
+      def initialize(message)
+        super message
+        @response_message = message
+      end
+
+#       def inspect
+#         %(#<#{self.class}>)
+#       end
+    end
+  end # Error
+end # BitBucket
+
+%w[
+  service_error
+  not_found
+  forbidden
+  bad_request
+  unauthorized
+  service_unavailable
+  internal_server_error
+  unprocessable_entity
+  client_error
+  invalid_options
+  required_params
+  unknown_value
+].each do |error|
+  require "bitbucket_rest_api/error/#{error}"
+end

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 BitBucket::Request::Jsonize
+        builder.use Faraday::Request::UrlEncoded
+        builder.use Faraday::Request::Multipart
+        builder.use BitBucket::Request::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 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/normalizer.rb

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+module BitBucket
+  # Deals with normalizing client supplied parameter keys.
+  module Normalizer
+
+    # Turns any keys from nested hashes including nested arrays into strings
+    #
+    def normalize!(params)
+      case params
+      when Hash
+        params.keys.each do |k|
+          params[k.to_s] = params.delete(k)
+          normalize!(params[k.to_s])
+        end
+      when Array
+        params.map! do |el|
+          normalize!(el)
+        end
+      else
+        params.to_s
+      end
+      return params
+    end
+
+  end # Normalizer
+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,97 @@
+# 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 paginated? and (current_api.auto_pagination? || auto)
+        resources_bodies = []
+        each_page do |resource|
+          if resource.body.respond_to?(:values) and resource.body[: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

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+module BitBucket
+  # Allows you to specify parameters keys which will be preserved
+  # in parameters hash and its subhashes. Any keys from the nested
+  # hash that do not match will be removed.
+  module ParameterFilter
+
+    # Removes any keys from nested hashes that don't match predefiend keys
+    #
+    def filter!(keys, params, options={:recursive => true})  # :nodoc:
+      case params
+      when Hash, ParamsHash
+        params.keys.each do |k, v|
+          unless (keys.include?(k) or BitBucket::Validations::VALID_API_KEYS.include?(k))
+            params.delete(k)
+          else
+            filter!(keys, params[k]) if options[:recursive]
+          end
+        end
+      when Array
+        params.map! do |el|
+          filter!(keys, el) if options[:recursive]
+        end
+      else
+        params
+      end
+      return params
+    end
+
+  end # Filter
+end # BitBucket

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'base64'
+
+module BitBucket
+  class Request
+    class BasicAuth < Faraday::Middleware
+      dependency 'base64'
+
+      def call(env)
+        unless @auth.to_s.empty?
+          env[:request_headers].merge!('Authorization' => "Basic #{@auth}\"")
+        end
+
+        @app.call env
+      end
+
+      def initialize(app, *args)
+        @app = app
+        credentials = ""
+        options = args.extract_options!
+        if options.has_key? :login
+          credentials = "#{options[:login]}:#{options[:password]}"
+        elsif options.has_key? :basic_auth
+          credentials = "#{options[:basic_auth]}"
+        end
+        @auth = Base64.encode64(credentials)
+        @auth.gsub!("\n", "")
+      end
+    end # BasicAuth
+  end # Request
+end # BitBucket

data/lib/bitbucket_rest_api/request/jsonize.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module BitBucket
+  class Request::Jsonize < Faraday::Middleware
+
+    CONTENT_TYPE = 'Content-Type'.freeze
+    MIME_TYPE    = 'application/json'.freeze
+
+    dependency 'multi_json'
+
+    def call(env)
+      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
+
+    def encode_body(env)
+      if MultiJson.respond_to?(:dump)
+        MultiJson.dump env[:body]
+      else
+        MultiJson.encode env[:body]
+      end
+    end
+
+    def request_with_body?(env)
+      type = request_type(env)
+      has_body?(env) and (type.empty? or type == MIME_TYPE)
+    end
+
+    # Don't encode bodies in string form
+    def has_body?(env)
+      body = env[:body] and !(body.respond_to?(:to_str) and body.empty?)
+    end
+
+    def request_type(env)
+      type = env[:request_headers][CONTENT_TYPE].to_s
+      type = type.split(';', 2).first if type.index(';')
+      type
+    end
+
+  end # Request::Jsonize
+end # BitBucket