fanforce-api 0.31.0 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c6e98f070f07163c77ce43a3309a26ba8978c1e
+  data.tar.gz: 43909c75a46c9fb3767910ccf1d0f56d1c5b0c11
+SHA512:
+  metadata.gz: 3d2170fbe9bac57593b3489ec0a31cf34adead0911fba830f2b09f499f6722a74a0ef7c27d7108de5466885cdce73182ed7d17d471852b0e8fff0dc30f8d27b7
+  data.tar.gz: d7f1cec939937d5cc7b065888d46535db3d322ed6bcfe0f763772b670c0da8dd6184243673e060e0aafe62d99d8eba809f5466d2d19f69cf61f73136d80a1f0b

data/.ruby-version

@@ -1 +1 @@
-1.9.3-p194
+2.0.0-p576

data/.yardopts

@@ -0,0 +1,5 @@
+lib/**/*.rb
+--load ./.yardopts.rb
+--markup-provider=redcarpet
+--markup=markdown
+--readme README.md

data/.yardopts.rb

@@ -0,0 +1 @@
+require 'redcarpet/compat'

data/Gemfile

@@ -1,2 +1,11 @@
 source 'https://rubygems.org'
 gemspec
+
+group :development, :test do
+  gem 'minitest'
+  gem 'rack-test'
+  gem 'simplecov', :require => false
+  gem 'yard'
+  gem 'redcarpet'
+  gem 'github-markup', :require => true
+end

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Caleb Clark
+Copyright (c) 2014, The Fanforce Company
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,107 +1,28 @@
-## Install
-
-Via rubygems.org:
-
-```
-$ gem install fanforce
-```
-
-To build and install the development branch yourself from the latest source:
-
-```
-$ git clone git@github.com:mlabs/fanforce-ruby.git
-$ cd fanforce-ruby
-$ git checkout master
-$ rake gem
-$ gem install pkg/fanforce-{version}
-```
-
 ## Getting Started
 
-### Set It Up
+Add fanforce-api to your Gemfile
 
 ``` ruby
-require 'rubygems' # not necessary with ruby 1.9 but included for completeness
-require 'fanforce/api'
-
-# put your own credentials here
-api_key = 'ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
-
-# set up a client to talk to the Fanforce API
-ff = Fanforce::API.new api_key
+gem 'fanforce-api'
 ```
 
-### Making Your First Call
+Require fanforce/api and initialize an instance
 
 ``` ruby
-# get your api access info
-ff.get('/access_info', {})
-```
-
-## Full REST Access
-
-### GET
+require 'fanforce/api'
 
-``` ruby
-ff.get('/', {})
+# Initialize a new Fanforce::API instance with your api_key
+ff = Fanforce::API.new('00000000-0000-0000-0000-000000000000')
 ```
 
-### POST
+## Making Your First Call
 
-``` ruby
-ff.post('/', {})
-```
-
-### PUT
+Get your organization details...
 
 ``` ruby
-ff.put('/', {})
+ff.get('/organization')
 ```
 
-### DELETE
-
-``` ruby
-ff.delete('/')
-```
-
-## Error Handling
-
-```ruby
-begin
-    ff.get('/bad_page')
-rescue Fanforce::Error => e
-    puts e.curl_command
-end
-```
-
-e.curl_command
-e.response_code
-e.response_body
-e.request_url
-e.request_params
-
-BadRequestError
-
-## Utils
-
-ff.get_url(path, query_params)
-
-ff.curl_command(method, path, query_params)
-
-ff.validate_auth
-
-ff.to_query_string
-
-ff.compile_jquery_tmpls
-
-ff.decode_json
-
-ff.parse_url
-
-ff.remove_sensitive_params
-
-ff.remove_internal_params
-
 ## Handling Results
 
 response.result
@@ -112,6 +33,7 @@ response.current_results
 response.current_page
 response.total_pages
 
+
 ## Paging
 
 response.prev_url
@@ -121,12 +43,21 @@ response.next_url
 
 By default logging is turned off.
 ```ruby
-Fanforce.config do |config|
+Fanforce::API.config do |config|
   config.logging = true
 end
 ```
 
-For more info, see RestClient.logging.
+
+## Error Handling
+
+```ruby
+begin
+    ff.get('/nonexistent_method')
+rescue Fanforce::API::Error => e
+    puts e.curl_command
+end
+```
 
 ## More Information
 

