nimbu-api 0.0.1

data/lib/nimbu-api/request/basic_auth.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'base64'
+
+module Nimbu
+  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 # Nimbu

data/lib/nimbu-api/request/json.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module Nimbu
+  class Request::Json < 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::Json
+end # Nimbu

data/lib/nimbu-api/request/normalizer.rb

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+module Nimbu
+  module Request
+    # Deals with normalazing client supplied parameter keys.
+    module Normalizer
+
+      # Turns any keys from nested hashes including nested arrays into strings
+      #
+      def normalize!(params)
+        case params
+        when Hash
+          params.keys.each do |k|
+            params[k.to_s] = params.delete(k)
+            normalize!(params[k.to_s])
+          end
+        when Array
+          params.map! do |el|
+            normalize!(el)
+          end
+        else
+          params.to_s
+        end
+        return params
+      end
+
+      end # Normalizer
+    end # Request
+  end # Nimbu

data/lib/nimbu-api/request/oauth2.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module Nimbu
+  module Request
+    class OAuth2 < Faraday::Middleware
+      include Nimbu::Utils::Url
+
+      ACCESS_TOKEN = 'access_token'.freeze
+      AUTH_HEADER  = 'Authorization'.freeze
+
+      dependency 'oauth2'
+
+      def call(env)
+        # Extract parameters from the query
+        params = { ACCESS_TOKEN => @token }.update query_params(env[:url])
+
+        if token = params[ACCESS_TOKEN] and !token.empty?
+          env[:url].query = build_query params
+          env[:request_headers].merge!(AUTH_HEADER => "Token token=\"#{token}\"")
+        end
+
+        @app.call env
+      end
+
+      def initialize(app, *args)
+        super app
+        @app = app
+        @token = args.shift
+      end
+
+      def query_params(url)
+        if url.query.nil? or url.query.empty?
+          {}
+        else
+          parse_query url.query
+        end
+      end
+    end # OAuth2
+  end # Request
+end # Nimbu

data/lib/nimbu-api/request/parameter_filter.rb

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+module Nimbu
+  module Request
+    # Allows you to specify parameters keys which will be preserved
+    # in parameters hash and its subhashes. Any keys from the nested
+    # hash that do not match will be removed.
+    module ParameterFilter
+
+      # Removes any keys from nested hashes that don't match predefiend keys
+      #
+      def filter!(keys, params, options={:recursive => true})  # :nodoc:
+        case params
+        when Hash
+          params.keys.each do |k, v|
+            unless (keys.include?(k) or Nimbu::Validations::VALID_API_KEYS.include?(k))
+              params.delete(k)
+            else
+              filter!(keys, params[k]) if options[:recursive]
+            end
+          end
+        when Array
+          params.map! do |el|
+            filter!(keys, el) if options[:recursive]
+          end
+        else
+          params
+        end
+        return params
+      end
+
+    end # ParameterFilter
+  end # Request
+end # Nimbu

data/lib/nimbu-api/request/validations.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'nimbu-api/request/validations/presence'
+require 'nimbu-api/request/validations/format'
+require 'nimbu-api/request/validations/token'
+require 'nimbu-api/request/validations/required'
+
+module Nimbu
+  module Request
+    module Validations
+
+      include Presence
+      include Format
+      include Token
+      include Required
+
+      VALID_API_KEYS = [
+        'page',
+        'per_page',
+        'auto_pagination'
+      ]
+
+      end # Validation
+    end # Request
+  end # Nimbu

data/lib/nimbu-api/request/validations/format.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Nimbu
+  module Request
+    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 Nimbu::Error::UnknownValue.new(k,v, permitted[k].join(', '))
+
+            elsif permitted[k].is_a?(Regexp) && !(permitted[k] =~ params[k])
+              raise Nimbu::Error::UnknownValue.new(k,v, permitted[k])
+            end
+          end
+        end
+
+      end # Format
+    end # Validations
+  end # Request
+end # Nimbu

