mambanation 0.1.29 → 0.1.30

data/VERSION.yml

@@ -2,4 +2,4 @@
 :major: 0
 :build: 
 :minor: 1
-:patch: 29
+:patch: 30

data/lib/mambanation.rb

@@ -1,74 +1,120 @@
+require "forwardable"
+require "hashie"
+require "httparty"
+require "yajl"
+
 module MambaNation
-  class Request
-    extend Forwardable
+  include HTTParty
+  API_VERSION = "2".freeze
+  
+  class MambaNationError < StandardError
+    attr_reader :data
     
-    def self.get(client, path, options={})
-      new(client, :get, path, options).perform
+    def initialize(data)
+      @data = data
+      super
     end
-    
-    def self.post(client, path, options={})
-      new(client, :post, path, options).perform
-    end
-    
-    def self.put(client, path, options={})
-      options[:body] ||= ""
-      new(client, :put, path, options).perform
-    end
-    
-    def self.delete(client, path, options={})
-      new(client, :delete, path, options).perform
-    end
-    
-    attr_reader :client, :method, :path, :options
-    
-    def_delegators :client, :get, :post, :put, :delete
-    
-    def initialize(client, method, path, options={})
-      @client, @method, @path, @options = client, method, path, options
-    end
-    
-    def uri
-      @uri ||= begin
-        uri = URI.parse(path)
-        
-        if options[:query] && options[:query] != {}
-          uri.query = to_query(options[:query])
-        end
-        
-        uri.to_s
-      end
-    end
-    
-    def perform
-      MambaNation.make_friendly(send("perform_#{method}"))
-    end
-    
-    private
-    
-    def perform_get
-      get(uri, options[:headers])
+  end
+  
+  class RateLimitExceeded < MambaNationError; end
+  class Unauthorized      < MambaNationError; end
+  class General           < MambaNationError; end
+  
+  class Unavailable       < StandardError; end
+  class InformMambaNation < StandardError; end
+  class NotFound          < StandardError; end
+  
+  def self.api_endpoint
+    @api_endpoint ||= "api.mambanation.com"
+  end
+  
+  def self.api_endpoint=(value)
+    @api_endpoint = value
+  end
+  
+  private
+  
+  def self.perform_get(uri, options = {})
+    base_uri(self.api_endpoint)
+    make_friendly(get(uri, options))
+  end
+  
+  def self.make_friendly(response)
+    raise_errors(response)
+    data = parse(response)
+    # Don't mash arrays of integers
+    if data && data.is_a?(Array) && data.first.is_a?(Integer)
+      data
+    else
+      mash(data)
     end
-    
-    def perform_post
-      post(uri, options[:body], options[:headers])
+  end
+  
+  def self.raise_errors(response)
+    case response.code.to_i
+      when 400
+        data = parse(response)
+        raise RateLimitExceeded.new(data), "(#{response.code}): #{response.message} - #{data['error'] if data}"
+      when 401
+        data = parse(response)
+        raise Unauthorized.new(data), "(#{response.code}): #{response.message} - #{data['error'] if data}"
+      when 403
+        data = parse(response)
+        raise General.new(data), "(#{response.code}): #{response.message} - #{data['error'] if data}"
+      when 404
+        raise NotFound, "(#{response.code}): #{response.message}"
+      when 500
+        raise InformMambaNation, "MambaNation had an internal error. Please let them know in the group. (#{response.code}): #{response.message}"
+      when 502..503
+        raise Unavailable, "(#{response.code}): #{response.message}"
     end
-    
-    def perform_put
-      put(uri, options[:body], options[:headers])
+  end
+  
+  def self.parse(response)
+    Yajl::Parser.parse(response.body)
+  end
+  
+  def self.mash(obj)
+    if obj.is_a?(Array)
+      obj.map{|item| make_mash_with_consistent_hash(item)}
+    elsif obj.is_a?(Hash)
+      make_mash_with_consistent_hash(obj)
+    else
+      obj
     end
-    
-    def perform_delete
-      delete(uri, options[:headers])
+  end
+  
+  # Lame workaround for the fact that mash doesn't hash correctly
+  def self.make_mash_with_consistent_hash(obj)
+    m = Hashie::Mash.new(obj)
+    def m.hash
+      inspect.hash
     end
-    
-    def to_query(options)
-      options.inject([]) do |collection, opt|
-        collection << case opt[1].class.to_s
-          when "Array" then opt[1].map { |value| "#{opt[0]}[]=#{value}" }.join('&')
-          else "#{opt[0]}=#{opt[1]}"
-        end
-        collection
-      end * '&'
+    return m
+  end
+
+end
+
+module Hashie
+  class Mash
+
+    # Converts all of the keys to strings, optionally formatting key name
+    def rubyify_keys!
+      keys.each{|k|
+        v = delete(k)
+        new_key = k.to_s.underscore
+        self[new_key] = v
+        v.rubyify_keys! if v.is_a?(Hash)
+        v.each{|p| p.rubyify_keys! if p.is_a?(Hash)} if v.is_a?(Array)
+      }
+      self
     end
+
   end
-end
+end
+
+directory = File.expand_path(File.dirname(__FILE__))
+
+require File.join(directory, "mambanation", "base")
+require File.join(directory, "mambanation", "httpauth")
+require File.join(directory, "mambanation", "request")

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mambanation
 version: !ruby/object:Gem::Version 
-  hash: 33
+  hash: 39
   prerelease: false
   segments: 
   - 0
   - 1
-  - 29
-  version: 0.1.29
+  - 30
+  version: 0.1.30
 platform: ruby
 authors: 
 - "J\xC3\xA9r\xC3\xA9my Van de Wyngaert"