reenhanced_bitbucket_api 0.1.6

data/lib/bitbucket_rest_api/response/helpers.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module BitBucket
+  class Response::Helpers < Response
+
+    def on_complete(env)
+      env[:body].class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        include BitBucket::Result
+
+        def env
+          @env
+        end
+
+      RUBY_EVAL
+      env[:body].instance_eval { @env = env }
+    end
+
+  end # Response::Helpers
+end # BitBucket

data/lib/bitbucket_rest_api/response/jsonize.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module BitBucket
+  class Response::Jsonize < Response
+    dependency 'multi_json'
+
+    define_parser do |body|
+      if MultiJson.respond_to?(:load)
+        MultiJson.load body
+      else
+        MultiJson.decode body
+      end
+    end
+
+    def parse(body)
+      case body
+      when ''
+        nil
+      when 'true'
+        true
+      when 'false'
+        false
+      else
+        self.class.parser.call body
+      end
+    end
+  end # Response::Jsonize
+end # BitBucket

data/lib/bitbucket_rest_api/response/mashify.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module BitBucket
+  class Response::Mashify < Response
+    dependency 'hashie/mash'
+
+    define_parser do |body|
+      ::Hashie::Mash.new body
+    end
+
+    def parse(body)
+      case body
+      when Hash
+        self.class.parser.call body
+      when Array
+        body.map { |item| item.is_a?(Hash) ? self.class.parser.call(item) : item }
+      else
+        body
+      end
+    end
+  end # Response::Mashify
+end # BitBucket

data/lib/bitbucket_rest_api/response/raise_error.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'bitbucket_rest_api/error'
+
+module BitBucket
+  class Response::RaiseError < Faraday::Response::Middleware
+
+    def on_complete(env)
+      case env[:status].to_i
+      when 400
+        raise BitBucket::Error::BadRequest.new(env)
+      when 401
+        raise BitBucket::Error::Unauthorized.new(env)
+      when 403
+        raise BitBucket::Error::Forbidden.new(env)
+      when 404
+        raise BitBucket::Error::NotFound.new(env)
+      when 422
+        raise BitBucket::Error::UnprocessableEntity.new(env)
+      when 500
+        raise BitBucket::Error::InternalServerError.new(env)
+      when 503
+        raise BitBucket::Error::ServiceUnavailable.new(env)
+      when 400...600
+        raise BitBucket::Error::ServiceError.new(env)
+      end
+    end
+
+  end # Response::RaiseError
+end # BitBucket

data/lib/bitbucket_rest_api/response/xmlize.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module BitBucket
+  class Response::Xmlize < Response
+    dependency 'nokogiri'
+
+    define_parser do |body|
+      ::Nokogiri::XML body
+    end
+
+    def parse(body)
+      case body
+      when ''
+        nil
+      when 'true'
+        true
+      when 'false'
+        false
+      else
+        self.class.parser.call body
+      end
+    end
+  end # Response::Xmlize
+end # BitBucket

data/lib/bitbucket_rest_api/response.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module BitBucket
+  # Contains methods and attributes that act on the response returned from the
+  # request
+  class Response < Faraday::Response::Middleware
+    CONTENT_TYPE = 'Content-Type'.freeze
+
+    class << self
+      attr_accessor :parser
+    end
+
+    def self.define_parser(&block)
+      @parser = block
+    end
+
+    def response_type(env)
+      env[:response_headers][CONTENT_TYPE].to_s
+    end
+
+    def parse_response?(env)
+      env[:body].respond_to? :to_str
+    end
+
+  end # Response
+end # BitBucket