data/Rakefile

@@ -3,14 +3,20 @@ require 'rake/testtask'
 require 'fileutils'
 include FileUtils
 
-# Default Rake task is compile
+task :run_test do
+  Rake::Task['test'].execute
+  puts '---------------------------------------------------------------------'
+  puts 'TESTS PASSED... READY TO BUILD...'
+  puts '---------------------------------------------------------------------'
+end
+task :build => :run_test
 task :default => :build
 
 ########################################################################
 
 Rake::TestTask.new do |t|
-  t.libs.push "lib"
-  t.libs.push "test"
+  t.libs.push 'lib'
+  t.libs.push 'test'
   t.pattern = 'test/**/*_test.rb'
   t.verbose = false
 end

data/fanforce-api.gemspec

@@ -8,17 +8,17 @@ Gem::Specification.new do |gem|
   gem.version     = Fanforce::API::VERSION
   gem.date        = Time.now.utc.strftime('%Y-%m-%d')
   gem.summary     = %q{Ruby API wrapper for Fanforce}
-  gem.description = %q{Ruby API wrapper that interfaces with all six Fanforce APIs.}
+
   gem.authors     = ['Caleb Clark']
   gem.email       = ['cclark@fanforce.com']
-  gem.homepage    = 'http://github.com/fanforce/fanforce-api-ruby'
+  gem.homepage    = 'http://github.com/fanforce/gem-fanforce-api'
 
   gem.files         = `git ls-files`.split($/)
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ['lib']
 
-  gem.add_runtime_dependency 'rest-client', '~> 1.6.7'
+  gem.add_runtime_dependency 'rest-client',   '~> 1.6.7'
+  gem.add_runtime_dependency 'uuid',          '~> 2.3.7'
 
-  gem.add_runtime_dependency 'fanforce-exceptions',  '~> 0.8'
-  gem.add_runtime_dependency 'fanforce-validations', '~> 0.8'
+  gem.add_runtime_dependency 'fanforce-base', '~> 1.0'
 end

data/lib/fanforce/api.rb

@@ -1,12 +1,8 @@
-class Fanforce
-  require 'fanforce'
-  require 'fanforce/errors'
-  require 'fanforce/domains'
-  class API
-    require_relative 'api/_main'
-    require_relative 'api/version'
-    require_relative 'api/error'
-  end
-  include Fanforce::Errors
-end
+require 'fanforce/base'
+
+require_relative 'api/version'
+require_relative 'api/utils'
+require_relative 'api/errors'
+require_relative 'api/response'
+require_relative 'api/main'
 

data/lib/fanforce/api/errors.rb

@@ -0,0 +1,24 @@
+class Fanforce::API::Error < StandardError
+  attr_accessor :response, :request, :requested_url, :requested_params, :errors
+
+  def initialize(message, response, request, requested_url, requested_params)
+    @response = response
+    @request = request
+    @requested_url = requested_url
+    @requested_params = requested_params
+    @message = message
+    super(message)
+  end
+
+  def curl_command
+    method = begin @request.method rescue nil end
+    Fanforce.curl_command(method, @requested_url, @requested_params)
+  end
+
+  def code;    @response.respond_to?(:code) ? @response.code : 500 end
+  def to_s;    @message end
+  def to_hash; {}  end
+end
+
+require_relative 'errors/server'
+require_relative 'errors/decoding'

data/lib/fanforce/api/errors/decoding.rb

@@ -0,0 +1,15 @@
+class Fanforce::API::Error::Decoding < Fanforce::API::Error
+
+  def initialize(e, response, request, requested_url, requested_params)
+    @message = "There was a Fanforce gem error while decoding JSON response (#{e.is_a?(String) ? e : e.message}): #{response.body}"
+    @errors = [{message: @message}]
+    super(@message, response, request, requested_url, requested_params)
+  end
+
+  def to_hash
+    {errors: @errors}
+  end
+
+  def code; 500 end
+
+end

data/lib/fanforce/api/errors/server.rb

