fanforce 0.2.0 → 0.2.2

data/README.md

@@ -14,4 +14,70 @@ $ cd fanforce-ruby
 $ git checkout master
 $ rake gem
 $ gem install pkg/fanforce-{version}
-```
+```
+
+## Getting Started
+
+### Set It Up
+
+``` ruby
+require 'rubygems' # not necessary with ruby 1.9 but included for completeness
+require 'fanforce'
+
+# put your own credentials here
+api_key = 'ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+
+# set up a client to talk to the Fanforce API
+@ff = Fanforce.new api_key
+```
+
+### Making Your First Call
+
+``` ruby
+# get your api access info
+@ff.get('/access_info', {})
+```
+
+## Full REST Access
+
+### GET
+
+``` ruby
+ff.get('/', {})
+```
+
+### POST
+
+``` ruby
+ff.post('/', {})
+```
+
+### PUT
+
+``` ruby
+ff.put('/', {})
+```
+
+### DELETE
+
+``` ruby
+ff.delete('/')
+```
+
+## Error Handling
+
+begin
+
+rescue Fanforce::Error => e
+
+end
+
+e.curl_command
+e.response_code
+e.response_body
+e.request_url
+e.request_params
+
+## More Information
+
+Visit the Fanforce Developers site to explore the full API access methods available.

data/lib/fanforce/main.rb

@@ -6,82 +6,89 @@ class Fanforce
   include Fanforce::Utils
 
   ########################################################################
-  def initialize(auth_key_or_hash=nil)
-    auth(auth_key_or_hash) if present?(auth_key_or_hash)
+  def initialize(auth_data=nil)
+    auth(auth_data) if is_present?(auth_data)
   end
 
-  def get(path, requestParams={})
-    path = complete_path(path)
-    query = apply_auth(requestParams)
-    RestClient.get(path, {:params => query, :accept => :json}) do |response, request, result, &block|
-      handle_response(response, request, path, query)
+  def get(path, params={})
+    url = complete_url(path)
+    params = apply_auth(params)
+    RestClient.get(url, {:params => params, :accept => :json}) do |response, request, result, &block|
+      handle_response(response, request, url, params)
     end
   end
 
-  def post(path, requestParams={})
-    path = complete_path(path)
-    query = apply_auth(requestParams)
-    RestClient.post(path, query, {:accept => :json}) do |response, request, result, &block|
-      handle_response(response, request, path, query)
+  def get_url(path, params={})
+    url = complete_url(path)
+    params = apply_auth(params)
+    "#{url}?#{to_query_string(params)}"
+  end
+
+  def post(path, params={})
+    url = complete_url(path)
+    params = apply_auth(params)
+    RestClient.post(url, params, {:accept => :json}) do |response, request, result, &block|
+      handle_response(response, request, url, params)
     end
   end
 
-  def put(path, requestParams={})
-    path = complete_path(path)
-    query = apply_auth(requestParams)
-    RestClient.put(path, query, {:accept => :json}) do |response, request, result, &block|
-      handle_response(response, request, path, query)
+  def put(path, params={})
+    url = complete_url(path)
+    params = apply_auth(params)
+    RestClient.put(url, params, {:accept => :json}) do |response, request, result, &block|
+      handle_response(response, request, url, params)
     end
   end
 
-  def delete(path, requestParams={})
-    path = complete_path(path)
-    query = apply_auth(requestParams)
-    RestClient.delete(path, {:query => query, :accept => :json}) do |response, request, result, &block|
-      handle_response(response, request, path, query)
+  def delete(path, params={})
+    url = complete_url(path)
+    params = apply_auth(url)
+    RestClient.delete(url, {:query => params, :accept => :json}) do |response, request, result, &block|
+      handle_response(response, request, url, params)
     end
   end
 
-  def handle_response(response, request, path, query)
+  def handle_response(response, request, url, params)
     case response.code
       when 200, 201
         begin
           response = decode_json(response)
         rescue
-          raise UnknownError.new(response, request, path, query)
+          raise UnknownError.new(response, request, url, params)
         end
       when 400
-        raise BadRequestError.new(response, request, path, query)
+        raise BadRequestError.new(response, request, url, params)
       when 403
-        raise ForbiddenError.new(response, request, path, query)
+        raise ForbiddenError.new(response, request, url, params)
       when 404