data/lib/bitbucket_rest_api/result.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+
+module BitBucket
+  module Result
+    include BitBucket::Constants
+
+    # TODO Add result counts method to check total items looking at result links
+
+    def ratelimit_limit
+      loaded? ? @env[:response_headers][RATELIMIT_LIMIT] : nil
+    end
+
+    def ratelimit_remaining
+      loaded? ? @env[:response_headers][RATELIMIT_REMAINING] : nil
+    end
+
+    def cache_control
+      loaded? ? @env[:response_headers][CACHE_CONTROL] : nil
+    end
+
+    def content_type
+      loaded? ? @env[:response_headers][CONTENT_TYPE] : nil
+    end
+
+    def content_length
+      loaded? ? @env[:response_headers][CONTENT_LENGTH] : nil
+    end
+
+    def etag
+      loaded? ? @env[:response_headers][ETAG] : nil
+    end
+
+    def date
+      loaded? ? @env[:response_headers][DATE] : nil
+    end
+
+    def location
+      loaded? ? @env[:response_headers][LOCATION] : nil
+    end
+
+    def server
+      loaded? ? @env[:response_headers][SERVER] : nil
+    end
+
+    def status
+      loaded? ? @env[:status] : nil
+    end
+
+    def success?
+      (200..299).include? status
+    end
+
+    # Returns raw body
+    def body
+      loaded? ? @env[:body] : nil
+    end
+
+    def loaded?
+      !!@env
+    end
+
+    # Return page links
+    def links
+      @@links = BitBucket::PageLinks.new(@env[:response_headers])
+    end
+
+    # Iterator like each for response pages. If there are no pages to
+    # iterate over this method will return nothing.
+    def each_page
+      yield self.body
+      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
+      self.body
+    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
+      self.body
+    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
+      self.body
+    end
+    alias :previous_page :prev_page
+
+    # Retrives the result of the last page. Returns <tt>nil</tt> if there is
+    # no last page - either because you are already on the last page,
+    # there is only one page or there are no pages at all in the result.
+    def last_page
+      last_request = page_iterator.last
+      self.instance_eval { @env = last_request.env } if last_request
+      self.body
+    end
+
+    # 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
+      self.body
+    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
+
+    # Repopulates objects for new values
+    def reset
+      nil
+    end
+
+    private
+
+    # Internally used page iterator
+    def page_iterator # :nodoc:
+      @@page_iterator = BitBucket::PageIterator.new(@env)
+    end
+
+  end # Result
+end # BitBucket

data/lib/bitbucket_rest_api/user.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+module BitBucket
+  class User < API
+
+
+    DEFAULT_USER_OPTIONS = {
+        "first_name"      => "",
+        "last_name"       => "",
+        "avatar"          => ""
+        # TODO: can this filed be modified?
+        # "resource_uri"    => ""
+    }.freeze
+
+    # Creates new User API
+    def initialize(options = { })
+      super(options)
+    end
+
+    # Gets the basic information associated with an account and
+    # a list of all of the repositories owned by the user.
+    # See https://confluence.atlassian.com/display/BITBUCKET/user+Endpoint#userEndpoint-GETauserprofile
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.user_api.profile
+    #
+    def profile
+      get_request("/user")
+    end
+
+
+    # Update a user
+
+    # = Parameters
+    # * <tt>:first_name</tt>    Optional string
+    # * <tt>:last_name</tt>     Optional string
+    # * <tt>:avatar</tt>        Optional string
+    # * <tt>:resource_uri</tt>  Optional string
+    #
+    # = Examples
+    #
+    #  bitbucket = BitBucket.new
+    #  bitbucket.user_api.update :first_name => 'first-name', :last_name => 'last-name'
+    #
+
+    def update( params={ })
+      normalize! params
+      filter! DEFAULT_USER_OPTIONS, params
+
+      put_request("/user", DEFAULT_USER_OPTIONS.merge(params))
+
+    end
+
+
+    # GET a list of user privileges
+    def privileges
+      get_request("/user/privileges")
+    end
+
+
+
+    # GET a list of repositories an account follows
+    # Gets the details of the repositories that the individual or team account follows.
+    # This call returns the full data about the repositories including
+    # if the repository is a fork of another repository.
+    # An account always "follows" its own repositories.
+    def follows
+      get_request("/user/follows")
+    end
+
+
+    # GET a list of repositories visible to an account
+    # Gets the details of the repositories that the user owns
+    # or has at least read access to.
+    # Use this if you're looking for a full list of all of the repositories associated with a user.
+    def repositories
+      get_request("/user/repositories")
+    end
+
+    alias :repos :repositories
+
+
+
+    # GET a list of repositories the account is following
+    # Gets a list of the repositories the account follows.
+    # This is the same list that appears on the Following tab on your account dashboard.
+    def overview
+      get_request("/user/repositories/overview")
+    end
+
+
+
+    # GET the list of repositories on the dashboard
+    # Gets the repositories list from the account's dashboard.
+    def dashboard
+      get_request("/user/repositories/dashboard")
+    end
+
+  end # User
+end # BitBucket

