codenamev_bitbucket_api 0.4.0

data/lib/bitbucket_rest_api/api/config.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+require 'bitbucket_rest_api/api/config/property'
+require 'bitbucket_rest_api/api/config/property_set'
+
+module BitBucket
+
+  class API
+    # A base class for constructing api configuration
+    class Config
+
+      # Defines a property on an object's class or instance
+      #
+      # @example
+      #   class Configuration < Api::Config
+      #     property :adapter, default: :net_http
+      #     property :user, required: true
+      #   end
+      #
+      # @param [Symbol] name
+      #   the name of a property
+      #
+      # @param [#to_hash] options
+      #   the extra options
+      #
+      # @return [self]
+      #
+      # @api public
+      def self.property(name, options = {})
+        self.property_set << Property.new(name, options)
+        update_subclasses(name, options)
+        self
+      end
+
+      def self.update_subclasses(name, options)
+        if defined?(@subclasses) && @subclasses
+          @subclasses.each { |klass| klass.property(name, options) }
+        end
+      end
+
+      # Check if property is defined
+      #
+      # @param [Symbol] name
+      #   the name to check
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def self.property?(name)
+        property_set.include?(name)
+      end
+
+      class << self
+        attr_reader :property_set
+      end
+
+      instance_variable_set("@property_set", PropertySet.new(self))
+
+      def self.inherited(descendant)
+        super
+        (@subclasses ||= Set.new) << descendant
+        descendant.instance_variable_set('@property_set',
+          PropertySet.new(descendant, self.property_set.properties.dup))
+      end
+
+      def initialize(&block)
+        super(&block)
+      end
+
+      def property_names
+        self.class.property_set.properties.map(&:name)
+      end
+
+      def self.property_names
+        property_set.properties.map(&:name)
+      end
+
+      # Fetach all the properties and their values
+      #
+      # @return [Hash[Symbol]]
+      #
+      # @api public
+      def fetch(value = nil)
+        if value
+          self.class.property_set[value]
+        else
+          self.class.property_set.to_hash
+        end
+      end
+
+      # Provide access to properties
+      #
+      # @example
+      #   config.call do |config|
+      #     config.adapter = :net_http
+      #   end
+      #
+      # @return [self]
+      #
+      # @api private
+      def call(&block)
+        block.call(self) if block_given?
+        self
+      end
+    end # Config
+  end # Api
+end # BitBucket

data/lib/bitbucket_rest_api/api/factory.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'bitbucket_rest_api/core_ext/hash'
+
+module BitBucket
+  class API
+    class Factory
+
+      # Instantiates a new bitbucket api object
+      def self.new(klass, options={}, &block)
+        return create_instance(klass, options, &block) if klass
+        raise ArgumentError, 'must provide klass to be instantiated'
+      end
+
+      # Passes configuration options to instantiated class
+      def self.create_instance(klass, options, &block)
+        options.symbolize_keys!
+        convert_to_constant(klass.to_s).new options, &block
+      end
+
+      def self.convert_to_constant(classes)
+        classes.split('::').inject(BitBucket) do |constant, klass|
+          constant.const_get klass
+        end
+      end
+
+    end # Factory
+  end # Api
+end # BitBucket

data/lib/bitbucket_rest_api/api.rb

