bitbucket_rest_api2 0.2.0

data/lib/bitbucket_rest_api/utils/url.rb

@@ -0,0 +1,56 @@
+require 'cgi'
+
+module BitBucket
+  module Utils
+    module Url
+      extend self
+
+      DEFAULT_QUERY_SEP = /[&;] */n
+
+      KEY_VALUE_SEP = '='.freeze
+
+      def escape(s) CGI.escape s.to_s end
+
+      def unescape(s) CGI.unescape s.to_s end
+
+      def build_query(params)
+        params.map { |k, v|
+          if v.class == Array
+            build_query(v.map { |x| [k, x] })
+          else
+            v.nil? ? escape(k) : "#{escape(k)}=#{escape(v)}"
+          end
+        }.join("&")
+      end
+
+      def parse_query(query_string)
+        return '' if query_string.nil? || query_string.empty?
+        params = {}
+
+        query_string.split(DEFAULT_QUERY_SEP).each do |part|
+          k, v = part.split(KEY_VALUE_SEP, 2).map { |el| unescape(el) }
+
+          if cur = params[k]
+            if cur.class == Array
+              params[k] << v
+            else
+              params[k] = [cur, v]
+            end
+          else
+            params[k] = v
+          end
+        end
+        params
+      end
+
+      def parse_query_for_param(query_string, name)
+        parse_query(query_string).each do |key, val|
+          return val.first if (name == key) && val.is_a?(Array)
+          return val if (name == key)
+        end
+        return nil
+      end
+
+    end # Url
+  end # Utils
+end # BitBucket

data/lib/bitbucket_rest_api/validations.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module BitBucket
+  module Validations
+    extend AutoloadHelper
+
+    autoload_all 'bitbucket_rest_api/validations',
+                 :Presence => 'presence',
+                 :Token    => 'token',
+                 :Format   => 'format',
+                 :Required => 'required'
+
+    include Presence
+    include Format
+    include Token
+    include Required
+
+    VALID_API_KEYS = [
+        'page',
+        'per_page',
+        'jsonp_callback'
+    ]
+
+  end # Validation
+end # BitBucket

data/lib/bitbucket_rest_api/validations/format.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module BitBucket
+  module Validations
+    module Format
+
+      # Ensures that value for a given key is of the correct form whether
+      # matching regular expression or set of predefined values.
+      #
+      def assert_valid_values(permitted, params)
+        params.each do |k, v|
+          next unless permitted.keys.include?(k)
+          if permitted[k].is_a?(Array) && !permitted[k].include?(params[k])
+            raise BitBucket::Error::UnknownValue.new(k,v, permitted[k].join(', '))
+
+          elsif permitted[k].is_a?(Regexp) && !(permitted[k] =~ params[k])
+            raise BitBucket::Error::UnknownValue.new(k,v, permitted[k])
+          end
+        end
+      end
+
+    end # Format
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/validations/presence.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module BitBucket
+  module Validations
+    module Presence
+
+      # Ensures that essential 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
+
+
+      # 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?
+      end
+
+    end # Presence
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/validations/required.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module BitBucket
+  module Validations
+    module Required
+
+      # Validate all keys present in a provided hash against required set,
+      # on mismatch raise BitBucket::Error::RequiredParams
+      # Note that keys need to be in the same format i.e. symbols or strings,
+      # otherwise the comparison will fail.
+      #
+      def assert_required_keys(required, provided)
+        result = required.all? do |key|
+          provided.has_deep_key? key
+        end
+        if !result
+          raise BitBucket::Error::RequiredParams.new(provided, required)
+        end
+        result
+      end
+
+      # Validate that required values are not blank
+      # the *required are colon separated strings
+      # e.g. 'source:branch:name' tests value of params[:source][:branch][:name]
+      #
+      def assert_required_values_present(params, *required)
+        required.each do |encoded_string|
+          keys = parse_values(encoded_string)
+          value = keys.inject(params) { |params, key| params[key] }
+          if value.is_a?(String)
+            if value.empty?
+              raise BitBucket::Error::BlankValue.new(encoded_string)
+            end
+          end
+        end
+      end
+
+      def parse_values(string)
+        string.split(':')
+      end
+
+    end # Required
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/validations/token.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+# TODO: Set token required calls
+
+module BitBucket
+  module Validations
+    module Token
+
+      TOKEN_REQUIRED = [
+          'get /user',
+          'get /user/emails',
+          'get /user/followers',
+          'get /user/following',
+          'get /user/keys',
+          'get /user/repos',
+          'patch /user',
+          'post /user/emails',
+          'post /user/keys',
+          'post /user/repos'
+      ]
+
+      TOKEN_REQUIRED_REGEXP = [
+          /repos\/.*\/.*\/comments/,
+      ]
+
+      # Ensures that required authentication token is present before
+      # request is sent.
+      #
+      def validates_token_for(method, path)
+        return true unless TOKEN_REQUIRED.grep("#{method} #{path}").empty?
+
+        token_required = false
+        TOKEN_REQUIRED_REGEXP.each do |regex|
+          if "#{method} #{path}" =~ regex
+            token_required = true
+          end
+        end
+        return token_required
+      end
+
+    end # Token
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/version.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module BitBucket
+  module VERSION
+    MAJOR = 0
+    MINOR = 2
+    PATCH = 0
+
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+end # BitBucket

data/spec/bitbucket_rest_api/api/actions_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe BitBucket::API, '#actions' do
+  let(:api) { BitBucket::Repos::Keys }
+
+  context 'when class' do
+    it "lists all available actions for an api" do
+      expect(api.actions).to match_array([:actions, :all, :create, :delete, :edit, :list])
+    end
+  end
+
+  context 'when instance' do
+    it "lists all available actions for an api" do
+      expect(api.new.actions).to match_array([:actions, :all, :create, :delete, :edit, :list])
+    end
+  end
+end

