fanforce 0.1.1

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+.DS_Store
+.idea/
+.idea/*

data/.rbenv-gemsets

@@ -0,0 +1 @@
+gemset-fanforce-ruby

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3-p194

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'multi_json'
+gem 'rest-client'
+
+group :development, :test do
+  gem 'rake'
+end

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    fanforce (0.1.1)
+      multi_json
+      rest-client
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    mime-types (1.19)
+    multi_json (1.3.6)
+    rake (0.9.2.2)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fanforce!
+  multi_json
+  rake
+  rest-client

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Caleb Clark
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,17 @@
+## 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-ruby-{version}
+```

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/ext/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+#$CFLAGS = "-Wall -Werror -Wextra"
+
+extension_name = 'pr_query_parser'
+dir_config(extension_name)
+
+have_library('curl', 'curl_easy_unescape')
+create_makefile(extension_name)

data/ext/pr_query_parser.c

@@ -0,0 +1,137 @@
+#include "ruby.h"
+
+#include <stdio.h>
+#include <ctype.h>
+#include <curl/curl.h>
+
+static void
+pr_set_param(VALUE params, char *key, char *value)
+{
+    VALUE rkey, rvalue, cur;
+    char *v;
+
+    /* no key do nothing */
+    if (key == NULL || *key == 0) return;
+
+    /* strip [] from the key name */
+    v = curl_easy_unescape(NULL, key, 0, NULL);
+    if (strlen(v) > 2)
+    {
+        char *t = v;
+        char *open_bracket = NULL;
+
+        while (*(t + 1) != 0)
+        {
+            if (*t == '[') open_bracket = t;
+            t++;
+        }
+
+        if ((*t == ']') && (open_bracket != NULL))
+        {
+            char *pos = (open_bracket + 1);
+            int is_digit = 1;
+
+            while (pos != t)
+            {
+                if (!isdigit(*pos))
+                {
+                    is_digit = 0;
+                    break;
+                }
+                pos ++;
+            }
+
+            if ((*t == ']') && (*(t - 1) == '['))
+            {
+                *(t - 1) = 0;
+            }
+            else if ((*t == ']') && (*open_bracket == '[') && is_digit)
+            {
+                *open_bracket = 0;
+            }
+        }
+    }
+
+    /* key was only [], do nothing */
+    if (v == NULL || *v == 0) return;
+
+    rkey = rb_str_new2(v);
+    free(v);
+
+    v = curl_easy_unescape(NULL, value, 0, NULL);
+    rvalue = rb_str_new2(v);
+    free(v);
+
+    cur = rb_hash_aref(params, rkey);
+    if (NIL_P(cur))
+    {
+        rb_hash_aset(params, rkey, rvalue);
+    }
+    else
+    {
+        VALUE arry;
+        if (rb_obj_is_kind_of(cur, rb_cArray)  == Qtrue)
+        {
+            arry = cur;
+        }
+        else
+        {
+            arry = rb_ary_new();
+            rb_ary_push(arry, cur);
+            rb_hash_aset(params, rkey, arry);
+        }
+        rb_ary_push(arry, rvalue);
+    }
+}
+
+VALUE
+pr_query_parser(VALUE self, VALUE query_string, VALUE delim)
+{
+    VALUE params = Qnil;
+    char *qs, *p, *s, *key = NULL;
+    char delimiter = RSTRING_PTR(delim)[0];
+
+    params = rb_hash_new();
+    qs = strdup(RSTRING_PTR(query_string));
+    for (s = qs, p = qs; *p != 0; p++)
+    {
+        if (*p == delimiter)
+        {
+            *p = 0;
+            if (key != NULL)
+            {
+                pr_set_param(params, key, s);
+                key = NULL;
+            }
+            else
+            {
+                pr_set_param(params, s, s);
+            }
+            s = (p + 1);
+        }
+        else if ((*p == '=') && (key == NULL))
+        {
+            *p = 0;
+            key = s;
+            s = (p + 1);
+        }
+    }
+
+    if (s != NULL)
+    {
+        if (key != NULL) pr_set_param(params, key, s);
+        else pr_set_param(params, s, s);
+    }
+    free(qs);
+
+    return params;
+    self = self;
+}
+
+void
+Init_pr_query_parser(void)
+{
+    VALUE QueryStringParser = rb_define_module("QueryStringParser");
+
+    rb_define_module_function(QueryStringParser, "pr_query_parser", pr_query_parser, 2);
+}