-        raise NotFoundError.new(response, request, path, query)
+        raise NotFoundError.new(response, request, url, params)
       when 422
-        raise UnprocessableEntityError.new(response, request, path, query)
+        raise UnprocessableEntityError.new(response, request, url, params)
       else
-        raise UnknownError.new(response, request, path, query)
+        raise UnknownError.new(response, request, url, params)
     end
     response
   end
 
-  def auth(auth_hash=nil)
-    if present?(auth_hash)
-      auth_hash = auth_hash.is_a?(Hash) ? auth_hash.symbolize_keys : {api_key: auth_hash}
-      @auth_hash[:api_key] if present?(auth_hash[:api_key])
-      @auth_hash[:fanforce_id] if present?(auth_hash[:fanforce_id])
+  def auth(auth_data=nil)
+    if is_present?(auth_data)
+      auth_data = auth_data.is_a?(Hash) ? auth_data.symbolize_keys : {api_key: auth_data.to_s}
+      @auth_hash ||= {}
+      @auth_hash[:api_key] = auth_data[:api_key] if is_present?(auth_data[:api_key])
+      @auth_hash[:fanforce_id] = auth_data[:fanforce_id] if is_present?(auth_data[:fanforce_id])
     end
     @auth_hash
   end
 
   def valid_auth?
-    present?(@auth_hash) and present?(@auth_hash[:api_key])
+    is_present?(@auth_hash) and is_present?(@auth_hash[:api_key])
   end
 
   def apply_auth(params)
     params.merge(@auth_hash || {})
   end
 
-  def complete_path(path)
+  def complete_url(path)
     'http://' + $API_DOMAIN + path
   end
 

data/lib/fanforce/utils.rb

@@ -4,48 +4,48 @@ require 'query_string_parser'
 module Fanforce::Utils
   def self.included(base) base.extend(self)  end
 
-  def blank?(obj)
+  def is_blank?(obj)
     obj.respond_to?(:empty?) ? obj.empty? : !obj
   end
 
-  def present?(obj)
-    !blank?(obj)
+  def is_present?(obj)
+    !is_blank?(obj)
   end
 
   def valid_request?(params)
     return false if !params.is_a?(Hash)
-    return false if blank?(params[:fanforce_id])
-    return false if blank?(params[:app_id]) and blank?(params[:behavior_id]) and blank?(params[:module_id]) and blank?(params[:widget_id])
+    return false if is_blank?(params[:fanforce_id])
+    return false if is_blank?(params[:app_id]) and is_blank?(params[:behavior_id]) and is_blank?(params[:module_id]) and is_blank?(params[:widget_id])
     return true
   end
 
   def valid_install_request?(params)
     return false if !params.is_a?(Hash)
-    return false if blank?(params[:fanforce_id])
-    return false if blank?(params[:app_id]) and blank?(params[:behavior_id]) and blank?(params[:module_id]) and blank?(params[:widget_id])
-    return false if blank?(params[:api_key])
+    return false if is_blank?(params[:fanforce_id])
+    return false if is_blank?(params[:app_id]) and is_blank?(params[:behavior_id]) and is_blank?(params[:module_id]) and is_blank?(params[:widget_id])
+    return false if is_blank?(params[:api_key])
     return true
   end
 
   def valid_uninstall_request?(params)
     return false if !params.is_a?(Hash)
-    return false if blank?(params[:fanforce_id])
-    return false if blank?(params[:app_id]) and blank?(params[:behavior_id]) and blank?(params[:module_id]) and blank?(params[:widget_id])
-    return false if blank?(params[:api_key])
+    return false if is_blank?(params[:fanforce_id])
+    return false if is_blank?(params[:app_id]) and is_blank?(params[:behavior_id]) and is_blank?(params[:module_id]) and is_blank?(params[:widget_id])
+    return false if is_blank?(params[:api_key])
     return true
   end
 
   def parse_params(params)
-    if present?(params[:app_id])
+    if is_present?(params[:app_id])
       plugin_type = :app
       plugin_id = params[:app_id]
-    elsif present?(params[:behavior_id])
+    elsif is_present?(params[:behavior_id])
       plugin_type = :behavior
       plugin_id = params[:behavior_id]