data/spec/bitbucket_rest_api/api_factory_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe BitBucket::ApiFactory do
+
+  subject(:factory) { described_class }
+
+  context '#new' do
+    it 'throws error if klass type is ommitted' do
+      expect { factory.new nil }.to raise_error(ArgumentError)
+    end
+
+    it 'instantiates a new object' do
+      expect(factory.new('Issues')).to be_a BitBucket::Issues
+    end
+  end
+
+  context '#create_instance' do
+    it 'creates class instance' do
+      expect(factory.create_instance('User', {})).to be_kind_of(BitBucket::User)
+    end
+  end
+
+  context '#convert_to_constant' do
+    it 'knows how to convert nested classes' do
+      expect(factory.convert_to_constant('Repos::Changesets')).to eql(BitBucket::Repos::Changesets)
+    end
+  end
+end # BitBucket::ApiFactory

data/spec/bitbucket_rest_api/api_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe BitBucket::API do
+  let(:setup_options) { { user: 'test_user' } }
+  let(:bitbucket_api) { described_class.new(setup_options) }
+  after do
+    [:user, :login, :password].each do |key|
+      bitbucket_api.send "clear_#{key}".to_sym
+    end
+  end
+
+  describe '#new' do
+    it 'passes options to bitbucket' do
+      described_class.new(setup_options)
+
+      expect(bitbucket_api.user).to eq(setup_options[:user])
+    end
+
+    context 'valid options' do
+      it 'sets valid options' do
+        setup_options = {
+          login:    'johnwick',
+          password: 'password'
+        }
+        bitbucket_api = described_class.new(setup_options)
+
+        expect(bitbucket_api.login).to eq('johnwick')
+        expect(bitbucket_api.password).to eq('password')
+      end
+
+      it 'ignores invalid options' do
+        setup_options = {
+          invalid_option: 'invalid option'
+        }
+
+        bitbucket_api = described_class.new(setup_options)
+
+        expect{ bitbucket_api.invalid_option }.to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    let(:setup_options) { { user: 'test_user' } }
+
+    it 'responds to attribute query' do
+      expect(bitbucket_api.user?).to eq(true)
+    end
+
+    it 'clears the attributes' do
+      bitbucket_api.clear_user
+
+      expect(bitbucket_api.user).to be_nil
+    end
+  end
+
+  describe '#_update_user_repo_params' do
+    it 'sets the username and repo_name' do
+      bitbucket_api._update_user_repo_params('test_user1', 'test_repo')
+
+      expect(bitbucket_api.user).to eq('test_user1')
+      expect(bitbucket_api.repo).to eq('test_repo')
+    end
+  end
+
+  describe '#_merge_user_into_params!' do
+    let(:params) { {} }
+
+    it 'takes a hash and merges user into it' do
+      bitbucket_api._merge_user_into_params!(params)
+
+      expect(params).to include('user')
+    end
+  end
+
+  describe '#_merge_user_repo_into_params!' do
+    let(:params) { {} }
+
+    it 'takes a hash and merges user into it' do
+      new_params = bitbucket_api._merge_user_repo_into_params!(params)
+
+      expect(new_params).to include('user')
+      expect(new_params).to include('repo')
+    end
+  end
+end

data/spec/bitbucket_rest_api/authorization_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe BitBucket::Authorization do
+  let(:oauth_api) { BitBucket::API.new(oauth_token: 'example_oauth_token') }
+  let(:basic_auth_api) { BitBucket::API.new(basic_auth: 'example_login:example_password') }
+  let(:basic_auth_api_hash) do
+    BitBucket::API.new(
+      basic_auth: { login: 'example_login', password: 'example_password' })
+  end
+  let(:login_and_password_api) do
+    BitBucket::API.new(
+      login:      'example_login',
+      password:   'example_password',
+      basic_auth: nil
+    )
+  end
+
+  describe '#authenticated?' do
+    context 'oauth authentication' do
+      it 'should return true if oauth is used' do
+        expect(oauth_api.authenticated?).to eq(true)
+      end
+    end
+
+    context 'basic authentication' do
+      it 'should return true if basic authentication is used' do
+        expect(basic_auth_api.authenticated?).to eq(true)
+      end
+    end
+  end
+
+  describe '#basic_authed?' do
+    context 'with basic_auth' do
+      it 'should return true if basic_auth is set' do
+        expect(basic_auth_api.basic_authed?).to eq(true)
+        expect(basic_auth_api_hash.basic_authed?).to eq(true)
+      end
+    end
+
+    context 'with login and password' do
+      it 'should return true if a login and password are set' do
+        expect(login_and_password_api.basic_authed?).to eq(true)
+      end
+    end
+  end
+
+  describe '#authentication' do
+    context 'with basic_auth as a string' do
+      it 'should return a hash containing the value for :basic_auth' do
+        expectation = { basic_auth: 'example_login:example_password' }
+
+        expect(basic_auth_api.authentication).to eq(expectation)
+      end
+    end
+
+    context 'with basic_auth as a hash' do
+      it 'should return a hash containing the value for :basic_auth' do
+        expectation = { basic_auth: { login: 'example_login', password: 'example_password'} }
+
+        expect(basic_auth_api_hash.authentication).to eq(expectation)
+      end
+    end
+
+    context 'with login and password' do
+      it 'should return a hash containing values for :login and :password' do
+        expectation = { login: 'example_login', password: 'example_password' }
+
+        expect(login_and_password_api.authentication).to eq(expectation)
+      end
+    end
+  end
+end