data/lib/nimbu-api/request/validations/presence.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Nimbu
+  module Request
+    module Validations
+      # A mixin to help validate presence of non-empty values
+      module Presence
+
+        # Ensure that esential arguments are present before request is made.
+        #
+        # == Parameters
+        #  Hash/Array of arguments to be checked against nil and empty string
+        #
+        # == Example
+        #  assert_presence_of user: '...', repo: '...'
+        #  assert_presence_of user, repo
+        #
+        def assert_presence_of(*args)
+          hash = args.last.is_a?(::Hash) ? args.pop : {}
+
+          errors = hash.select { |key, val| val.to_s.empty? }
+          raise Nimbu::Error::Validations.new(errors) unless errors.empty?
+
+          args.each do |arg|
+            raise ArgumentError, "parameter cannot be nil" if arg.nil?
+          end
+        end
+
+      end # Presence
+    end # Validations
+  end # Request
+end # Nimbu

data/lib/nimbu-api/request/validations/required.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Nimbu
+  module Request
+    module Validations
+      module Required
+
+        # Validate all keys present in a provided hash against required set,
+        # on mismatch raise Nimbu::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 Nimbu::Error::RequiredParams.new(provided, required)
+          end
+          result
+        end
+
+      end # Required
+    end # Validations
+  end # Request
+end # Nimbu

data/lib/nimbu-api/request/validations/token.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Nimbu
+  module Request
+    module Validations
+      module Token
+
+        TOKEN_REQUIRED = [
+          'get /sites',
+          'get /channels'
+        ]
+
+        TOKEN_REQUIRED_REGEXP = [
+          /channels\/.*\/.*\/entries/,
+        ]
+
+        # 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 # Request
+end # Nimbu

data/lib/nimbu-api/response.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module Nimbu
+  # 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 # Nimbu
+
+require 'nimbu-api/response/header'
+require 'nimbu-api/response/mashify'
+require 'nimbu-api/response/json'
+require 'nimbu-api/response/raise_error'
+require 'nimbu-api/response/wrapper'

data/lib/nimbu-api/response/header.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+module Nimbu
+  class Response
+
+    # Represents http response header
+    class Header < Struct.new(:env)
+      include Nimbu::Utils::Constants
+
+      SUCCESSFUL_STATUSES = 200..299
+
+      def loaded?
+        !!env
+      end
+
+      def oauth_scopes
+        loaded? ? env[:response_headers][OAUTH_SCOPES] : nil
+      end
+
+      def accepted_oauth_scopes
+        loaded? ? env[:response_headers][ACCEPTED_OAUTH_SCOPES] : nil
+      end
+
+      # Requests are limited to API v3 to 5000 per hour.
+      def ratelimit_limit
+        loaded? ? env[:response_headers][RATELIMIT_LIMIT] : nil
+      end
+
+      def ratelimit_remaining
+        loaded? ? env[:response_headers][RATELIMIT_REMAINING] : nil
+      end
+
+      def cache_control
+        loaded? ? env[:response_headers][CACHE_CONTROL] : nil
+      end
+
+      def content_type
+        loaded? ? env[:response_headers][CONTENT_TYPE] : nil
+      end
+
+      def content_length
+        loaded? ? env[:response_headers][CONTENT_LENGTH] : nil
+      end
+
+      def etag
+        loaded? ? env[:response_headers][ETAG] : nil
+      end
+
+      def date
+        loaded? ? env[:response_headers][DATE] : nil
+      end
+
+      def location
+        loaded? ? env[:response_headers][LOCATION] : nil
+      end
+
+      def server
+        loaded? ? env[:response_headers][SERVER] : nil
+      end
+
+      def status
+        loaded? ? env[:status] : nil
+      end
+
+      def success?
+        SUCCESSFUL_STATUSES.include? status
+      end
+
+      # Returns raw body
+      def body
+        loaded? ? env[:body] : nil
+      end
+
+    end # Header
+  end # Response
+end # Nimbu