@@ -0,0 +1,242 @@
+# -*- encoding: utf-8 -*-
+
+require 'bitbucket_rest_api/configuration'
+require 'bitbucket_rest_api/core_ext/hash'
+require 'bitbucket_rest_api/core_ext/array'
+require 'bitbucket_rest_api/compatibility'
+require 'bitbucket_rest_api/null_encoder'
+
+require 'bitbucket_rest_api/request/verbs'
+
+require 'bitbucket_rest_api/api/actions'
+require 'bitbucket_rest_api/api/factory'
+require 'bitbucket_rest_api/api/arguments'
+
+module BitBucket
+  class API
+    extend BitBucket::ClassMethods
+    include Constants
+    include Authorization
+    include Request::Verbs
+
+    # TODO consider these optional in a stack
+    include Validations
+    include ParameterFilter
+    include Normalizer
+
+    @version = '1.0'
+
+    attr_reader *BitBucket.configuration.property_names
+
+    attr_accessor *Validations::VALID_API_KEYS
+
+    attr_accessor :current_options
+
+    # Callback to update global configuration options
+    class_eval do
+      BitBucket.configuration.property_names.each do |key|
+        define_method "#{key}=" do |arg|
+          self.instance_variable_set("@#{key}", arg)
+          self.current_options.merge!({:"#{key}" => arg})
+        end
+      end
+    end
+
+    # Creates new API
+    def initialize(options={}, &block)
+      super()
+      setup(options)
+      yield_or_eval(&block) if block_given?
+    end
+
+    def yield_or_eval(&block)
+      return unless block
+      block.arity > 0 ? yield(self) : self.instance_eval(&block)
+    end
+
+    def setup(options={})
+      options = BitBucket.configuration.fetch.merge(options)
+      self.current_options = options
+      if self.class.instance_variable_get('@version') == '2.0'
+        options[:endpoint] = BitBucket.endpoint_v2
+      end
+      BitBucket.configuration.property_names.each do |key|
+        send("#{key}=", options[key])
+      end
+      process_basic_auth(options[:basic_auth])
+    end
+
+    # Extract login and password from basic_auth parameter
+    def process_basic_auth(auth)
+      case auth
+      when String
+        self.login, self.password = auth.split(':', 2)
+      when Hash
+        self.login    = auth[:login]
+        self.password = auth[:password]
+      end
+    end
+
+    # Assigns current api class
+    def set_api_client
+      BitBucket.api_client = self
+    end
+
+    # Responds to attribute query or attribute clear
+    def method_missing(method, *args, &block) # :nodoc:
+      case method.to_s
+      when /^(.*)\?$/
+        return !self.send($1.to_s).nil?
+      when /^clear_(.*)$/
+        self.send("#{$1.to_s}=", nil)
+      else
+        super
+      end
+    end
+
+     # Acts as setter and getter for api requests arguments parsing.
+    #
+    # Returns Arguments instance.
+    #
+    def arguments(args=(not_set = true), options={}, &block)
+      if not_set
+        @arguments
+      else
+        @arguments = Arguments.new(options.merge!(api: self)).parse(*args, &block)
+      end
+    end
+
+    # Scope for passing request required arguments.
+    #
+    def with(args)
+      case args
+      when Hash
+        set args
+      when /.*\/.*/i
+        user, repo = args.split('/')
+        set :user => user, :repo => repo
+      else
+        ::Kernel.raise ArgumentError, 'This api does not support passed in arguments'
+      end
+    end
+
+    # Set a configuration option for a given namespace
+    #
+    # @param [String] option
+    # @param [Object] value
+    # @param [Boolean] ignore_setter
+    #
+    # @return [self]
+    #
+    # @api public
+    def set(option, value=(not_set=true), ignore_setter=false, &block)
+      raise ArgumentError, 'value not set' if block and !not_set
+      return self if !not_set and value.nil?
+
+      if not_set
+        set_options option
+        return self
+      end
+
+      if respond_to?("#{option}=") and not ignore_setter
+        return __send__("#{option}=", value)
+      end
+
+      define_accessors option, value
+      self
+    end
+
+    # Defines a namespace
+    #
+    # @param [Array[Symbol]] names
+    #   the name for the scope
+    #
+    # @return [self]
+    #
+    # @api public
+    def self.namespace(*names)
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      names   = names.map(&:to_sym)
+      name    = names.pop
+      return if public_method_defined?(name)
+
+      class_name = extract_class_name(name, options)
+      define_method(name) do |*args, &block|
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        API::Factory.new(class_name, current_options.merge(options), &block)
+      end
+      self
+    end
+
+    # Extracts class name from options
+    #
+    # @param [Hash] options
+    # @option options [String] :full_name
+    #   the full name for the class
+    # @option options [Boolean] :root
+    #   if the class is at the root or not
+    #
+    # @return [String]
+    #
+    # @api private
+    def self.extract_class_name(name, options)
+      converted  = options.fetch(:full_name, name).to_s
+      converted  = converted.split('_').map(&:capitalize).join
+      class_name = options.fetch(:root, false) ? '': "#{self.name}::"
+      class_name += converted
+      class_name
+    end
+
+    def _update_user_repo_params(user_name, repo_name=nil) # :nodoc:
+      self.user = user_name || self.user
+      self.repo = repo_name || self.repo
+    end
+
+    def _merge_user_into_params!(params)  #  :nodoc:
+      params.merge!({ 'user' => self.user }) if user?
+    end
+
+    def _merge_user_repo_into_params!(params)   #  :nodoc:
+      { 'user' => self.user, 'repo' => self.repo }.merge!(params)
+    end
+
+
+    private
+
+    # Set multiple options
+    #
+    # @api private
+    def set_options(options)
+      unless options.respond_to?(:each)
+        raise ArgumentError, 'cannot iterate over value'
+      end
+      options.each { |key, value| set(key, value) }
+    end
+
+    # Define setters and getters
+    #
+    # @api private
+    def define_accessors(option, value)
+      setter = proc { |val|  set option, val, true }
+      getter = proc { value }
+
+      define_singleton_method("#{option}=", setter) if setter
+      define_singleton_method(option, getter) if getter
+    end
+
+    # Dynamically define a method for setting request option
+    #
+    # @api private
+    def define_singleton_method(method_name, content=Proc.new)
+      (class << self; self; end).class_eval do
+        undef_method(method_name) if method_defined?(method_name)
+        if String === content
+          class_eval("def #{method_name}() #{content}; end")
+        else
+          define_method(method_name, &content)
+        end
+      end
+    end
+
+  end # API
+end # BitBucket

