assembla_api 0.1.2

data/lib/assembla_api/api/factory.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'assembla_api/core_ext/hash'
+
+module Assembla
+  class API
+    class Factory
+
+      # Instantiates a new assembla api object
+      #
+      def self.new(klass, options={}, &block)
+        return create_instance(klass, options, &block) if klass
+        raise ArgumentError, 'must provide API class 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
+
+      # Convert name to constant
+      #
+      def self.convert_to_constant(classes)
+        classes.split('::').inject(Assembla) do |constant, klass|
+          constant.const_get klass
+        end
+      end
+
+    end # Factory
+  end # Api
+end # Assembla

data/lib/assembla_api/authorization.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+module Assembla
+  module Authorization
+
+    attr_accessor :scopes
+
+    # Setup OAuth2 instance
+    def client
+      @client ||= ::OAuth2::Client.new(client_id, client_secret,
+        {
+          :site          => current_options.fetch(:site) { Assembla.site },
+          :authorize_url => 'authorization',
+          :token_url     => 'token',
+          :ssl           => { :verify => false }
+        }
+      )
+    end
+
+    # Strategy token
+    def auth_code
+      _verify_client
+      client.auth_code
+    end
+
+    # Sends authorization request to Assembla.
+    # = Parameters
+    # * <tt>:redirect_uri</tt> - Optional string.
+    # * <tt>:scope</tt> - Optional string. Comma separated list of scopes.
+    #   Available scopes:
+    #   * (no scope) - public read-only access (includes public user profile info, public repo info, and gists).
+    #   * <tt>user</tt> - DB read/write access to profile info only.
+    #   * <tt>public_repo</tt> - DB read/write access, and Git read access to public repos.
+    #   * <tt>repo</tt> - DB read/write access, and Git read access to public and private repos.
+    #   * <tt>gist</tt> - write access to gists.
+    #
+    def authorize_url(params = {})
+      _verify_client
+      client.auth_code.authorize_url(params)
+    end
+
+    # Makes request to token endpoint and retrieves access token value
+    def get_token(authorization_code, params = {})
+      _verify_client
+      client.auth_code.get_token(authorization_code, params)
+    end
+
+    # 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 # Assembla

data/lib/assembla_api/client.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Assembla
+  class Client < API
+
+    require_all 'assembla_api/client',
+      'portfolio',
+      'activity',
+      'spaces',
+      'tasks',
+      'users'
+
+    namespace :activity
+    namespace :spaces
+    namespace :portfolio
+
+    # Many of the resources on the users API provide a shortcut for getting
+    # information about the currently authenticated user.
+    namespace :users
+  end # Client
+end # Assembla

