bitbucket_rest_api 0.1.0

data/lib/bitbucket_rest_api/repos.rb

@@ -0,0 +1,213 @@
+# encoding: utf-8
+
+module BitBucket
+  class Repos < API
+    extend AutoloadHelper
+
+    # Load all the modules after initializing Repos to avoid superclass mismatch
+    autoload_all 'bitbucket_rest_api/repos',
+                 :Changesets       => 'changesets',
+                 :Keys          => 'keys',
+                 :Following      => 'following'
+
+    DEFAULT_REPO_OPTIONS = {
+        "homepage"        => "https://bitbucket.org",
+        "is_private"      => false,
+        "has_issues"      => false,
+        "has_wiki"        => false,
+        "scm"             => "git",
+        "no_public_forks" => false
+    }.freeze
+
+    VALID_REPO_OPTIONS = %w[
+      name
+      description
+      website
+      is_private
+      has_issues
+      has_wiki
+      no_public_forks
+      language
+      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
+
+    # Access to Repos::Keys API
+    def keys
+      @keys ||= ApiFactory.new 'Repos::Keys'
+    end
+
+    # Access to Repos::Watchin API
+    def following
+      @following ||= ApiFactory.new 'Repos::Following'
+    end
+
+    # List branches
+    #
+    # = Examples
+    #
+    #   bitbucket = BitBucket.new
+    #   bibucket.repos.branches 'user-name', 'repo-name'
+    #
+    #   repos = BitBucket::Repos.new
+    #   repos.branches 'user-name', 'repo-name'
+    #
+    def branches(user_name, repo_name, params={ })
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless (user? && repo?)
+      normalize! params
+
+      response = get_request("/repositories/#{user}/#{repo}/branches/", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+
+    alias :list_branches :branches
+
+    # Create a new repository for the authenticated user.
+    #
+    # = Parameters
+    #  <tt>:name</tt> - Required string
+    #  <tt>:description</tt> - Optional string
+    #  <tt>:website</tt> - Optional string
+    #  <tt>:is_private</tt> - Optional boolean - <tt>true</tt> to create a private repository, <tt>false</tt> to create a public one.
+    #  <tt>:has_issues</tt> - Optional boolean - <tt>true</tt> to enable issues for this repository, <tt>false</tt> to disable them
+    #  <tt>:has_wiki</tt> - Optional boolean - <tt>true</tt> to enable the wiki for this repository, <tt>false</tt> to disable it. Default is <tt>true</tt>
+    #  <tt>:owner</tt> Optional string - The team in which this repository will be created
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.repos.create "name" => 'repo-name'
+    #    "description": "This is your first repo",
+    #    "website": "https://bitbucket.com",
+    #    "is_private": false,
+    #    "has_issues": true,
+    #    "has_wiki": true
+    #
+    # Create a new repository in this team. The authenticated user
+    # must be a member of this team
+    #
+    # Examples:
+    #   bitbucket = BitBucket.new :oauth_token => '...', :oauth_secret => '...'
+    #   bitbucket.repos.create :name => 'repo-name', :owner => 'team-name'
+    #
+    def create(*args)
+      params = args.extract_options!
+      normalize! params
+      filter! VALID_REPO_OPTIONS + %w[ org ], params
+      assert_required_keys(%w[ name ], params)
+
+      # Requires authenticated user
+      post_request("/repositories/", DEFAULT_REPO_OPTIONS.merge(params))
+    end
+
+    # Edit a repository
+    #
+    # = Parameters
+    # * <tt>:name</tt> Required string
+    # * <tt>:description</tt>   Optional string
+    # * <tt>:homepage</tt>      Optional string
+    #  <tt>:private</tt> - Optional boolean - <tt>false</tt> to create public reps, <tt>false</tt> to create a private one
+    # * <tt>:has_issues</tt>    Optional boolean - <tt>true</tt> to enable issues for this repository, <tt>false</tt> to disable them
+    # * <tt>:has_wiki</tt>      Optional boolean - <tt>true</tt> to enable the wiki for this repository, <tt>false</tt> to disable it. Default is <tt>true</tt>
+    # * <tt>:has_downloads</tt> Optional boolean - <tt>true</tt> to enable downloads for this repository
+    #
+    # = Examples
+    #
+    #  bitbucket = BitBucket.new
+    #  bitbucket.repos.edit 'user-name', 'repo-name',
+    #    :name => 'hello-world',
+    #    :description => 'This is your first repo',
+    #    :homepage => "https://bitbucket.com",
+    #    :public => true, :has_issues => true
+    #
+    def edit(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_REPO_OPTIONS, params
+      assert_required_keys(%w[ name ], params)
+
+      patch_request("/repositories/#{user}/#{repo}/", DEFAULT_REPO_OPTIONS.merge(params))
+    end
+
+    # Get a repository
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.repos.get 'user-name', 'repo-name'
+    #
+    def get(user_name, repo_name, params={ })
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      normalize! params
+
+      get_request("/repositories/#{user}/#{repo}", params)
+    end
+
+    alias :find :get
+
+    # List repositories for the authenticated user
+    #
+    # = Examples
+    #   bitbucket = BitBucket.new :oauth_token => '...', :oauth_secret => '...'
+    #   bitbucket.repos.list
+    #   bitbucket.repos.list { |repo| ... }
+    #
+    # List public repositories for the specified user.
+    #
+    # = Examples
+    #   bitbucket = BitBucket.new
+    #   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
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+
+    alias :all :list
+
+    # List tags
+    #
+    # = Examples
+    #   bitbucket = BitBucket.new
+    #   bitbucket.repos.tags 'user-name', 'repo-name'
+    #   bitbucket.repos.tags 'user-name', 'repo-name' { |tag| ... }
+    #
+    def tags(user_name, repo_name, params={ })
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      normalize! params
+
+      response = get_request("/repositories/#{user}/#{repo}/tags/", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+
+    alias :list_tags :tags
+    alias :repo_tags :tags
+    alias :repository_tags :tags
+
+  end # Repos
+end # BitBucket

data/lib/bitbucket_rest_api/request/basic_auth.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'base64'
+
+module BitBucket
+  module Request
+    class BasicAuth < Faraday::Middleware
+      dependency 'base64'
+
+      def call(env)
+        env[:request_headers].merge!('Authorization' => "Basic #{@auth}\"")
+
+        @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,46 @@
+# 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)
+      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

data/lib/bitbucket_rest_api/request/oauth.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module BitBucket
+  module Request
+    class OAuth < Faraday::Middleware
+      include BitBucket::Utils::Url
+
+      ACCESS_TOKEN = 'access_token'.freeze
+      AUTH_HEADER  = 'Authorization'.freeze
+
+      dependency '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?)
+          env[:url].query = build_query params
+
+          access_token = ::OAuth::AccessToken.new(@consumer, @token, @secret)
+          oauth_params = {:consumer => @consumer, :token => access_token}
+          req = Net::HTTP::Get.new env[:url].to_s
+          oauth_helper = ::OAuth::Client::Helper.new(req, oauth_params.merge(:request_uri => env[:url].to_s))
+          env[:request_headers].merge!(AUTH_HEADER => oauth_helper.header)
+        end
+
+        @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.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+module BitBucket
+  # Defines HTTP verbs
+  module Request
+
+    METHODS = [:get, :post, :put, :delete, :patch]
+    METHODS_WITH_BODIES = [ :post, :put, :patch ]
+
+    def get_request(path, params={}, options={})
+      request(:get, path, params, options)
+    end
+
+    def patch_request(path, params={}, options={})
+      request(:patch, path, params, options)
+    end
+
+    def post_request(path, params={}, options={})
+      request(:post, path, params, options)
+    end
+
+    def put_request(path, params={}, options={})
+      request(:put, path, params, options)
+    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}"
+      end
+      # _extract_mime_type(params, options)
+
+      puts "EXECUTED: #{method} - #{path} with #{params} and #{options}" if ENV['DEBUG']
+
+      conn = connection(options)
+      path = (conn.path_prefix + path).gsub(/\/\//,'/') if conn.path_prefix != '/'
+
+      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)
+        when *METHODS_WITH_BODIES
+          request.path = path
+          request.body = extract_data_from_params(params) unless params.empty?
+        end
+      end
+      response.body
+    end
+
+    private
+
+    def extract_data_from_params(params) # :nodoc:
+      return params['data'] if params.has_key?('data') and !params['data'].nil?
+      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/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