data/fanforce.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "fanforce/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "fanforce"
+  gem.version     = Fanforce::VERSION
+  gem.date        = '2012-10-19'
+  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/mlabs/fanforce-ruby"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.extensions = ["ext/extconf.rb", "ext/extconf.rb"]
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rake'
+  gem.add_runtime_dependency 'rest-client'
+  gem.add_runtime_dependency 'multi_json'
+end

data/lib/fanforce/config.rb

@@ -0,0 +1,14 @@
+class Fanforce
+  SERVERS = {
+      dev: 'api.fanforce.gg',
+      qa: 'api.fanforce.us',
+      prod: 'api.fanforce.com'
+  }
+
+  TEST_ACCOUNT = {
+      _id: '',
+      _slug: '',
+      _password: '',
+      _api_key: ''
+  }
+end

data/lib/fanforce/errors.rb

@@ -0,0 +1,39 @@
+class Fanforce
+  class Error < StandardError;
+    def initialize(response, request, path, query_params)
+      @query_params = query_params
+      @path = path
+      @request = request
+      begin
+        @response = MultiJson.load(response, :symbolize_keys => symbolize_keys)
+      rescue
+        @response = response
+      end
+      @request_url = "#{@path}?#{@query_params.to_param}"
+      super(@response.is_a?(Hash) ? @response[:message] : @response)
+    end
+    attr :path, :query_params, :request, :response, :request_url
+
+    def curl_command
+      case @request.method
+        when :get
+          "curl \"#{@path}?#{@query_params.to_param}\""
+        when :post
+          "curl -X POST -d \"#{@query_params.to_param}\" #{@path}"
+        when :put
+          "curl -X PUT -d \"#{@query_params.to_param}\" #{@path.to_json}"
+        when :delete
+          "curl --request DELETE \"#{@path}?#{@query_params.to_param}\""
+        else
+          "Could not create curl command because request method was unknown: #{@request.method}"
+      end
+    end
+    def code() end
+  end
+
+  class BadRequestError < Error;          def code() 400 end end
+  class ForbiddenError < Error;           def code() 403 end end
+  class NotFoundError < Error;            def code() 404 end end
+  class UnprocessableEntityError < Error; def code() 422 end end
+  class UnknownError < Error;             def code() 500 end end
+end

data/lib/fanforce/main.rb

@@ -0,0 +1,117 @@
+require 'fanforce/errors'
+require 'fanforce/utils'
+
+class Fanforce
+
+  ########################################################################
+  def initialize(auth_key_or_hash=nil)
+    auth(auth_key_or_hash) if auth_key_or_hash.present?
+  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)
+    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)
+    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)
+    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)
+    end
+  end
+
+  def handle_response(response, request, path, query)
+    case response.code
+      when 200, 201
+        begin
+          response = MultiJson.load(response, :symbolize_keys => symbolize_keys)
+        rescue
+          raise UnknownError.new(response, request, path, query)
+        end
+      when 400
+        raise BadRequestError.new(response, request, path, query)
+      when 403
+        raise ForbiddenError.new(response, request, path, query)
+      when 404
+        raise NotFoundError.new(response, request, path, query)
+      when 422
+        raise UnprocessableEntityError.new(response, request, path, query)
+      else
+        raise UnknownError.new(response, request, path, query)
+    end
+    response
+  end
+
+  def auth(auth_key_or_hash=nil)
+    if auth_key_or_hash.present?
+      key = auth_key_or_hash.is_a?(Hash) ? auth_key_or_hash.symbolize_keys[:key] : auth_key_or_hash
+      @auth_hash = {key: key} if key.present?
+    end
+    @auth_hash
+  end
+
+  def valid_auth?
+    @auth_hash.present? and @auth_hash[:key].present?
+  end
+
+  def apply_auth(params)
+    params.merge(@auth_hash || {})
+  end
+
+  def complete_path(path)
+    'http://' + $API_DOMAIN + path
+  end
+
+  def is_valid_install_request(params)
+    Utils.is_valid_install_request(params)
+  end
+
+  def is_invalid_install_request(params)
+    !is_valid_install_request(params)
+  end
+
+  def is_valid_uninstall_request(params)
+    Utils.is_valid_uninstall_request(params)
+  end
+
+  def is_invalid_uninstall_request(params)
+    !is_valid_uninstall_request(params)
+  end
+
+  def is_valid_request(params)
+    Utils.is_valid_request(params)
+  end
+
+  def is_invalid_request(params)
+    !is_valid_request(params)
+  end
+
+  def parse_params(params)
+    Utils.parse_params(params)
+  end
+
+  def parse_url(raw_url)
+    Utils.parse_url(raw_url)
+  end
+
+end

