assembla_api 0.1.2

data/lib/assembla_api/error.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'descendants_tracker'
+
+module Assembla
+  module Error
+    class AssemblaError < StandardError
+      extend DescendantsTracker
+
+      attr_reader :response_message, :response_headers
+
+      # Initialize a new Assembla error object.
+      #
+      def initialize(message=$!)
+        if message.respond_to?(:backtrace)
+          super(message.message)
+          @response_message = message
+        else
+          super(message.to_s)
+        end
+      end
+
+      def backtrace
+        @response_message ? @response_message.backtrace : super
+      end
+
+    end # AssemblaError
+  end # Error
+end # Assembla
+
+require 'assembla_api/error/service_error'
+require 'assembla_api/error/client_error'
+Dir[File.dirname(__FILE__) + '/error/*.rb'].sort.each do |path|
+  filename = File.basename(path)
+  next if ['service_error.rb', 'client_error.rb'].include?(filename)
+  require "assembla_api/error/#{filename}"
+end

data/lib/assembla_api/error/bad_request.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Assembla
+  module Error
+    # Raised when Assembla returns the HTTP status code 400
+    class BadRequest < ServiceError
+      http_status_code 400
+
+      def initialize(response)
+        super(response)
+      end
+    end
+  end
+end # Assembla

data/lib/assembla_api/error/client_error.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when Assembla returns the HTTP status code 404
+  module Error
+    class ClientError < AssemblaError
+      attr_reader :problem, :summary, :resolution
+
+      def initialize(message)
+        super(message)
+      end
+
+      def generate_message(attributes)
+        "\nProblem:\n #{attributes[:problem]}"+
+        "\nSummary:\n #{attributes[:summary]}"+
+        "\nResolution:\n #{attributes[:resolution]}"
+      end
+    end
+  end # Error
+end # Assembla

data/lib/assembla_api/error/forbidden.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when Assembla returns the HTTP status code 403
+  module Error
+    class Forbidden < ServiceError
+      http_status_code 403
+
+      def initialize(response)
+        super(response)
+      end
+    end
+  end # Error
+end # Assembla

data/lib/assembla_api/error/internal_server_error.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when Assembla returns the HTTP status code 500
+  module Error
+    class InternalServerError < ServiceError
+      http_status_code 500
+
+      def initialize(response)
+        super(response)
+      end
+
+    end # InternalServerError
+  end # Error
+end # Assembla

data/lib/assembla_api/error/invalid_options.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when invalid options are passed to a request body
+  module Error
+    class InvalidOptions < ClientError
+      def initialize(invalid, valid)
+        super(
+          generate_message(
+            :problem => "Invalid option #{invalid.keys.join(', ')} provided for this request.", 
+            :summary => "Assembla gem checks the request parameters passed to ensure that assembla api is not hit unnecessairly and to fail fast.",
+            :resolution => "Valid options are: #{valid.join(', ')}, make sure these are the ones you are using"
+          )
+        )
+      end
+    end
+  end # Error
+end # Assembla

data/lib/assembla_api/error/not_acceptable.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when Assembla returns the HTTP status code 406
+  module Error
+    class NotAcceptable < ServiceError
+      http_status_code 406
+
+      def initialize(response)
+        super(response)
+      end
+
+    end # NotAcceptable
+  end # Error
+end # Assembla

data/lib/assembla_api/error/not_found.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when Assembla returns the HTTP status code 404
+  module Error
+    class NotFound < ServiceError
+      http_status_code 404
+
+      def initialize(env)
+        super(env)
+      end
+    end
+  end # Error
+end # Assembla

data/lib/assembla_api/error/required_params.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when invalid options are passed to a request body
+  module Error
+    class RequiredParams < ClientError
+      def initialize(provided, required)
+        super(
+          generate_message(
+            :problem => "Missing required parameters: #{provided.keys.join(', ')} provided for this request.",
+            :summary => "Assembla gem checks the request parameters passed to ensure that assembla api is not hit unnecessairly and to fail fast.",
+            :resolution => "Required parameters are: #{required.join(', ')}, make sure these are the ones you are using"
+          )
+        )
+      end
+    end
+  end # Error
+end # Assembla

data/lib/assembla_api/error/service_error.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+# require 'multi_json'
+require 'assembla_api/jsonable'
+
+module Assembla
+  # Raised when Assembla returns any of the HTTP status codes
+  module Error
+    class ServiceError < AssemblaError
+      include ::Assembla::Jsonable
+
+      attr_reader :http_headers, :body, :status
+
+      MIN_BODY_LENGTH = 2
+
+      def initialize(response)
+        @http_headers = response[:response_headers]
+        message       = parse_response(response)
+        super(message)
+      end
+
+      def parse_response(response)
+        @body   = parse_body(response[:body])
+        @status = response[:status]
+        "#{response[:method].to_s.upcase} #{response[:url].to_s}: #{@status} #{@body}"
+      end
+
+      def decode_body(body)
+        if body.respond_to?(:to_str) && body.length >= MIN_BODY_LENGTH
+           decode body, symbolize_keys: true
+        else
+          body
+        end
+      end
+
+      def parse_body(body)
+        body = decode_body(body)
+
+        return '' if body.nil? || body.empty?
+
+        if body[:error]
+          body[:error]
+        elsif body[:errors]
+          error = Array(body[:errors]).first
+          if error.kind_of?(Hash)
+            error[:message]
+          else
+            error
+          end
+        elsif body[:message]
+          body[:message]
+        else
+          ''
+        end
+      end
+
+      def self.http_status_code(code)
+        define_method(:http_status_code) { code }
+      end
+
+      def self.errors
+        @errors ||= Hash[
+          descendants.map { |klass| [klass.new({}).http_status_code, klass] }
+        ]
+      end
+
+    end
+  end # Error
+end # Assembla

