reenhanced_bitbucket_api 0.1.6 → 0.3.0

data/lib/bitbucket_rest_api/client/repos/pull_requests.rb

@@ -0,0 +1,205 @@
+# encoding: utf-8
+
+module BitBucket
+  class Client::Repos::PullRequests < API
+
+    # Load all the modules after initializing Repos to avoid superclass mismatch
+    require_all 'bitbucket_rest_api/client/repos/pull_requests',
+      'comments',
+      'commits',
+      'activity'
+
+    VALID_PULL_REQUEST_PARAM_NAMES = %w[
+      title
+      description
+      source
+      destination
+      reviewers
+      close_source_branch
+    ].freeze
+
+    VALID_PULL_REQUEST_STATE_VALUES = {
+      state: ['OPEN', 'MERGED', 'DECLINED']
+    }
+
+    @version = '2.0'
+
+    # Access to Client::Repos::PullRequests::Comments API
+    namespace :comments
+    namespace :commits
+
+    # List pull requests for a repository
+    #
+    # = Inputs
+    #  <tt>:state</tt> - Optional - State of the pull request (OPEN, MERGED, DECLINED)
+    #
+    def list(*args)
+      args = { user: self.user, repo: self.repo.downcase, state: 'OPEN'}.merge(Hash[*args])
+      #_update_user_repo_params(user_name, repo_name)
+      #_validate_user_repo_params(user, repo) unless user? && repo?
+      params = arguments([args], required: [:user, :repo]) do
+        assert_values VALID_PULL_REQUEST_STATE_VALUES
+      end.params
+
+      # Bitbucket requires the state to be all caps or it returns all
+      params['state'] = params['state'].upcase
+
+      response = get_request("/repositories/#{args[:user]}/#{args[:repo]}/pullrequests", params)
+
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :all :list
+
+    # Get a single pull request
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.repos.pull_requests.find 'user-name', 'repo-name', 'pull-request-id'
+    #
+    def get(user_name, repo_name, pull_request_id, params={ })
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of pull_request_id
+
+      normalize! params
+
+      get_request("/repositories/#{user}/#{repo.downcase}/pullrequests/#{pull_request_id}", params)
+    end
+
+    alias :find :get
+
+    # Create a pull request
+    #
+    # = Inputs
+    #  <tt>:title</tt> - Required string
+    #  <tt>:description</tt> - Optional string
+    #  <tt>:source</tt> - Required hash - The source branch name and/or repository (for example, { develop)
+    #  * <tt>{ "branch": { "name": "REQUIRED branch_name" }, "repository": { "full_name": "owner/repo_slug" } }</tt>
+    #  <tt>:destination</tt> - Optional hash - The destination branch or commit
+    #  * <tt>{ "branch": { "name": "branch_name" }, "commit": { "hash": "name" } }</tt>
+    #  <tt>:reviewers</tt> - Optional array - Users currently reviewiing the pull
+    #  * <tt>[{ "username": "accountname" }]</tt>
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new :user => 'user-name', :repo => 'repo-name'
+    #  bitbucket.repos.pull_requests.create
+    #    "title" => "Fixes a bug",
+    #    "description" => "Fixes not being able to see anything.",
+    #    "source" => { "branch" => { "name" => "bug-fixes" } },
+    #    "destination" => { "branch" => { "name" => "master" } },
+    #    "reviewers" => [ { "username" => "octocat" } ],
+    #    "close_source_branch" => true
+    #
+    def create(user_name, repo_name, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+
+      normalize! params
+      filter! VALID_PULL_REQUEST_PARAM_NAMES , params
+      assert_required_keys(%w[ title source ], params)
+
+      post_request("/repositories/#{user}/#{repo.downcase}/pullrequests/", params)
+    end
+
+    # Edit a pull request
+    #
+    # = Inputs
+    #  <tt>:title</tt> - Required string
+    #  <tt>:description</tt> - Optional string
+    #  <tt>:destination</tt> - Optional hash - The destination branch or commit
+    #  * <tt>{ "branch": { "name": "branch_name" }, "commit": { "hash": "name" } }</tt>
+    #  <tt>:reviewers</tt> - Optional array - Users currently reviewiing the pull
+    #  * <tt>[{ "username": "accountname" }]</tt>
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.repos.pull_requests.update 'user-name', 'repo-name', 'pull-request-id',
+    #    "title" => "Fixes a bug",
+    #    "description" => "Fixes not being able to see anything.",
+    #    "destination" => { "branch" => { "name" => "master" } },
+    #    "reviewers" => [ { "username" => "octocat" } ],
+    #    "close_source_branch" => true
+    #
+    def update(user_name, repo_name, pull_request_id, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of pull_request_id
+
+      # BitBucket will drop any data if it is not included, so we have to check for pre-existing data
+      existing_pull = get(user_name, repo_name, pull_request_id)
+      existing_pull_data = {
+        'title' => existing_pull.title,
+        'description' => existing_pull.description,
+        'destination' => {
+          'branch' => existing_pull.destination.branch
+        },
+        'reviewers' => existing_pull.reviewers,
+        'close_source_branch' => existing_pull.close_source_branch
+      }
+      params = normalize!(existing_pull_data).merge!(normalize!(params))
+
+      filter! VALID_PULL_REQUEST_PARAM_NAMES.reject{|param| param == 'source'}, params
+      assert_required_keys(%w[ title ], params)
+
+      put_request("/repositories/#{user}/#{repo.downcase}/pullrequests/#{pull_request_id}/", params)
+    end
+    alias :edit :update
+
+    # Decline or reject a single pull request
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.repos.pull_requests.reject 'user-name', 'repo-name', 'pull-request-id'
+    #
+    def decline(user_name, repo_name, pull_request_id)
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of pull_request_id
+
+      post_request("/repositories/#{user}/#{repo}/pullrequests/#{pull_request_id}/decline")
+    end
+    alias :reject :decline
+
+    # Give approval on a pull request
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.repos.pull_requests.approve 'user-name', 'repo-name', 'pull-request-id'
+    #
+    def approve(user_name, repo_name, pull_request_id)
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of pull_request_id
+
+      post_request("/repositories/#{user}/#{repo}/pullrequests/#{pull_request_id}/approve")
+    end
+
+    # Get the diff for a pull request
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.repos.pull_requests.diff 'user-name', 'repo-name', 'pull-request-id'
+    #
+    def diff(user_name, repo_name, pull_request_id)
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of pull_request_id
+
+      get_request("/repositories/#{user}/#{repo}/pullrequests/#{pull_request_id}/diff")
+    end
+
+    # Get a log of all activity for a pull request
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.repos.pull_requests.activity 'user-name', 'repo-name'
+    #
+    def activity(user_name, repo_name)
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+
+      get_request("/repositories/#{user}/#{repo}/pullrequests/activity")
+    end
+  end # Repos::PullRequests
+end # BitBucket

data/lib/bitbucket_rest_api/{repos → client/repos}/services.rb

@@ -1,7 +1,8 @@
 # encoding: utf-8
 
 module BitBucket
-  class Repos::Services < API
+  class Client::Repos::Services < API
+    @version = '2.0'
 
     REQUIRED_KEY_PARAM_NAMES = %w[ type ].freeze
 

data/lib/bitbucket_rest_api/{repos → client/repos}/sources.rb

@@ -1,7 +1,8 @@
 # encoding: utf-8
 
 module BitBucket
-  class Repos::Sources < API
+  class Client::Repos::Sources < API
+    @version = '1.0'
 
     REQUIRED_COMMENT_PARAMS = %w[
         body

data/lib/bitbucket_rest_api/{repos.rb → client/repos.rb}

@@ -1,16 +1,17 @@
 # encoding: utf-8
 
 module BitBucket
-  class Repos < API
-    extend AutoloadHelper
+  class Client::Repos < API
 
-    # Load all the modules after initializing Repos to avoid superclass mismatch
-    autoload_all 'bitbucket_rest_api/repos',
-                 :Changesets  => 'changesets',
-                 :Keys        => 'keys',
-                 :Services    => 'services',
-                 :Following   => 'following',
-                 :Sources     => 'sources'
+    require_all 'bitbucket_rest_api/client/repos',
+      'changesets',
+      'keys',
+      'services',
+      'following',
+      'sources',
+      'pull_requests'
+
+    @version = '1.0'
 
     DEFAULT_REPO_OPTIONS = {
         "website"         => "",
@@ -34,35 +35,23 @@ module BitBucket
       scm
     ].freeze
 
-    # Creates new Repositories API
-    def initialize(options = { })
-      super(options)
-    end
-
     # Access to Repos::Commits API
-    def changesets
-      @changesets ||= ApiFactory.new 'Repos::Changesets'
-    end
+    namespace :changesets
 
     # Access to Repos::Keys API
-    def keys
-      @keys ||= ApiFactory.new 'Repos::Keys'
-    end
+    namespace :keys
 
     # Access to Repos::Watchin API
-    def following
-      @following ||= ApiFactory.new 'Repos::Following'
-    end
+    namespace :following
 
     # Access to Repos::Commits API
-    def sources
-      @sources ||= ApiFactory.new 'Repos::Sources'
-    end
+    namespace :sources
 
     # Access to Repos::Services API
-    def services
-      @services ||= ApiFactory.new 'Repos::Services'
-    end
+    namespace :services
+
+    # Access to Repos::PullRequests API
+    namespace :pull_requests
 
     # List branches
     #
@@ -196,17 +185,14 @@ module BitBucket
     #   bitbucket.repos.list :user => 'user-name'
     #   bitbucket.repos.list :user => 'user-name', { |repo| ... }
     def list(*args)
-      params = args.extract_options!
-      normalize! params
-      _merge_user_into_params!(params) unless params.has_key?('user')
-      filter! %w[ user type ], params
-
-      response = #if (user_name = params.delete("user"))
-                 #  get_request("/users/#{user_name}", params)
-                 #else
-                   # For authenticated user
-                   get_request("/user/repositories", params)
-                 #end
+      #_merge_user_into_params!(params) unless params.has_key?('user')
+      arguments(args) do
+        permit %w[ user type ]
+      end
+      params = arguments.params
+
+      response = get_request("/user/repositories", params)
+
       return response unless block_given?
       response.each { |el| yield el }
     end

data/lib/bitbucket_rest_api/{user.rb → client/user.rb}

@@ -1,8 +1,8 @@
 # encoding: utf-8
 
 module BitBucket
-  class User < API
-
+  class Client::User < API
+    @version = '1.0'
 
     DEFAULT_USER_OPTIONS = {
         "first_name"      => "",
@@ -12,11 +12,6 @@ module BitBucket
         # "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

data/lib/bitbucket_rest_api/{users → client/users}/account.rb

@@ -1,7 +1,8 @@
 # encoding: utf-8
 
 module BitBucket
-  class Users::Account < API
+  class Client::Users::Account < API
+    @version = '1.0'
 
     # API about users/account , please refer to 
     # https://confluence.atlassian.com/display/BITBUCKET/account+Resource

data/lib/bitbucket_rest_api/client/users.rb

@@ -0,0 +1,14 @@
+
+# encoding: utf-8
+
+module BitBucket
+  class Client::Users < API
+
+    require_all 'bitbucket_rest_api/client/users', 'account'
+
+    @version = '1.0'
+
+    namespace :account
+
+  end # Client
+end # BitBucket

data/lib/bitbucket_rest_api/client.rb

@@ -3,56 +3,52 @@
 module BitBucket
   class Client < API
 
+    require_all 'bitbucket_rest_api/client',
+      'issues',
+      'repos',
+      'users',
+      'invitations'
+
+    require_all 'bitbucket_rest_api/client/users', 'account'
+
+    namespace :issues
+
+    namespace :pull_requests
+
+    namespace :repos
+    alias :repositories :repos
+
+    # Many of the resources on the users API provide a shortcut for getting
+    # information about the currently authenticated user.
+    namespace :users
+
+    namespace :user
+    alias :user_api :user
+
+    namespace :invitations
+
     # This is a read-only API to the BitBucket events.
     # These events power the various activity streams on the site.
     def events(options = {})
       raise "Unimplemented"
-      #@events ||= ApiFactory.new 'Events', options
-    end
-
-    def issues(options = {})
-      @issues ||= ApiFactory.new 'Issues', options
+      #@events ||= Api::Factory.new 'Events', options
     end
 
     # An API for users to manage their own tokens.
     def oauth(options = {})
       raise "Unimpletmented"
-      #@oauth ||= ApiFactory.new 'Authorizations', options
+      #@oauth ||= Api::Factory.new 'Authorizations', options
     end
     alias :authorizations :oauth
 
     def teams(options = {})
       raise "Unimplemented"
-      #@teams ||= ApiFactory.new 'teams', options
+      #@teams ||= Api::Factory.new 'teams', options
     end
 
-    def pull_requests(options = {})
-      raise "Unimplemented"
-      #@pull_requests ||= ApiFactory.new 'PullRequests', options
-    end
-
-    def repos(options = {})
-      @repos ||= ApiFactory.new 'Repos', options
-    end
-    alias :repositories :repos
-
     def search(options = {})
       raise "Unimplemented"
-      #@search ||= ApiFactory.new 'Search', options
-    end
-
-    # Many of the resources on the users API provide a shortcut for getting
-    # information about the currently authenticated user.
-    def users(options = {})
-      @users ||= ApiFactory.new 'Users', options
-    end
-
-    def user_api(options = {})
-      @user_api ||= ApiFactory.new 'User', options
-    end
-
-    def invitations(options = {})
-      @invitations ||= ApiFactory.new "Invitations", options
+      #@search ||= Api::Factory.new 'Search', options
     end
   end # Client
 end # BitBucket

data/lib/bitbucket_rest_api/configuration.rb

@@ -1,101 +1,58 @@
 # encoding: utf-8
 
+require 'bitbucket_rest_api/api/config'
+
 module BitBucket
-  module Configuration
-
-    VALID_OPTIONS_KEYS         = [
-        :adapter,
-        :client_id,
-        :client_secret,
-        :oauth_token,
-        :oauth_secret,
-        :endpoint,
-        :mime_type,
-        :user_agent,
-        :connection_options,
-        :repo,
-        :user,
-        :login,
-        :password,
-        :basic_auth
-    ].freeze
+  # Stores the configuration
+  class Configuration < API::Config
 
     # Other adapters are :typhoeus, :patron, :em_synchrony, :excon, :test
-    DEFAULT_ADAPTER            = :net_http
+    property :adapter, default: :net_http
 
     # By default, don't set an application key
-    DEFAULT_CLIENT_ID          = nil
+    property :client_id, default: nil
 
     # By default, don't set an application secret
-    DEFAULT_CLIENT_SECRET      = nil
+    property :client_secret, default: nil
 
     # By default, don't set a user oauth access token
-    DEFAULT_OAUTH_TOKEN        = nil
+    property :oauth_token, default: nil
 
     # By default, don't set a user oauth access token secret
-    DEFAULT_OAUTH_SECRET       = nil
+    property :oauth_secret, default: nil
 
     # By default, don't set a user login name
-    DEFAULT_LOGIN              = nil
+    property :login, default: nil
 
     # By default, don't set a user password
-    DEFAULT_PASSWORD           = nil
+    property :password, default: nil
 
     # By default, don't set a user basic authentication
-    DEFAULT_BASIC_AUTH         = nil
+    property :basic_auth, default: nil
 
     # The endpoint used to connect to BitBucket if none is set, in the event that BitBucket is ever available on location
-    DEFAULT_ENDPOINT           = 'https://bitbucket.org/api/1.0'.freeze
+    property :endpoint, default: 'https://bitbucket.org/api/1.0'.freeze
 
     # The value sent in the http header for 'User-Agent' if none is set
-    DEFAULT_USER_AGENT         = "BitBucket Ruby Gem #{BitBucket::VERSION::STRING}".freeze
+    property :user_agent, default: "BitBucket Ruby Gem #{BitBucket::VERSION::STRING}".freeze
 
     # By default the <tt>Accept</tt> header will make a request for <tt>JSON</tt>
-    DEFAULT_MIME_TYPE          = :json
+    property :mime_type, default: :json
 
     # By default uses the Faraday connection options if none is set
-    DEFAULT_CONNECTION_OPTIONS = { }
+    property :connection_options, default: { }
 
     # By default, don't set user name
-    DEFAULT_USER               = nil
+    property :user, default: nil
 
     # By default, don't set repository name
-    DEFAULT_REPO               = nil
-
-    attr_accessor *VALID_OPTIONS_KEYS
-
-    # Convenience method to allow for global setting of configuration options
-    def configure
-      yield self
-    end
-
-    def self.extended(base)
-      base.set_defaults
-    end
-
-    def options
-      options = { }
-      VALID_OPTIONS_KEYS.each { |k| options[k] = send(k) }
-      options
-    end
-
-    def set_defaults
-      self.adapter            = DEFAULT_ADAPTER
-      self.client_id          = DEFAULT_CLIENT_ID
-      self.client_secret      = DEFAULT_CLIENT_SECRET
-      self.oauth_token        = DEFAULT_OAUTH_TOKEN
-      self.oauth_secret       = DEFAULT_OAUTH_SECRET
-      self.endpoint           = DEFAULT_ENDPOINT
-      self.user_agent         = DEFAULT_USER_AGENT
-      self.connection_options = DEFAULT_CONNECTION_OPTIONS
-      self.mime_type          = DEFAULT_MIME_TYPE
-      self.user               = DEFAULT_USER
-      self.repo               = DEFAULT_REPO
-      self.login              = DEFAULT_LOGIN
-      self.password           = DEFAULT_PASSWORD
-      self.basic_auth         = DEFAULT_BASIC_AUTH
-      self
-    end
+    property :repo, default: nil
+
+    # By default, don't auto-paginate results
+    property :auto_pagination, default: false
+
+    # Add Faraday::RackBuilder to overwrite middleware
+    property :stack
 
   end # Configuration
 end # BitBucket

data/lib/bitbucket_rest_api/connection.rb

@@ -1,16 +1,5 @@
 # encoding: utf-8
 
-require 'faraday'
-require 'faraday_middleware'
-require 'bitbucket_rest_api/response'
-require 'bitbucket_rest_api/response/mashify'
-require 'bitbucket_rest_api/response/jsonize'
-require 'bitbucket_rest_api/response/helpers'
-require 'bitbucket_rest_api/response/raise_error'
-require 'bitbucket_rest_api/request/oauth'
-require 'bitbucket_rest_api/request/basic_auth'
-require 'bitbucket_rest_api/request/jsonize'
-
 module BitBucket
   module Connection
     extend self
@@ -21,46 +10,21 @@ module BitBucket
         :url,
         :params,
         :request,
-        :ssl
+        :ssl,
+        :builder,
+        :api
     ].freeze
 
     def default_options(options={})
       {
           :headers => {
-              USER_AGENT       => user_agent
+              USER_AGENT       => options[:user_agent]
           },
           :ssl => { :verify => false },
           :url => options.fetch(:endpoint) { BitBucket.endpoint }
       }.merge(options)
     end
 
-    # Default middleware stack that uses default adapter as specified at
-    # configuration stage.
-    #
-    def default_middleware(options={})
-      Proc.new do |builder|
-        #builder.use BitBucket::Request::Jsonize
-        builder.use Faraday::Request::Multipart
-        builder.use Faraday::Request::UrlEncoded
-        builder.use FaradayMiddleware::OAuth, {:consumer_key => client_id, :consumer_secret => client_secret, :token => oauth_token, :token_secret => oauth_secret} if client_id? and client_secret?
-        builder.use BitBucket::Request::BasicAuth, authentication if 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 adapter
-      end
-    end
-
-    @connection = nil
-
-    @stack = nil
-
     def clear_cache
       @connection = nil
     end
@@ -72,24 +36,25 @@ module BitBucket
     # Exposes middleware builder to facilitate custom stacks and easy
     # addition of new extensions such as cache adapter.
     #
-    def stack(options={}, &block)
+    def stack(options={})
       @stack ||= begin
-        if block_given?
-          Faraday::RackBuilder.new(&block)
-        else
-          Faraday::RackBuilder.new(&default_middleware(options))
-        end
+        builder_class = defined?(Faraday::RackBuilder) ? Faraday::RackBuilder : Faraday::Builder
+        builder_class.new(&BitBucket.default_middleware(options))
       end
     end
 
     # Returns a Fraday::Connection object
     #
-    def connection(options = {})
-      conn_options = default_options(options)
+    def connection(api, options = {})
+      connection_options = default_options(options)
       clear_cache unless options.empty?
-      puts "OPTIONS:#{conn_options.inspect}" if ENV['DEBUG']
+      builder = api.stack ? api.stack : stack(options.merge!(api: api))
+      connection_options.merge!(builder: builder)
+      connection_options.keep_if {|key, value| ALLOWED_OPTIONS.include?(key) }
+
+      puts "OPTIONS:#{connection_options.inspect}" if ENV['DEBUG']
 
-      @connection ||= Faraday.new(conn_options.merge(:builder => stack(options)))
+      @connection ||= Faraday.new(connection_options)
     end
 
   end # Connection