data/lib/fanforce/utils.rb

@@ -0,0 +1,85 @@
+require 'uri'
+require 'query_string_parser'
+
+module Fanforce::Utils
+
+  def self.blank?(obj)
+    obj.respond_to?(:empty?) ? obj.empty? : !obj
+  end
+
+  def self.present?(obj)
+    !blank?(obj)
+  end
+
+  def self.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 true
+  end
+
+  def self.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[:key])
+    return true
+  end
+
+  def self.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[:key])
+    return true
+  end
+
+  def self.parse_params(params)
+    if present?(params[:app_id])
+      plugin_type = :app
+      plugin_id = params[:app_id]
+    elsif present?(params[:behavior_id])
+      plugin_type = :behavior
+      plugin_id = params[:behavior_id]
+    elsif present?(params[:module_id])
+      plugin_type = :module
+      plugin_id = params[:module_id]
+    elsif present?(params[:widget_id])
+      plugin_type = :widget
+      plugin_id = params[:widget_id]
+    end
+    {:"#{plugin_type}_id" => params["#{plugin_type}_id"], plugin_type: plugin_type, plugin_id: plugin_id, fanforce_id: params[:fanforce_id], key: params[:key]}
+  end
+
+  def self.parse_url(raw_url)
+    return if 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)
+    _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)}"
+
+    { _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 self.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 * '&'
+    else
+      raise "params must be an Object, Hash, or Array"
+    end
+  end
+
+  def self.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)}"
+  end
+
+end

data/lib/fanforce/version.rb

@@ -0,0 +1,3 @@
+class Fanforce
+  VERSION = "0.1.1"
+end

data/lib/fanforce.rb

@@ -0,0 +1,5 @@
+class Fanforce
+end
+require 'fanforce/version'
+require 'fanforce/config'
+require 'fanforce/main'

data/lib/query_string_parser.rb

@@ -0,0 +1,13 @@
+require 'pr_query_parser'
+
+module QueryStringParser
+  module_function
+
+  def qs_parse(query_string, delim = '&')
+    return {} if query_string.nil? || query_string == ""
+
+    ret = (query_string + "\x20").force_encoding('UTF-8').encode('UTF-16', :invalid => :replace, :replace => '').encode('UTF-8')[0..-2]
+    pr_query_parser(ret, delim)
+  end
+
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: fanforce
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Caleb Clark
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby API wrapper that interfaces with all six Fanforce APIs.
+email:
+- cclark@fanforce.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rbenv-gemsets
+- .rbenv-version
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- ext/extconf.rb
+- ext/pr_query_parser.c
+- fanforce.gemspec
+- lib/fanforce.rb
+- lib/fanforce/config.rb
+- lib/fanforce/errors.rb
+- lib/fanforce/main.rb
+- lib/fanforce/utils.rb
+- lib/fanforce/version.rb
+- lib/query_string_parser.rb
+homepage: http://github.com/mlabs/fanforce-ruby
+licenses: []
+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
+signing_key: 
+specification_version: 3
+summary: Ruby API wrapper for Fanforce
+test_files: []