data/lib/assembla_api/error/service_unavailable.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when Assembla returns the HTTP status code 503
+  module Error
+    class ServiceUnavailable < ServiceError
+      http_status_code 503
+
+      def initialize(response)
+        super(response)
+      end
+
+    end # ServiceUnavailable
+  end # Error
+end # Assembla

data/lib/assembla_api/error/unauthorized.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when Assembla returns the HTTP status code 401
+  module Error
+    class Unauthorized < ServiceError
+      http_status_code 401
+
+      def initialize(response)
+        super(response)
+      end
+
+    end # Unauthorized
+  end # Error
+end # Assembla

data/lib/assembla_api/error/unknown_media.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when invalid options are passed to a request body
+  module Error
+    class UnknownMedia < ClientError
+      def initialize(file)
+        super(
+          generate_message(
+            :problem => "Unknown content type for: '#{file}' provided for this request.",
+            :summary => "Assembla gem infers the content type of the resource by calling the mime-types gem type inference.",
+            :resolution => "Please install mime-types gem to infer the resource content type."
+          )
+        )
+      end
+    end
+  end # Error
+end # Assembla

data/lib/assembla_api/error/unknown_value.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when invalid options are passed to a request body
+  module Error
+    class UnknownValue < ClientError
+      def initialize(key, value, permitted)
+        super(
+          generate_message(
+            :problem => "Wrong value of '#{value}' for the parameter: #{key} provided for this request.",
+            :summary => "Assembla gem checks the request parameters passed to ensure that assembla api is not hit unnecessairly and fails fast.",
+            :resolution => "Permitted values are: #{permitted}, make sure these are the ones you are using"
+          )
+        )
+      end
+    end
+  end # Error
+end # Assembla

data/lib/assembla_api/error/unprocessable_entity.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when Assembla returns the HTTP status code 422
+  module Error
+    class UnprocessableEntity < ServiceError
+      http_status_code 422
+
+      def initialize(response)
+        super(response)
+      end
+    end
+  end # Error
+end # Assembla

data/lib/assembla_api/error/validations.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Assembla #:nodoc
+  # Raised when passed parameters are missing or contain wrong values.
+  module Error
+    class Validations < ClientError
+      def initialize(errors)
+        super(
+          generate_message(
+            :problem => "Attempted to send request with nil arguments for #{errors.keys.join(', ')}.",
+            :summary => 'Each request expects certain number of required arguments.',
+            :resolution => 'Double check that the provided arguments are set to some value that is neither nil nor empty string.'
+          )
+        )
+      end
+    end
+  end # Error
+end # Assembla

data/lib/assembla_api/ext/faraday.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Faraday
+  module Utils
+
+    class ParamsHash
+      def params_encoder(encoder = nil)
+        if encoder
+          @encoder = encoder
+        else
+          @encoder
+        end
+      end
+
+      def to_query(encoder = nil)
+        Utils.build_nested_query(self, nil, params_encoder)
+      end
+    end
+
+    def build_nested_query(value, prefix = nil, encoder = nil)
+      case value
+      when Array
+        value.map { |v| build_nested_query(v, "#{prefix}%5B%5D", encoder) }.join("&")
+      when Hash
+        value.map { |k, v|
+          processed_value = encoder ? encoder.escape(k) : escape(k)
+          build_nested_query(v, prefix ? "#{prefix}%5B#{processed_value}%5D" : processed_value, encoder)
+        }.join("&")
+      when NilClass
+        prefix
+      else
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        processed_value = encoder ? encoder.escape(value) : escape(value)
+        "#{prefix}=#{processed_value}"
+      end
+    end
+  end
+end

data/lib/assembla_api/jsonable.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'multi_json'
+
+module Assembla
+  module Jsonable
+    extend self
+
+    def decode(*args)
+      return unless args.first
+      if MultiJson.respond_to?(:load)
+        MultiJson.load *args
+      else
+        MultiJson.decode *args
+      end
+    end
+  end
+end

data/lib/assembla_api/middleware.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'assembla_api/response'
+require 'assembla_api/response/mashify'
+require 'assembla_api/response/jsonize'
+require 'assembla_api/response/raise_error'
+require 'assembla_api/response/header'
+
+module Assembla
+  class Middleware
+    def self.default(options = {})
+      api = options[:api]
+      proc do |builder|
+        builder.use Faraday::Request::Multipart
+        builder.use Assembla::Request::Jsonize
+        builder.use Faraday::Request::UrlEncoded
+        builder.use Assembla::Request::OAuth2, api.oauth_token if api.oauth_token?
+        builder.use Assembla::Request::BasicAuth, api.authentication if api.basic_authed?
+        builder.use Assembla::Request::KeyAuth, { api_key: api.api_key, api_secret: api.api_secret } if api.api_key?
+
+        builder.use Faraday::Response::Logger if ENV['DEBUG']
+        unless options[:raw]
+          builder.use Assembla::Response::Mashify
+          builder.use Assembla::Response::Jsonize
+        end
+        builder.use Assembla::Response::RaiseError
+        builder.adapter options[:adapter]
+      end
+    end
+  end # Middleware
+end # Assembla