@@ -0,0 +1,31 @@
+class Fanforce::API::Error::Server < Fanforce::API::Error
+
+  def initialize(response, request, requested_url, requested_params)
+    @response_body = response.to_s
+
+    if Fanforce.is_present?(response.body)
+      begin
+        @response_hash = MultiJson.load(response, symbolize_keys: true)
+        @errors = @response_hash[:errors]
+      rescue Exception => e
+        raise Fanforce::API::Error::Decoding.new(e, response, request, requested_url, requested_params)
+      end
+    else
+      @errors = [{message: "(Response body from #{response.code} error was empty: #{response.body})"}]
+    end
+
+    super(response.to_s, response, request, requested_url, requested_params)
+  end
+
+  def to_hash
+    @response_hash
+  end
+
+  def curl_command
+    method = begin @request.method rescue nil end
+    Fanforce.curl_command(method, @requested_url, @requested_params)
+  end
+
+  def code; @response.code end
+
+end

data/lib/fanforce/api/main.rb

@@ -0,0 +1,130 @@
+require 'rest-client'
+require 'uuid'
+
+class Fanforce::API
+  include Fanforce::API::Utils
+
+  # Initialize a new API connection
+  # @param auth_data [String,Hash] is a string of api_key or hash with api_key
+  def initialize(auth_data=nil)
+    set_auth(auth_data) if auth_data
+  end
+
+  # Get the raw url for a request
+  # @param path [String]
+  # @param req_params [Hash]
+  # @return [String] url
+  def raw_url(path, req_params={})
+    req_params = inject_auth_params(req_params)
+    "#{complete_url(path)}?#{to_query_string(req_params) if req_params.size > 0}"
+  end
+
+  # Get the CURL command for a request
+  # @param method [Symbol] (get/post/put/delete)
+  # @param path [String]
+  # @param params [Hash]
+  # @return [String] curl command
+  def curl_command(method, path, params={})
+    params = inject_auth_params(params)
+    Fanforce.curl_command(method, complete_url(path), params)
+  end
+
+  # Handles a GET request for Fanforce API
+  # @param path [String]
+  # @param params [Hash]
+  # @return [Fanforce::API::Response]
+  def get(path, params={})
+    params = inject_auth_params(params)
+    RestClient.get(url(path, params), :accept => :json) do |response, request, result, &block|
+      Fanforce::API::Response.process(response, request, complete_url(path), params)
+    end
+  end
+
+  # Handles a POST request for Fanforce API
+  # @param path [String]
+  # @param params [Hash]
+  # @return [Fanforce::API::Response]
+  def post(path, params={}, retries=0)
+    url = complete_url(path)
+    params = inject_auth_params(params) unless retries > 0
+    RestClient.post(url, MultiJson.dump(params), :content_type => :json, :accept => :json) do |response, request, result, &block|
+      if response.code == 400 and response.body == '{"error":"Invalid JSON"}' and retries <= 2
+        puts "retried #{path} #{retries+1} times"
+        post(path, params, retries+1)
+      else
+        Fanforce::API::Response.process(response, request, url, params)
+      end
+    end
+  end
+
+  # Handles a PUT request for Fanforce API
+  # @param path [String]
+  # @param params [Hash]
+  # @return [Fanforce::API::Response]
+  def put(path, params={}, retries=0)
+    url = complete_url(path)
+    params = inject_auth_params(params) unless retries > 0
+    RestClient.put(url, MultiJson.dump(params), :content_type => :json, :accept => :json) do |response, request, result, &block|
+      if response.code == 400 and response.body == '{"error":"Invalid JSON"}' and retries <= 2
+        puts "retried #{path} #{retries+1} times"
+        post(path, params, retries+1)
+      else
+        Fanforce::API::Response.process(response, request, url, params)
+      end
+    end
+  end
+
+  # Handles a DELETE request for Fanforce API
+  # @param path [String]
+  # @param params [Hash]
+  # @return [Fanforce::API::Response]
+  def delete(path, params={})
+    url = complete_url(path)
+    params = inject_auth_params(params)
+    RestClient.delete(url(path, params), :accept => :json) do |response, request, result, &block|
+      Fanforce::API::Response.process(response, request, url, params)
+    end
+  end
+
+  # Get the auth params for current instance
+  # @return [Hash] current auth params
+  def auth_params
+    @auth_params.clone
+  end
+
+  # Auth the current instance. Will raise error if api_key not found or is not of UUID format.
+  # @param auth_data [String, Hash] either an api_key string or a hash containing it
+  # @return [nil]
+  def set_auth(auth_data={})
+    auth_data = {} if is_blank?(auth_data)
+    if auth_data.is_a?(String)
+      @auth_params = {api_key: auth_data}
+    elsif auth_data.is_a?(Hash)
+      auth_data = symbolize_keys(auth_data)
+      @auth_params = {
+          api_key: auth_data[:api_key],
+          organization_id: auth_data[:organization_id]
+      }
+    end
+    raise 'api_key is required to auth Fanforce::API' if !has_valid_api_key?
+  end
+
+  # Check if current instance has a valid api_key
+  # @return [Boolean]
+  def has_valid_api_key?
+    is_present?(@auth_params) and is_present?(@auth_params[:api_key]) and UUID.validate(@auth_params[:api_key])
+  end
+  alias_method :has_valid_auth?, :has_valid_api_key?
+
+  ######################################################################
+  private
+
+  def inject_auth_params(params)
+    params.merge(@auth_params || {})
+  end
+
+  def complete_url(path)
+    'http://' + Fanforce.api_domain + path
+  end
+
+end