data/lib/bitbucket_rest_api/users/account.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module BitBucket
+  class Users::Account < API
+
+    # API about users/account , please refer to 
+    # https://confluence.atlassian.com/display/BITBUCKET/account+Resource
+    #  
+
+
+    # GET the account profile
+    # 
+    def profile(accountname)
+      response = get_request("/users/#{accountname}")
+    end
+
+    # GET the account plan
+    def plan(accountname)
+      response = get_request("/users/#{accountname}/plan")
+    end
+
+    # GET the emails
+    def emails(accountname)
+      response = get_request("/users/#{accountname}/emails")
+    end
+
+    # GET the followers
+    def followers(accountname)
+      response = get_request("/users/#{accountname}/followers")
+    end
+
+    # GET the events
+    def events(accountname)
+      response = get_request("/users/#{accountname}/events")
+    end
+
+    #GET the keys
+    def keys(accountname)
+      response = get_request("/users/#{accountname}/ssh-keys")
+    end
+
+    #POST a new key
+    # params should be in format {key: "", label:""}
+    def new_key(accountname, params)
+      response = post_request("/users/#{accountname}/ssh-keys/", params)
+    end
+
+    #DELETE a key
+    def delete_key(accountname, key_id)
+      response = delete_request("/users/#{accountname}/ssh-keys/#{key_id}")
+    end
+  end # Users::Account
+end # BitBucket

data/lib/bitbucket_rest_api/users.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module BitBucket
+  class Users < API
+    extend AutoloadHelper
+
+    # Load all the modules after initializing Repos to avoid superclass mismatch
+    autoload_all 'bitbucket_rest_api/users',
+                 :Account       => 'account'
+
+
+    # Creates new Users API
+    def initialize(options = { })
+      super(options)
+    end
+
+    # Access to Users::Account API
+    def account
+      @account ||= ApiFactory.new 'Users::Account'
+    end
+
+
+  end # Users
+end # BitBucket

data/lib/bitbucket_rest_api/utils/url.rb

@@ -0,0 +1,56 @@
+require 'cgi'
+
+module BitBucket
+  module Utils
+    module Url
+      extend self
+
+      DEFAULT_QUERY_SEP = /[&;] */n
+
+      KEY_VALUE_SEP = '='.freeze
+
+      def escape(s) CGI.escape s.to_s end
+
+      def unescape(s) CGI.unescape s.to_s end
+
+      def build_query(params)
+        params.map { |k, v|
+          if v.class == Array
+            build_query(v.map { |x| [k, x] })
+          else
+            v.nil? ? escape(k) : "#{escape(k)}=#{escape(v)}"
+          end
+        }.join("&")
+      end
+
+      def parse_query(query_string)
+        return '' if query_string.nil? || query_string.empty?
+        params = {}
+
+        query_string.split(DEFAULT_QUERY_SEP).each do |part|
+          k, v = part.split(KEY_VALUE_SEP, 2).map { |el| unescape(el) }
+
+          if cur = params[k]
+            if cur.class == Array
+              params[k] << v
+            else
+              params[k] = [cur, v]
+            end
+          else
+            params[k] = v
+          end
+        end
+        params
+      end
+
+      def parse_query_for_param(query_string, name)
+        parse_query(query_string).each do |key, val|
+          return val.first if (name == key) && val.is_a?(Array)
+          return val if (name == key)
+        end
+        return nil
+      end
+
+    end # Url
+  end # Utils
+end # BitBucket