data/lib/bitbucket_rest_api/authorization.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module BitBucket
+  module Authorization
+
+    # Check whether authentication credentials are present
+    def authenticated?
+      basic_authed? || oauth_token?
+    end
+
+    # Check whether basic authentication credentials are present
+    def basic_authed?
+      basic_auth? || (login? && password?)
+    end
+
+    # Select authentication parameters
+    def authentication
+      if basic_auth?
+        { :basic_auth => basic_auth }
+      elsif login? && password?
+        { :login => login, :password => password }
+      else
+        { }
+      end
+    end
+
+    private
+
+    def _verify_client # :nodoc:
+      raise ArgumentError, 'Need to provide client_id and client_secret' unless client_id? && client_secret?
+    end
+
+  end # Authorization
+end # BitBucket

data/lib/bitbucket_rest_api/client/invitations.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module BitBucket
+  class Client::Invitations < API
+    @version = '1.0'
+
+    def invite(user_name, repo_name, emailaddress, perm)
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of emailaddress
+      perm ||= "write"
+
+      post_request("/invitations/#{user}/#{repo.downcase}/#{emailaddress}", permission: perm)
+    end
+  end
+end

data/lib/bitbucket_rest_api/client/issues/comments.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+module BitBucket
+  class Client::Issues::Comments < API
+    @version = '1.0'
+
+    VALID_ISSUE_COMMENT_PARAM_NAME = %w[
+      content
+    ].freeze
+
+    # List comments on an issue
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.issues.comments.all 'user-name', 'repo-name', 'issue-id'
+    #  bitbucket.issues.comments.all 'user-name', 'repo-name', 'issue-id' {|com| .. }
+    #
+    def list(user_name, repo_name, issue_id, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of issue_id
+
+      normalize! params
+
+      response = get_request("/repositories/#{user}/#{repo.downcase}/issues/#{issue_id}/comments/", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :all :list
+
+    # Get a single comment
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.issues.comments.find 'user-name', 'repo-name', 'comment-id'
+    #
+    def get(user_name, repo_name, comment_id, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of comment_id
+
+      normalize! params
+
+      get_request("/repositories/#{user}/#{repo.downcase}/issues/comments/#{comment_id}", params)
+    end
+    alias :find :get
+
+    # Create a comment
+    #
+    # = Inputs
+    #  <tt>:content</tt> Required string
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.issues.comments.create 'user-name', 'repo-name', 'issue-id',
+    #     "content" => 'a new comment'
+    #
+    def create(user_name, repo_name, issue_id, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of issue_id
+
+      normalize! params
+      filter! VALID_ISSUE_COMMENT_PARAM_NAME, params
+      assert_required_keys(%w[ content ], params)
+
+      post_request("/repositories/#{user}/#{repo.downcase}/issues/#{issue_id}/comments/", params)
+    end
+
+    # Edit a comment
+    #
+    # = Inputs
+    #  <tt>:content</tt> Required string
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.issues.comments.edit 'user-name', 'repo-name', 'comment-id',
+    #     "content" => 'a new comment'
+    #
+    def edit(user_name, repo_name, comment_id, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of comment_id
+
+      normalize! params
+      filter! VALID_ISSUE_COMMENT_PARAM_NAME, params
+      assert_required_keys(%w[ content ], params)
+
+      put_request("/repositories/#{user}/#{repo.downcase}/issues/comments/#{comment_id}")
+    end
+
+    # Delete a comment
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.issues.comments.delete 'user-name', 'repo-name', 'comment-id'
+    #
+    def delete(user_name, repo_name, comment_id, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of comment_id
+
+      normalize! params
+
+      delete_request("/repositories/#{user}/#{repo.downcase}/issues/comments/#{comment_id}", params)
+    end
+
+  end # Issues::Comments
+end # BitBucket

data/lib/bitbucket_rest_api/client/issues/components.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+module BitBucket
+  class Client::Issues::Components < API
+    @version = '1.0'
+
+    VALID_COMPONENT_INPUTS = %w[ name ].freeze
+
+    # List all components for a repository
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new :user => 'user-name', :repo => 'repo-name'
+    #  bitbucket.issues.components.list
+    #  bitbucket.issues.components.list { |component| ... }
+    #
+    def list(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.downcase}/issues/components", params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :all :list
+
+    # Get a single component
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.issues.components.find 'user-name', 'repo-name', 'component-id'
+    #
+    def get(user_name, repo_name, component_id, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of component_id
+      normalize! params
+
+      get_request("/repositories/#{user}/#{repo.downcase}/issues/components/#{component_id}", params)
+    end
+    alias :find :get
+
+    # Create a component
+    #
+    # = Inputs
+    #  <tt>:name</tt> - Required string
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new :user => 'user-name', :repo => 'repo-name'
+    #  bitbucket.issues.components.create :name => 'API'
+    #
+    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_COMPONENT_INPUTS, params
+      assert_required_keys(VALID_COMPONENT_INPUTS, params)
+
+      post_request("/repositories/#{user}/#{repo.downcase}/issues/components", params)
+    end
+
+    # Update a component
+    #
+    # = Inputs
+    #  <tt>:name</tt> - Required string
+    #
+    # = Examples
+    #  @bitbucket = BitBucket.new
+    #  @bitbucket.issues.components.update 'user-name', 'repo-name', 'component-id',
+    #    :name => 'API'
+    #
+    def update(user_name, repo_name, component_id, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+      _validate_presence_of component_id
+
+      normalize! params
+      filter! VALID_COMPONENT_INPUTS, params
+      assert_required_keys(VALID_COMPONENT_INPUTS, params)
+
+      put_request("/repositories/#{user}/#{repo.downcase}/issues/components/#{component_id}", params)
+    end
+    alias :edit :update
+
+    # Delete a component
+    #
+    # = Examples
+    #  bitbucket = BitBucket.new
+    #  bitbucket.issues.components.delete 'user-name', 'repo-name', 'component-id'
+    #
+    def delete(user_name, repo_name, component_id, params={})
+      _update_user_repo_params(user_name, repo_name)
+      _validate_user_repo_params(user, repo) unless user? && repo?
+
+      _validate_presence_of component_id
+      normalize! params
+
+      delete_request("/repositories/#{user}/#{repo.downcase}/labels/components/#{component_id}", params)
+    end
+
+  end # Issues::Components
+end # BitBucket