data/lib/fanforce/api/response.rb

@@ -3,113 +3,112 @@ class Fanforce::API::Response
 
   def self.process(response, request, requested_url, requested_params)
     return nil if response.code == 404 and request.method == :get
-    raise Fanforce::API::ServerError.new(response, request, requested_url, requested_params) if response.code > 201
+    raise Fanforce::API::Error::Server.new(response, request, requested_url, requested_params) if response.code > 201
 
-    begin  response_hash = Fanforce::Utils.decode_json(response)
-    rescue Exception => e; raise Fanforce::API::DecodingError.new(e, response, request, requested_url, requested_params) end
+    begin  response_hash = MultiJson.load(response, symbolize_keys: true)
+    rescue Exception => e; raise Fanforce::API::Error::Decoding.new(e, response, request, requested_url, requested_params) end
     if !response_hash.is_a?(Hash)
-      raise Fanforce::API::DecodingError.new('Server did not send a valid hash.', response, request, requested_url, requested_params)
+      raise Fanforce::API::Error::Decoding.new('Server did not send a valid hash.', response, request, requested_url, requested_params)
     elsif response_hash[:results]
-      Fanforce::API::Results.new(response_hash, response, request, requested_url, requested_params)
+      MultipleResults.new(response_hash, response, request, requested_url, requested_params)
     else
-      Fanforce::API::Result.new(response_hash, response, request, requested_url, requested_params)
+      SingleResult.new(response_hash, response, request, requested_url, requested_params)
     end
   end
 
-end
-
-class Fanforce::API::Result < Hash
-  attr_reader :requested_url, :requested_params
+  class MultipleResults < Array
+    attr_reader :requested_url, :requested_params
 
-  def initialize(response_hash, response, request, requested_url, requested_params)
-    @response = response
-    @request = request
-    @requested_url = requested_url
-    @requested_params = requested_params
-    @response_hash = response_hash
-    self.replace(response_hash)
-  end
+    def initialize(response_hash, response, request, requested_url, requested_params)
+      @response = response
+      @request = request
+      @requested_url = requested_url
+      @requested_params = requested_params
+      @response_hash = response_hash
+      self.replace(response_hash[:results])
+    end
 
-  def data
-    self
-  end
-  alias result data
+    def data
+      self
+    end
+    alias results data
 
-  def curl_command
-    @curl_command ||= Fanforce::Utils.curl_command(@request.method, @requested_url, @requested_params)
-  end
+    def curl_command
+      @curl_command ||= Fanforce.curl_command(@request.method, @requested_url, @requested_params)
+    end
 
-  def body;
-    @response.to_s
-  end
+    def body
+      @response.to_s
+    end
 
-  def current_results; 1   end
-  def total_results;   1   end
-  def current_page;    1   end
-  def total_pages;     1   end
-  def prev_page;       nil end
-  def next_page;       nil end
-  def prev_page_url;   nil end
-  def next_page_url;   nil end
-  def code; @response.code end
-end
+    def current_results
+      @current_results ||= @response_hash[:current_results]
+    end
 
-class Fanforce::API::Results < Array
-  attr_reader :requested_url, :requested_params
+    def total_results;
+      @total_results ||= @response_hash[:total_results]
+    end
 
-  def initialize(response_hash, response, request, requested_url, requested_params)
-    @response = response
-    @request = request
-    @requested_url = requested_url
-    @requested_params = requested_params
-    @response_hash = response_hash
-    self.replace(response_hash[:results])
-  end
+    def current_page;
+      @current_page ||= @response_hash[:current_page]
+    end
 