-    elsif present?(params[:module_id])
+    elsif is_present?(params[:module_id])
       plugin_type = :module
       plugin_id = params[:module_id]
-    elsif present?(params[:widget_id])
+    elsif is_present?(params[:widget_id])
       plugin_type = :widget
       plugin_id = params[:widget_id]
     end
@@ -53,34 +53,47 @@ module Fanforce::Utils
   end
 
   def parse_url(raw_url)
-    return if blank?(raw_url)
+    return if is_blank?(raw_url)
     url = URI::parse(raw_url)
     query_params = QueryStringParser.qs_parse(url.query).inject({}) do |result, (k,v)|
       result[k] = v if k !~ /^ff_.+/
       result
     end
-    query_string = to_query_string(Hash[query_params.sort]) if present?(query_params)
+    query_string = to_query_string(Hash[query_params.sort]) if is_present?(query_params)
     _external_id = url.host + url.path
-    clean_url = "#{url.scheme}://#{url.host}#{(if ![80,443].include?(url.port) then ":#{url.port}" end)}#{url.path}#{(if present?(query_string) then "?#{query_string}" end)}"
+    clean_url = "#{url.scheme}://#{url.host}#{(if ![80,443].include?(url.port) then ":#{url.port}" end)}#{url.path}#{(if is_present?(query_string) then "?#{query_string}" end)}"
 
     { _external_id: _external_id, clean_url: clean_url, raw_url: raw_url, query_params: query_params, query_string: query_string, scheme: url.scheme, host: url.host, port: url.port, path: url.path, fragment: url.fragment }
   end
 
-  def to_query_string(params, namespace = nil)
-    if params.is_a?(String)
-      params
-    elsif params.is_a?(Array)
-      params.collect { |value| to_query_chunk(value, "#{namespace}[]") }.join '&'
-    elsif params.is_a?(Hash)
-      params.collect { |key, value| to_query_chunk(value, namespace ? "#{namespace}[#{key}]" : key) }.sort * '&'
+  def to_query_string(obj, namespace=nil)
+    return '' if is_blank?(obj)
+    if obj.is_a?(Array)
+      obj.collect { |value| to_query_string(value, "#{namespace}[]") }.join '&'
+    elsif obj.is_a?(Hash)
+      obj.collect { |key, value| to_query_string(value, namespace ? "#{namespace}[#{key}]" : key) }.sort * '&'
+    elsif obj.is_a?(Object)
+      require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+      "#{CGI.escape(to_param(namespace))}=#{CGI.escape(to_param(obj).to_s)}"
     else
-      raise "params must be an Object, Hash, or Array"
+      raise "Argument must be an object, hash, or array; instead it was a #{obj.class}"
     end
   end
 
-  def to_query_chunk(value,key)
-    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
-    "#{CGI.escape(to_query_string(key))}=#{CGI.escape(to_query_string(value).to_s)}"
+  def to_param(obj, namespace=nil)
+    if obj.is_a?(Object)
+      obj.to_s
+    elsif obj.is_a?(Array)
+      collect { |e| e.to_param }.join '/'
+    elsif obj.is_a?(Hash)
+      to_query_string(obj, namespace)
+    elsif obj.is_a?(NilClass)
+      obj
+    elsif obj.is_a?(TrueClass)
+      obj
+    elsif obj.is_a?(FalseClass)
+      obj
+    end
   end
 
   def decode_json(str, symbolize_keys=true)

data/lib/fanforce/version.rb

@@ -1,3 +1,3 @@
 class Fanforce
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

data/test/fanforce_test.rb

@@ -7,12 +7,16 @@ require 'fanforce'
 describe Fanforce do
 
   it "should test if var is blank" do
-    assert Fanforce.blank?(nil)
-    assert !Fanforce.blank?("value")
+    assert Fanforce.is_blank?(nil)
+    assert !Fanforce.is_blank?("value")
 
     ff = Fanforce.new
-    assert ff.blank?(nil)
-    assert !ff.blank?("value")
+    assert ff.is_blank?(nil)
+    assert !ff.is_blank?("value")
+  end
+
+  it "should create new instance of fanforce with api_key" do
+    Fanforce.new('13d90b01-6df7-4618-881c-c79320a0dc21')
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fanforce
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors: