codenamev_bitbucket_api 0.4.0

data/lib/bitbucket_rest_api/request/oauth.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module BitBucket
+  class Request
+    class OAuth < Faraday::Middleware
+      include BitBucket::Utils::Url
+
+      AUTH_HEADER  = 'Authorization'.freeze
+
+      dependency 'simple_oauth'
+
+      def call(env)
+        # Extract parameters from the query
+        params = {  }.update query_params(env[:url])
+
+        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
+
+
+
+        @app.call env
+      end
+
+      def initialize(app, *args)
+        super app
+        @app = app
+        @consumer = args.shift
+        @token = args.shift
+        @secret = args.shift
+      end
+
+      def query_params(url)
+        if url.query.nil? or url.query.empty?
+          {}
+        else
+          parse_query url.query
+        end
+      end
+    end # OAuth
+  end # Request
+end # BitBucket

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

data/lib/bitbucket_rest_api/request.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+require 'bitbucket_rest_api/request/oauth'
+require 'bitbucket_rest_api/request/basic_auth'
+require 'bitbucket_rest_api/request/jsonize'
+
+require 'bitbucket_rest_api/connection'
+
+module BitBucket
+  # Defines HTTP verbs
+  class Request
+    include Connection
+
+    HTTP_METHODS = [:get, :post, :put, :delete, :patch]
+    METHODS_WITH_BODIES = [ :post, :put, :patch ]
+
+    # Return http verb
+    #
+    # @return [Symbol]
+    attr_reader :action
+
+    # Return url
+    #
+    # @return [String]
+    attr_accessor :path
+
+    # Return api this request is associated with
+    #
+    # @return [BitBucket::API]
+    attr_reader :api
+
+    # Create a new Request
+    #
+    # @return [BitBucket::Request]
+    #
+    # @api public
+    def initialize(action, path, api)
+      @action = action
+      @path   = path
+      @api    = api
+    end
+
+    # Performs a request
+    #
+    # @param [Symbol] method - The Symbol the HTTP verb
+    # @param [String] path   - String relative URL to access
+    # @param [Hash] params   - Hash to configure the request API
+    #
+    # @return [BitBucket::ResponseWrapper]
+    #
+    # @api private
+    def call(current_options, params)
+      unless HTTP_METHODS.include?(action)
+        raise ArgumentError, "unknown http method: #{method}"
+      end
+
+      puts "EXECUTED: #{action} - #{path} with PARAMS: #{params}" if ENV['DEBUG']
+
+      request_options    = params.options
+      connection_options = current_options.merge(request_options)
+      conn               = connection(api, connection_options)
+
+      if conn.path_prefix != '/' && self.path.index(conn.path_prefix) != 0
+        self.path = (conn.path_prefix + self.path).gsub(/\/(\/)*/, '/')
+      end
+
+      response = conn.send(action) do |request|
+        case action.to_sym
+        when *(HTTP_METHODS - METHODS_WITH_BODIES)
+          request.body = params.data if params.has_key?('data')
+          if params.has_key?('encoder')
+            request.params.params_encoder(params.encoder)
+          end
+          request.url(self.path, params.to_hash)
+        when *METHODS_WITH_BODIES
+          request.url(self.path, connection_options[:query] || {})
+          request.body = extract_data_from_params(params) unless params.empty?
+        end
+      end
+      ResponseWrapper.new(response, api)
+    end
+
+    private
+
+    def extract_data_from_params(params) # :nodoc:
+      return params['data'] if params.has_key?('data') and !params['data'].nil?
+      return params
+    end
+
+  end # Request
+end # BitBucket