-  def data
-    self
-  end
-  alias results data
+    def total_pages;
+      @total_pages ||= @response_hash[:total_pages]
+    end
 
-  def curl_command
-    @curl_command ||= Fanforce::Utils.curl_command(@request.method, @requested_url, @requested_params)
-  end
+    def prev_page
+      @prev_page ||= (@request.method == :get and current_page > 1) ? current_page - 1 : nil
+    end
 
-  def body
-    @response.to_s
-  end
+    def next_page
+      @next_page ||= (@request.method == :get and total_pages > current_page) ? current_page + 1 : nil
+    end
 
-  def current_results
-    @current_results ||= @response_hash[:current_results]
-  end
+    def prev_page_url;
+      @prev_page_url ||= prev_page ? "#{@requested_url}?#{Fanforce.to_query_string(@requested_params.merge(page: current_page-1))}" : nil
+    end
 
-  def total_results;
-    @total_results ||= @response_hash[:total_results]
+    def next_page_url;
+      @next_page_url ||= next_page ? "#{@requested_url}?#{Fanforce.to_query_string(@requested_params.merge(page: current_page+1))}" : nil
+    end
+    def code; @response.code end
   end
 
-  def current_page;
-    @current_page ||= @response_hash[:current_page]
-  end
+  class SingleResult < Hash
+    attr_reader :requested_url, :requested_params
 
-  def total_pages;
-    @total_pages ||= @response_hash[:total_pages]
-  end
+    def initialize(response_hash, response, request, requested_url, requested_params)
+      @response = response
+      @request = request
+      @requested_url = requested_url
+      @requested_params = requested_params
+      @response_hash = response_hash
+      self.replace(response_hash)
+    end
 
-  def prev_page
-    @prev_page ||= (@request.method == :get and current_page > 1) ? current_page - 1 : nil
-  end
+    def data
+      self
+    end
+    alias result data
 
-  def next_page
-    @next_page ||= (@request.method == :get and total_pages > current_page) ? current_page + 1 : nil
-  end
+    def curl_command
+      @curl_command ||= Fanforce.curl_command(@request.method, @requested_url, @requested_params)
+    end
 
-  def prev_page_url;
-    @prev_page_url ||= prev_page ? "#{@requested_url}?#{Fanforce::Utils.to_query_string(@requested_params.merge(page: current_page-1))}" : nil
-  end
+    def body;
+      @response.to_s
+    end
 
-  def next_page_url;
-    @next_page_url ||= next_page ? "#{@requested_url}?#{Fanforce::Utils.to_query_string(@requested_params.merge(page: current_page+1))}" : nil
+    def current_results; 1   end
+    def total_results;   1   end
+    def current_page;    1   end
+    def total_pages;     1   end
+    def prev_page;       nil end
+    def next_page;       nil end
+    def prev_page_url;   nil end
+    def next_page_url;   nil end
+    def code; @response.code end
   end
-  def code; @response.code end
 
 end

data/lib/fanforce/api/utils.rb

@@ -1,10 +1,9 @@
-require 'fanforce/utils'
-
 module Fanforce::API::Utils
-  include Fanforce::Utils
-  extend Fanforce::API::Utils
+  extend self
   def self.included(base) base.extend(self) end
 
+  include Fanforce::Base::Utils
+
   def valid_fanforce_js_request?(params=@params)
     return false if !params.is_a?(Hash)
     return false if is_blank?(params[:organization_id]) or is_blank?(params[:api_key])
@@ -34,21 +33,4 @@ module Fanforce::API::Utils
     return true
   end
 
-  def remove_nil_values(hash)
-    hash.clone.delete_if {|k,v| v.nil? }
-  end
-
-  def collect_known_params(params)
-    params = symbolize_keys(params)
-    remove_nil_values(app_id: params[:app_id], organization_id: params[:organization_id], organization_slug: params[:organization_slug], api_key: params[:api_key], session_id: params[:session_id])
-  end
-
-  def remove_internal_params(params)
-    params.clone.delete_if { |k,v| [:app_id, :organization_id, :organization_slug, :api_key].include? k }
-  end
-
-  def remove_sensitive_params(params)
-    params.clone.delete_if { |k,v| [:api_key].include? k }
-  end
-
 end

