nimbu-api 0.0.1

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'nimbu-api/utils/json'
+
+module Nimbu
+  class Response::Json < Response
+    include Nimbu::Utils::Json
+
+    dependency 'multi_json'
+
+    define_parser do |body|
+      Nimbu::Utils::Json.decode body
+    end
+
+    def parse(body)
+      case body
+      when ''
+        nil
+      when 'true'
+        true
+      when 'false'
+        false
+      else
+        self.class.parser.call body
+      end
+    end
+  end # Response::Json
+end # Nimbu

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module Nimbu
+  class Response::Mashify < Response
+    dependency 'hashie/mash'
+
+    define_parser do |body|
+      ::Hashie::Mash.new body
+    end
+
+    def parse(body)
+      case body
+      when Hash
+        self.class.parser.call body
+      when Array
+        body.map { |item| item.is_a?(Hash) ? self.class.parser.call(item) : item }
+      else
+        body
+      end
+    end
+  end # Response::Mashify
+end # Nimbu

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'nimbu-api/errors'
+
+module Nimbu
+  class Response::RaiseError < Faraday::Response::Middleware
+
+    def on_complete(env)
+      # status_code = env[:status].to_i
+      # service_error = Nimbu::Error::ServiceError
+      # error_class = service_error.errors[status_code]
+      # error_class = service_error if !error_class and (400...600).include? status_code
+      # raise error_class.new(env) if error_class
+    end
+
+  end # Response::RaiseError
+end # Nimbu

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

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+module Nimbu
+  class Response
+    # A class responsible for proxing to faraday response
+    class Wrapper
+      extend Forwardable
+      include Pagination
+      include Enumerable
+
+      attr_reader :response
+      attr_reader :current_api
+      attr_reader :env
+
+      def_delegators :body, :empty?, :size, :include?, :length, :to_a, :first, :flatten, :include?, :keys, :[]
+
+      def initialize(response, current_api)
+        @response    = response
+        @current_api = current_api
+        @env         = response.env
+      end
+
+      # Request url
+      #
+      def url
+        response.env[:url].to_s
+      end
+
+      def body=(value)
+        @body = value
+        @env[:body] = value
+      end
+
+      # Response raw body
+      #
+      def body
+        @body ? @body : response.body
+      end
+
+      # Response status
+      #
+      def status
+        response.status
+      end
+
+      def success?
+        response.success?
+      end
+
+      def redirect?
+        status.to_i >= 300 && status.to_i < 400
+      end
+
+      def client_error?
+        status.to_i >= 400 && status.to_i < 500
+      end
+
+      def server_error?
+        status.to_i >= 500 && status.to_i < 600
+      end
+
+      # Return response headers
+      #
+      def headers
+        Nimbu::Response::Header.new(env)
+      end
+
+      # Lookup an attribute from the body if hash, otherwise behave like array index.
+      # Convert any key to string before calling.
+      #
+      def [](key)
+        if self.body.is_a?(Array)
+          self.body[key]
+        else
+          self.body.send(:"#{key}")
+        end
+      end
+
+      def last
+        self[self.length-1] if self.length.to_i > 0
+      end
+
+      # Return response body as string
+      #
+      def to_s
+        body.to_s
+      end
+
+      # Convert the ResponseWrapper into a Hash
+      #
+      def to_hash
+        body.to_hash
+      end
+
+      # Convert the ResponseWrapper into an Array
+      #
+      def to_ary
+        body.to_ary
+      end
+
+      # Iterate over each resource inside the body
+      #
+      def each
+        body_parts = self.body.respond_to?(:each) ? self.body : [self.body]
+        return body_parts.to_enum unless block_given?
+        body_parts.each { |part| yield(part) }
+      end
+
+      # Check if body has an attribute
+      #
+      def has_key?(key)
+        self.body.is_a?(Hash) && self.body.has_key?(key)
+      end
+
+      # Coerce any method calls for body attributes
+      #
+      def method_missing(method_name, *args, &block)
+        if self.has_key?(method_name.to_s)
+          self.[](method_name, &block)
+        else
+          super
+        end
+      end
+
+      # Check if method is defined on the body
+      #
+      def respond_to?(method_name)
+        if self.has_key?(method_name.to_s)
+          true
+        else
+          super
+        end
+      end
+
+      # Print only response body
+      #
+      def inspect
+        "#<#{self.class.name} @body=\"#{self.body}\">"
+      end
+
+      # Compare the wrapper with other wrapper for equality
+      #
+      def ==(other)
+        self.env == other.env &&
+        self.body == other.body
+      end
+    end # Wrapper
+  end # Response
+end # Nimbu

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module Nimbu
+  class Response::Xmlize < Response
+    dependency 'nokogiri'
+
+    define_parser do |body|
+      ::Nokogiri::XML body
+    end
+
+    def parse(body)
+      case body
+      when ''
+        nil
+      when 'true'
+        true
+      when 'false'
+        false
+      else
+        self.class.parser.call body
+      end
+    end
+  end # Response::Xmlize
+end # Nimbu

data/lib/nimbu-api/utils/all.rb