data/lib/bitbucket_rest_api/response/header.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module BitBucket
+  class Response
+
+    # Represents http response header
+    class Header < Struct.new(:env)
+      include BitBucket::Constants
+
+      SUCCESSFUL_STATUSES = 200..299
+
+      def loaded?
+        !!env
+      end
+
+      # Requests are limited to API v3 to 5000 per hour.
+      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?
+        SUCCESSFUL_STATUSES.include? status
+      end
+
+      # Returns raw body
+      def body
+        loaded? ? env[:body] : nil
+      end
+
+    end # Header
+  end # Response
+end # BitBucket

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/response_wrapper.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+
+module BitBucket
+
+  # A class responsible for proxing to faraday response
+  class ResponseWrapper
+    extend Forwardable
+    include Pagination
+    include Enumerable
+
+    attr_reader :response
+
+    attr_reader :current_api
+
+    attr_reader :env
+
+    def_delegators :body, :empty?, :size, :include?, :length, :to_a, :first, :flatten, :include?, :keys, :[]
+
+    def initialize(response, current_api)
+      @response    = response
+      @current_api = current_api
+      @env         = response.env
+    end
+
+    # Overwrite methods to hash keys
+    #
+    ['id', 'type', 'fork'].each do |method_name|
+      define_method(method_name) do
+        self.body.fetch(method_name.to_s)
+      end
+    end
+
+    # Request url
+    #
+    def url
+      response.env[:url].to_s
+    end
+
+    def body=(value)
+      @body = value
+      @env[:body] = value
+    end
+
+    # Response raw body
+    #
+    def body
+      @body ? @body : response.body
+    end
+
+    # Response status
+    #
+    def status
+      response.status
+    end
+
+    def success?
+      response.success?
+    end
+
+    def redirect?
+      status.to_i >= 300 && status.to_i < 400
+    end
+
+    def client_error?
+      status.to_i >= 400 && status.to_i < 500
+    end
+
+    def server_error?
+      status.to_i >= 500 && status.to_i < 600
+    end
+
+    # Return response headers
+    #
+    def headers
+      BitBucket::Response::Header.new(env)
+    end
+
+    # Lookup an attribute from the body if hash, otherwise behave like array index.
+    # Convert any key to string before calling.
+    #
+    def [](key)
+      if self.body.is_a?(Array)
+        self.body[key]
+      else
+        self.body.send(:"#{key}")
+      end
+    end
+
+    # Return response body as string
+    #
+    def to_s
+      body.to_s
+    end
+
+    # Convert the ResponseWrapper into a Hash
+    #
+    def to_hash
+      body.to_hash
+    end
+
+    # Convert the ResponseWrapper into an Array
+    #
+    def to_ary
+      body.to_ary
+    end
+
+    # Iterate over each resource inside the body
+    #
+    def each
+      body_parts = self.body.respond_to?(:each) ? self.body : [self.body]
+      return body_parts.to_enum unless block_given?
+      body_parts.each { |part| yield(part) }
+    end
+
+    # Check if body has an attribute
+    #
+    def has_key?(key)
+      self.body.is_a?(Hash) && self.body.has_key?(key)
+    end
+
+    # Coerce any method calls for body attributes
+    #
+    def method_missing(method_name, *args, &block)
+      if self.has_key?(method_name.to_s)
+        self.[](method_name, &block)
+      else
+        super
+      end
+    end
+
+    # Check if method is defined on the body
+    #
+    def respond_to?(method_name)
+      if self.has_key?(method_name.to_s)
+        true
+      else
+        super
+      end
+    end
+
+    # Print only response body
+    #
+    def inspect
+      "#<#{self.class.name} @body=\"#{self.body}\">"
+    end
+
+    # Compare the wrapper with other wrapper for equality
+    #
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      return false unless (other.respond_to?(:env) && other.respond_to?(:body))
+      self.env == other.env && self.body == other.body
+    end
+    alias eql? ==
+
+  end # ResponseWrapper
+end # BitBucket

data/lib/bitbucket_rest_api/result.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module BitBucket
+  module Result
+    include BitBucket::Constants
+    include Pagination
+
+    # TODO Add result counts method to check total items looking at result links
+
+    def paginated?
+      loaded? ? !@env[:body][PARAM_PAGE].nil? : false
+    end
+
+    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
+
+  end # Result
+end # BitBucket

data/lib/bitbucket_rest_api/users.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module BitBucket
+  class Client::Users < API
+    @version = '1.0'
+
+    require_all 'bitbucket_rest_api/users', 'account'
+
+
+    # Creates new Users API
+    def initialize(options = { })
+      super(options)
+    end
+
+    # Access to Users::Account API
+    namespace :account
+
+
+  end # Users
+end # BitBucket