data/lib/fanforce/api/version.rb

@@ -1,5 +1,5 @@
 class Fanforce
   class API
-    VERSION = '0.31.0'
+    VERSION = '1.0.0'
   end
 end

data/test/api/auth_test.rb

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

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'simplecov'
+SimpleCov.start { add_filter '/test/' }
+
+require 'rubygems'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'rack/test'
+
+ENV['RACK_ENV'] = 'test'
+
+require 'fanforce/api'

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: fanforce-api
 version: !ruby/object:Gem::Version
-  version: 0.31.0
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - Caleb Clark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-12 00:00:00.000000000 Z
+date: 2014-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,44 +20,39 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.6.7
 - !ruby/object:Gem::Dependency
-  name: fanforce-exceptions
+  name: uuid
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 2.3.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 2.3.7
 - !ruby/object:Gem::Dependency
-  name: fanforce-validations
+  name: fanforce-base
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.8'
-description: Ruby API wrapper that interfaces with all six Fanforce APIs.
+        version: '1.0'
+description: 
 email:
 - cclark@fanforce.com
 executables: []
@@ -68,41 +61,47 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .ruby-version
+- .yardopts
+- .yardopts.rb
 - Gemfile
 - LICENSE.md
 - README.md
 - Rakefile
 - fanforce-api.gemspec
 - lib/fanforce/api.rb
-- lib/fanforce/api/_main.rb
-- lib/fanforce/api/error.rb
+- lib/fanforce/api/errors.rb
+- lib/fanforce/api/errors/decoding.rb
+- lib/fanforce/api/errors/server.rb
+- lib/fanforce/api/main.rb
 - lib/fanforce/api/response.rb
 - lib/fanforce/api/utils.rb
 - lib/fanforce/api/version.rb
-- test/fanforce_test.rb
-homepage: http://github.com/fanforce/fanforce-api-ruby
+- test/api/auth_test.rb
+- test/test_helper.rb
+homepage: http://github.com/fanforce/gem-fanforce-api
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby API wrapper for Fanforce
 test_files:
-- test/fanforce_test.rb
+- test/api/auth_test.rb
+- test/test_helper.rb
+has_rdoc: 

data/lib/fanforce/api/_main.rb

@@ -1,111 +0,0 @@
-require 'rest-client'
-require_relative 'utils'
-require_relative 'response'
-
-class Fanforce::API
-  include Fanforce::API::Utils
-  include Fanforce::Errors
-
-  def initialize(arg={})
-    if arg.is_a?(Hash)
-      add_params(arg)
-      auth(@params) if @params.length > 0
-    elsif arg.is_a?(String)
-      auth(arg)
-    end
-  end
-
-  def params
-    @params ||= {}
-  end
-
-  def add_params(params_to_add)
-    params.merge!(collect_known_params params_to_add)
-  end
-
-  def url(path, req_params={})
-    req_params = apply_auth(req_params)
-    "#{complete_url(path)}?#{to_query_string(req_params)}"
-  end
-
-  def curl_command(method, path, req_params={})
-    req_params = apply_auth(req_params)
-    Fanforce::Utils.curl_command(method, complete_url(path), req_params)
-  end
-
-  def get(path, req_params={})
-    req_params = apply_auth(req_params)
-    RestClient.get(url(path, req_params), :accept => :json) do |response, request, result, &block|
-      Fanforce::API::Response.process(response, request, complete_url(path), req_params)
-    end
-  end
-
-  def post(path, req_params={}, retries=0)
-    url = complete_url(path)
-    req_params = apply_auth(req_params) unless retries > 0
-    RestClient.post(url, MultiJson.dump(req_params), :content_type => :json, :accept => :json) do |response, request, result, &block|
-      if response.code == 400 and response.body == '{"error":"Invalid JSON"}' and retries <= 2
-        puts "retried #{path} #{retries+1} times"
-        post(path, req_params, retries+1)
-      else
-        Fanforce::API::Response.process(response, request, url, req_params)
-      end
-    end
-  end
-
-  def put(path, req_params={}, retries=0)
-    url = complete_url(path)
-    req_params = apply_auth(req_params) unless retries > 0
-    RestClient.put(url, MultiJson.dump(req_params), :content_type => :json, :accept => :json) do |response, request, result, &block|
-      if response.code == 400 and response.body == '{"error":"Invalid JSON"}' and retries <= 2
-        puts "retried #{path} #{retries+1} times"
-        post(path, req_params, retries+1)
-      else
-        Fanforce::API::Response.process(response, request, url, req_params)
-      end
-    end
-  end
-
-  def delete(path, req_params={})
-    url = complete_url(path)
-    req_params = apply_auth(req_params)
-    RestClient.delete(url(path, req_params), :accept => :json) do |response, request, result, &block|
-      Fanforce::API::Response.process(response, request, url, req_params)
-    end
-  end
-
-  def identify(req_params)
-    post '/bie/identify', req_params
-  end
-
-  def track(com_behavior_id, req_params)
-    post '/bie/track', req_params.merge(com_behavior_id: com_behavior_id)
-  end
-
-  def recommend(com_behavior_id, unique_key, req_params={})
-    req_params.update(unique_key: "#{com_behavior_id}:#{unique_key}")
-    post '/bie/recommend', req_params
-  end
-
-  def auth(auth_data=nil)
-    @auth_hash ||= {}
-    return @auth_hash if is_blank?(auth_data)
-    auth_data = auth_data.is_a?(Hash) ? symbolize_keys(auth_data) : {api_key: auth_data.to_s}
-    @auth_hash.merge! remove_nil_values(api_key: auth_data[:api_key], organization_id: auth_data[:organization_id], organization_slug: auth_data[:organization_slug])
-    params.merge!(@auth_hash)
-    valid_auth?
-  end
-
-  def valid_auth?
-    is_present?(@auth_hash) and is_present?(@auth_hash[:api_key]) and is_present?(@auth_hash[:organization_id])
-  end
-
-  def apply_auth(req_params)
-    req_params.merge(@auth_hash || {})
-  end
-
-  def complete_url(path)
-    'http://' + Fanforce.api_domain + path
-  end
-
-end