@@ -0,0 +1,6 @@
+require "nimbu-api/utils/constants"
+require "nimbu-api/utils/extend_array"
+require "nimbu-api/utils/extend_hash"
+require "nimbu-api/utils/json"
+require "nimbu-api/utils/url"
+require "nimbu-api/utils/descendants"

data/lib/nimbu-api/utils/constants.rb

@@ -0,0 +1,37 @@
+module Nimbu
+  module Utils
+    module Constants
+      extend self
+
+      # Response headers
+      RATELIMIT_REMAINING = 'X-RateLimit-Remaining'.freeze
+      RATELIMIT_LIMIT = 'X-RateLimit-Limit'.freeze
+      CONTENT_TYPE = 'Content-Type'.freeze
+      CONTENT_LENGTH = 'content-length'.freeze
+      CACHE_CONTROL = 'cache-control'.freeze
+      ETAG = 'ETag'.freeze
+      SERVER = 'Server'.freeze
+      DATE = 'Date'.freeze
+      LOCATION = 'Location'.freeze
+      USER_AGENT = 'User-Agent'.freeze
+      ACCEPT = 'Accept'.freeze
+      ACCEPT_CHARSET = 'Accept-Charset'.freeze
+      OAUTH_SCOPES = 'X-Oauth-Scopes'.freeze
+      ACCEPTED_OAUTH_SCOPES = 'X-Accepted-Oauth-Scopes'.freeze
+
+      # Link headers
+      HEADER_LINK = "Link".freeze
+      HEADER_NEXT = "X-Next".freeze
+      HEADER_LAST = "X-Last".freeze
+      META_REL = "rel".freeze
+      META_LAST = "last".freeze
+      META_NEXT = "next".freeze
+      META_FIRST = "first".freeze
+      META_PREV = "prev".freeze
+      PARAM_PAGE = "page".freeze
+      PARAM_PER_PAGE = "per_page".freeze
+      PARAM_START_PAGE = "start_page".freeze
+
+    end # Constants
+  end # Utils
+end # Nimbu

data/lib/nimbu-api/utils/descendants.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Nimbu
+  module Utils
+    module Descendants
+      def descendants
+        ObjectSpace.each_object(::Class).select { |klass| klass < self }
+      end
+    end
+  end
+end

data/lib/nimbu-api/utils/extend_array.rb

@@ -0,0 +1,17 @@
+class Array # :nodoc:
+
+  def except(*keys) # :nodoc:
+    self.dup.except!(*keys)
+  end unless method_defined?(:except)
+
+  def except!(*items) # :nodoc:
+    copy = self.dup
+    copy.reject! { |item| items.include? item }
+    copy
+  end unless method_defined?(:except!)
+
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+
+end # Array

data/lib/nimbu-api/utils/extend_hash.rb

@@ -0,0 +1,73 @@
+class Hash # :nodoc:
+
+  def except(*items) # :nodoc:
+    self.dup.except!(*items)
+  end unless method_defined?(:except)
+
+  def except!(*keys) # :nodoc:
+    copy = self.dup
+    keys.each { |key| copy.delete!(key) }
+    copy
+  end unless method_defined?(:except!)
+
+  def symbolize_keys  # :nodoc:
+    inject({}) do |hash, (key, value)|
+      hash[(key.to_sym rescue key) || key] = value
+      hash
+    end
+  end unless method_defined?(:symbolize_keys)
+
+  def symbolize_keys! # :nodoc:
+    hash = symbolize_keys
+    hash.each do |key, val|
+      hash[key] = case val
+        when Hash
+          val.symbolize_keys!
+        when Array
+          val.map do |item|
+            item.is_a?(Hash) ? item.symbolize_keys! : item
+          end
+        else
+          val
+        end
+    end
+    return hash
+  end unless method_defined?(:symbolize_keys!)
+
+  def serialize # :nodoc:
+    self.map { |key, val| [key, val].join("=") }.join("&")
+  end unless method_defined?(:serialize)
+
+  def all_keys # :nodoc:
+    keys = self.keys
+    keys.each do |key|
+      if self[key].is_a?(Hash)
+        keys << self[key].all_keys.compact.flatten
+        next
+      end
+    end
+    keys.flatten
+  end unless method_defined?(:all_keys)
+
+  def has_deep_key?(key)
+    self.all_keys.include? key
+  end unless method_defined?(:has_deep_key?)
+
+  def self.hash_traverse(hash, &block)
+    hash.each do |key, val|
+      block.call(key)
+      case val
+      when Hash
+        val.keys.each do |k|
+          _hash_traverse(val, &block)
+        end
+      when Array
+        val.each do |item|
+          _hash_traverse(item, &block)
+        end
+      end
+    end
+    return hash
+  end
+
+end # Hash

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'multi_json'
+
+module Nimbu
+  module Utils
+    module Json
+      extend self
+
+      def decode(*args)
+        if MultiJson.respond_to?(:load)
+          MultiJson.load(*args)
+        else
+          MultiJson.decode(*args)
+        end
+      end
+    end
+  end
+end

data/lib/nimbu-api/utils/url.rb

@@ -0,0 +1,56 @@
+require 'cgi'
+
+module Nimbu
+  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 # Nimbu