data/lib/bitbucket_rest_api/validations/format.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module BitBucket
+  module Validations
+    module Format
+
+      # Ensures that value for a given key is of the correct form whether
+      # matching regular expression or set of predefined values.
+      #
+      def assert_valid_values(permitted, params)
+        params.each do |k, v|
+          next unless permitted.keys.include?(k)
+          if permitted[k].is_a?(Array) && !permitted[k].include?(params[k])
+            raise BitBucket::Error::UnknownValue.new(k,v, permitted[k].join(', '))
+
+          elsif permitted[k].is_a?(Regexp) && !(permitted[k] =~ params[k])
+            raise BitBucket::Error::UnknownValue.new(k,v, permitted[k])
+          end
+        end
+      end
+
+    end # Format
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/validations/presence.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module BitBucket
+  module Validations
+    module Presence
+
+      # Ensures that essential arguments are present before request is made
+      #
+      def _validate_presence_of(*params)
+        params.each do |param|
+          raise ArgumentError, "parameter cannot be nil" if param.nil?
+        end
+      end
+
+
+      # Check if user or repository parameters are passed
+      #
+      def _validate_user_repo_params(user_name, repo_name)
+        raise ArgumentError, "[user] parameter cannot be nil" if user_name.nil?
+        raise ArgumentError, "[repo] parameter cannot be nil" if repo_name.nil?
+      end
+
+    end # Presence
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/validations/required.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module BitBucket
+  module Validations
+    module Required
+
+      # Validate all keys present in a provided hash against required set,
+      # on mismatch raise BitBucket::Error::RequiredParams
+      # Note that keys need to be in the same format i.e. symbols or strings,
+      # otherwise the comparison will fail.
+      #
+      def assert_required_keys(required, provided)
+        result = required.all? do |key|
+          provided.has_deep_key? key
+        end
+        if !result
+          raise BitBucket::Error::RequiredParams.new(provided, required)
+        end
+        result
+      end
+
+    end # Required
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/validations/token.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+# TODO: Set token required calls
+
+module BitBucket
+  module Validations
+    module Token
+
+      TOKEN_REQUIRED = [
+          'get /user',
+          'get /user/emails',
+          'get /user/followers',
+          'get /user/following',
+          'get /user/keys',
+          'get /user/repos',
+          'patch /user',
+          'post /user/emails',
+          'post /user/keys',
+          'post /user/repos'
+      ]
+
+      TOKEN_REQUIRED_REGEXP = [
+          /repos\/.*\/.*\/comments/,
+      ]
+
+      # Ensures that required authentication token is present before
+      # request is sent.
+      #
+      def validates_token_for(method, path)
+        return true unless TOKEN_REQUIRED.grep("#{method} #{path}").empty?
+
+        token_required = false
+        TOKEN_REQUIRED_REGEXP.each do |regex|
+          if "#{method} #{path}" =~ regex
+            token_required = true
+          end
+        end
+        return token_required
+      end
+
+    end # Token
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/validations.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module BitBucket
+  module Validations
+    extend AutoloadHelper
+
+    autoload_all 'bitbucket_rest_api/validations',
+                 :Presence => 'presence',
+                 :Token    => 'token',
+                 :Format   => 'format',
+                 :Required => 'required'
+
+    include Presence
+    include Format
+    include Token
+    include Required
+
+    VALID_API_KEYS = [
+        'page',
+        'per_page',
+        'jsonp_callback'
+    ]
+
+  end # Validation
+end # BitBucket

data/lib/bitbucket_rest_api/version.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module BitBucket
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 6
+
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+end # BitBucket