data/lib/assembla_api/client/activity.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Assembla
+  class Client::Activity < API
+    VALID_REQUEST_PARAM_NAMES = %w[
+      space_id
+      to
+      from
+    ].freeze
+
+    TIME_REGEXP = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/
+
+    VALID_REQUEST_PARAM_VALUES = {
+      'to' => TIME_REGEXP,
+      'from' => TIME_REGEXP
+    }
+
+    def list(*args)
+      arguments(args) do
+        permit VALID_REQUEST_PARAM_NAMES
+        assert_values VALID_REQUEST_PARAM_VALUES
+      end
+
+      response = get_request("/activity", arguments.params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+
+  end # Activity
+end # Assembla

data/lib/assembla_api/client/authorizations.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+
+module Assembla
+  # OAuth Authorizations API
+  class Client::Authorizations < API
+
+    require_all 'assembla_api/client/authorizations', 'app'
+
+    VALID_AUTH_PARAM_NAMES = %w[
+      scopes
+      add_scopes
+      remove_scopes
+      note
+      note_url
+      client_id
+      client_secret
+    ].freeze
+
+    # Access to Authorizations::App API
+    namespace :app
+
+    # List authorizations
+    #
+    # @see https://developer.assembla.com/v3/oauth_authorizations/#list-your-authorizations
+    #
+    # @example
+    #  assembla = Assembla.new basic_auth: 'login:password'
+    #  assembla.oauth.list
+    #  assembla.oauth.list { |auth| ... }
+    #
+    # @api public
+    def list(*args)
+      raise_authentication_error unless authenticated?
+      arguments(args)
+
+      response = get_request('/authorizations', arguments.params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+    alias :all :list
+
+    # Get a single authorization
+    #
+    # @see https://developer.assembla.com/v3/oauth_authorizations/#get-a-single-authorization
+    #
+    # @example
+    #  assembla = Assembla.new basic_auth: 'login:password'
+    #  assembla.oauth.get 'authorization-id'
+    #
+    # @return [ResponseWrapper]
+    #
+    # @api public
+    def get(*args)
+      raise_authentication_error unless authenticated?
+      arguments(args, required: [:id])
+
+      get_request("/authorizations/#{arguments.id}", arguments.params)
+    end
+    alias :find :get
+
+    # Create a new authorization
+    #
+    # @param [Hash] params
+    # @option params [Array[String]] :scopes
+    #   A list of scopes that this authorization is in.
+    # @option params [String] :note
+    #   A note to remind you what the OAuth token is for.
+    # @option params [String] :note_url
+    #   A URL to remind you what the OAuth token is for.
+    # @option params [String] :client_id
+    #   The 20 character OAuth app client key for which to create the token.
+    # @option params [String] :client_secret
+    #   The 40 character OAuth app client secret for which to create the token.
+    #
+    # @example
+    #  assembla = Assembla.new basic_auth: 'login:password'
+    #  assembla.oauth.create
+    #    "scopes" => ["public_repo"]
+    #
+    # @api public
+    def create(*args)
+      raise_authentication_error unless authenticated?
+      arguments(args) do
+        permit VALID_AUTH_PARAM_NAMES
+      end
+
+      post_request('/authorizations', arguments.params)
+    end
+
+    # Update an existing authorization
+    #
+    # @param [Hash] inputs
+    # @option inputs [Array] :scopes
+    #   Optional array - A list of scopes that this authorization is in.
+    # @option inputs [Array] :add_scopes
+    #   Optional array - A list of scopes to add to this authorization.
+    # @option inputs [Array] :remove_scopes
+    #   Optional array - A list of scopes to remove from this authorization.
+    # @option inputs [String] :note
+    #   Optional string - A note to remind you what the OAuth token is for.
+    # @optoin inputs [String] :note_url
+    #   Optional string - A URL to remind you what the OAuth token is for.
+    #
+    # @example
+    #  assembla = Assembla.new basic_auth: 'login:password'
+    #  assembla.oauth.update "authorization-id", add_scopes: ["repo"]
+    #
+    # @api public
+    def update(*args)
+      raise_authentication_error unless authenticated?
+      arguments(args, required: [:id]) do
+        permit VALID_AUTH_PARAM_NAMES
+      end
+
+      patch_request("/authorizations/#{arguments.id}", arguments.params)
+    end
+    alias :edit :update
+
+    # Delete an authorization
+    #
+    # @see https://developer.assembla.com/v3/oauth_authorizations/#delete-an-authorization
+    #
+    # @example
+    #  assembla.oauth.delete 'authorization-id'
+    #
+    # @api public
+    def delete(*args)
+      raise_authentication_error unless authenticated?
+      arguments(args, required: [:id])
+
+      delete_request("/authorizations/#{arguments.id}", arguments.params)
+    end
+    alias :remove :delete
+
+    protected
+
+    def raise_authentication_error
+      raise ArgumentError, 'You can only access your own tokens' +
+        ' via Basic Authentication'
+    end
+
+  end # Client::Authorizations
+end # Assembla

data/lib/assembla_api/client/authorizations/app.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+module Assembla
+  class Client::Authorizations::App < Client::Authorizations
+    # Get-or-create an authorization for a specific app
+    #
+    # @see https://developer.assembla.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app
+    #
+    # @param [Hash] params
+    # @option params [String] client_secret
+    #  The 40 character OAuth app client secret associated with the client
+    #  ID specified in the URL.
+    # @option params [Array] :scopes
+    #   Optional array - A list of scopes that this authorization is in.
+    # @option params [String] :note
+    #   Optional string - A note to remind you what the OAuth token is for.
+    # @option params [String] :note_url
+    #   Optional string - A URL to remind you what the OAuth token is for.
+    #
+    # @example
+    #   assembla = Assembla.new
+    #   assembla.oauth.app.create 'client-id', client_secret: '...'
+    #
+    # @api public
+    def create(*args)
+      raise_authentication_error unless authenticated?
+      arguments(args, required: [:client_id]) do
+        permit VALID_AUTH_PARAM_NAMES
+      end
+
+      if arguments.client_id
+        put_request("/authorizations/clients/#{arguments.client_id}", arguments.params)
+      else
+        raise raise_app_authentication_error
+      end
+    end
+
+    # Check if an access token is a valid authorization for an application
+    #
+    # @example
+    #   assembla = Assembla.new basic_auth: "client_id:client_secret"
+    #   assembla.oauth.app.check 'client_id', 'access-token'
+    #
+    # @api public
+    def check(*args)
+      raise_authentication_error unless authenticated?
+      params = arguments(args, required: [:client_id, :access_token]).params
+
+      if arguments.client_id
+        begin
+          get_request("/applications/#{arguments.client_id}/tokens/#{arguments.access_token}", params)
+        rescue Assembla::Error::NotFound => e
+          nil
+        end
+      else
+        raise raise_app_authentication_error
+      end
+    end
+
+    # Revoke all authorizations for an application
+    #
+    # @example
+    #  assembla = Assembla.new basic_auth: "client_id:client_secret"
+    #  assembla.oauth.app.delete 'client-id'
+    #
+    # Revoke an authorization for an application
+    #
+    # @example
+    #  assembla = Assembla.new basic_auth: "client_id:client_secret"
+    #  assembla.oauth.app.delete 'client-id', 'access-token'
+    #
+    # @api public
+    def delete(*args)
+      raise_authentication_error unless authenticated?
+      params = arguments(args, required: [:client_id]).params
+
+      if arguments.client_id
+        if access_token = (params.delete('access_token') || args[1])
+          delete_request("/applications/#{arguments.client_id}/tokens/#{access_token}", params)
+        else
+          # Revokes all tokens
+          delete_request("/applications/#{arguments.client_id}/tokens", params)
+        end
+      else
+        raise raise_app_authentication_error
+      end
+    end
+    alias :remove :delete
+    alias :revoke :delete
+
+    protected
+
+    def raise_app_authentication_error
+      raise ArgumentError, 'To create authorization for the app, ' +
+        'you need to provide client_id argument and client_secret parameter'
+    end
+  end # Client::Authorizations::App
+end # Assembla

data/lib/assembla_api/client/portfolio.rb

@@ -0,0 +1,19 @@
+module Assembla
+  class Client::Portfolio < API
+    require_all 'assembla_api/client/portfolio',
+      'tasks',
+      'users',
+      'tickets',
+      'spaces',
+      'ticket_reports',
+      'standup_reports',
+      'invitations'
+
+    namespace :tasks
+    namespace :users
+    namespace :tickets
+    namespace :ticket_reports
+    namespace :standup_reports
+    namespace :invitations
+  end
+end

data/lib/assembla_api/client/portfolio/invitations.rb

@@ -0,0 +1,30 @@
+module Assembla
+  class Client::Portfolio::Invitations < API
+
+    # @example
+    # api.portfolio.invitations.list
+    def list(*args)
+      arguments(args)
+      response = get_request("/invitations", arguments.params)
+      return response unless block_given?
+      response.each { |el| yield el }
+    end
+
+    # @example
+    # api.portfolio.invitations.create
+    def create(*args)
+      arguments(args) do
+        permit %w{ role title identifiers }, recursive: true
+      end
+
+      post_request("/invitations", arguments.params)
+    end
+
+    # @example
+    # api.portfolio.invitations.get 187
+    def get(*args)
+      arguments(args, required: [:id])
+      get_request("/invitations/#{arguments.id}", arguments.params)
+    end
+  end
+end