data/lib/fanforce/api/error.rb

@@ -1,71 +0,0 @@
-require_relative 'utils'
-
-class Fanforce::API::Error < StandardError
-  attr_accessor :response, :request, :requested_url, :requested_params, :errors
-
-  def initialize(message, response, request, requested_url, requested_params)
-    @response = response
-    @request = request
-    @requested_url = requested_url
-    @requested_params = requested_params
-    @message = message
-    super(message)
-  end
-
-  def curl_command
-    method = begin @request.method rescue nil end
-    Fanforce::Utils.curl_command(method, @requested_url, @requested_params)
-  end
-
-  def code;    @response.respond_to?(:code) ? @response.code : 500 end
-  def to_s;    @message end
-  def to_hash; {}  end
-end
-
-class Fanforce::API::ServerError < Fanforce::API::Error
-
-  def initialize(response, request, requested_url, requested_params)
-    @response_body = response.to_s
-
-    if Fanforce::Utils.is_present?(response.body)
-      begin
-        @response_hash = Fanforce::Utils.decode_json(response)
-        @errors = @response_hash[:errors]
-      rescue Exception => e
-        raise Fanforce::API::DecodingError.new(e, response, request, requested_url, requested_params)
-      end
-    else
-      @errors = [{message: "(Response body from #{response.code} error was empty: #{response.body})"}]
-    end
-
-    super(response.to_s, response, request, requested_url, requested_params)
-  end
-
-  def to_hash
-    @response_hash
-  end
-
-  def curl_command
-    method = begin @request.method rescue nil end
-    Fanforce::Utils.curl_command(method, @requested_url, @requested_params)
-  end
-
-  def code; @response.code end
-
-end
-
-class Fanforce::API::DecodingError < Fanforce::API::Error
-
-  def initialize(e, response, request, requested_url, requested_params)
-    @message = "There was a Fanforce gem error while decoding JSON response (#{e.is_a?(String) ? e : e.message}): #{response.body}"
-    @errors = [{message: @message}]
-    super(@message, response, request, requested_url, requested_params)
-  end
-
-  def to_hash
-    {errors: @errors}
-  end
-
-  def code; 500 end
-
-end

data/test/fanforce_test.rb

@@ -1,22 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-
-$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'fanforce'
-
-describe Fanforce do
-
-  it 'should test if var is blank' do
-    assert Fanforce.is_blank?(nil)
-    assert !Fanforce.is_blank?("value")
-
-    ff = Fanforce.new
-    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