reenhanced_bitbucket_api 0.1.6 → 0.3.0

data/lib/bitbucket_rest_api/request.rb

@@ -1,54 +1,83 @@
 # 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
-  module Request
+  class Request
+    include Connection
 
-    METHODS = [:get, :post, :put, :delete, :patch]
+    HTTP_METHODS = [:get, :post, :put, :delete, :patch]
     METHODS_WITH_BODIES = [ :post, :put, :patch ]
 
-    def get_request(path, params={}, options={})
-      request(:get, path, params, options)
-    end
+    # Return http verb
+    #
+    # @return [Symbol]
+    attr_reader :action
 
-    def patch_request(path, params={}, options={})
-      request(:patch, path, params, options)
-    end
+    # Return url
+    #
+    # @return [String]
+    attr_accessor :path
 
-    def post_request(path, params={}, options={})
-      request(:post, path, params, options)
-    end
+    # Return api this request is associated with
+    #
+    # @return [BitBucket::API]
+    attr_reader :api
 
-    def put_request(path, params={}, options={})
-      request(:put, path, params, options)
+    # Create a new Request
+    #
+    # @return [BitBucket::Request]
+    #
+    # @api public
+    def initialize(action, path, api)
+      @action = action
+      @path   = path
+      @api    = api
     end
 
-    def delete_request(path, params={}, options={})
-      request(:delete, path, params, options)
-    end
-
-    def request(method, path, params, options)
-      if !METHODS.include?(method)
-        raise ArgumentError, "unkown http method: #{method}"
+    # 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
-      # _extract_mime_type(params, options)
 
-      puts "EXECUTED: #{method} - #{path} with #{params} and #{options}" if ENV['DEBUG']
+      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)
 
-      conn = connection(options)
-      path = (conn.path_prefix + path).gsub(/\/\//,'/') if conn.path_prefix != '/'
+      if conn.path_prefix != '/' && self.path.index(conn.path_prefix) != 0
+        self.path = (conn.path_prefix + self.path).gsub(/\/(\/)*/, '/')
+      end
 
-      response = conn.send(method) do |request|
-        case method.to_sym
-        when *(METHODS - METHODS_WITH_BODIES)
-          request.body = params.delete('data') if params.has_key?('data')
-          request.url(path, params)
+      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.path = path
+          request.url(self.path, connection_options[:query] || {})
           request.body = extract_data_from_params(params) unless params.empty?
         end
       end
-      response.body
+      ResponseWrapper.new(response, api)
     end
 
     private
@@ -58,10 +87,5 @@ module BitBucket
       return params
     end
 
-    def _extract_mime_type(params, options) # :nodoc:
-      options['resource']  = params['resource'] ? params.delete('resource') : ''
-      options['mime_type'] = params['resource'] ? params.delete('mime_type') : ''
-    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_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

@@ -3,9 +3,14 @@
 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
@@ -59,82 +64,5 @@ module BitBucket
       !!@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/users.rb

@@ -1,12 +1,10 @@
 # encoding: utf-8
 
 module BitBucket
-  class Users < API
-    extend AutoloadHelper
+  class Client::Users < API
+    @version = '1.0'
 
-    # Load all the modules after initializing Repos to avoid superclass mismatch
-    autoload_all 'bitbucket_rest_api/users',
-                 :Account       => 'account'
+    require_all 'bitbucket_rest_api/users', 'account'
 
 
     # Creates new Users API
@@ -15,9 +13,7 @@ module BitBucket
     end
 
     # Access to Users::Account API
-    def account
-      @account ||= ApiFactory.new 'Users::Account'
-    end
+    namespace :account
 
 
   end # Users

data/lib/bitbucket_rest_api/validations/presence.rb

@@ -2,22 +2,27 @@
 
 module BitBucket
   module Validations
+    # A mixin to help validate presence of non-empty values
     module Presence
 
-      # Ensures that essential arguments are present before request is made
+      # Ensure that esential 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
+      # == Parameters
+      #  Hash/Array of arguments to be checked against nil and empty string
+      #
+      # == Example
+      #  assert_presence_of user: '...', repo: '...'
+      #  assert_presence_of user, repo
+      #
+      def assert_presence_of(*args)
+        hash = args.last.is_a?(::Hash) ? args.pop : {}
 
+        errors = hash.select { |key, val| val.to_s.empty? }
+        raise Github::Error::Validations.new(errors) unless errors.empty?
 
-      # 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?
+        args.each do |arg|
+          raise ArgumentError, "parameter cannot be nil" if arg.nil?
+        end
       end
 
     end # Presence

data/lib/bitbucket_rest_api/validations.rb

@@ -2,13 +2,12 @@
 
 module BitBucket
   module Validations
-    extend AutoloadHelper
 
-    autoload_all 'bitbucket_rest_api/validations',
-                 :Presence => 'presence',
-                 :Token    => 'token',
-                 :Format   => 'format',
-                 :Required => 'required'
+    BitBucket::require_all 'bitbucket_rest_api/validations',
+      'presence',
+      'token',
+      'format',
+      'required'
 
     include Presence
     include Format
@@ -18,6 +17,7 @@ module BitBucket
     VALID_API_KEYS = [
         'page',
         'per_page',
+        'auto_pagination',
         'jsonp_callback'
     ]
 

data/lib/bitbucket_rest_api/version.rb

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