sweettooth 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c25d2dad930f01702ec9f332a73cd7a25cf7e509
+  data.tar.gz: c8b2668e549834d0f9be3b4202ac77986b88bf08
+SHA512:
+  metadata.gz: 603faf1752792593d0be4ff22d677d6bee812d69700f4baf062bd9f98404e39d5db6e37d4e31142e59d31042918749e69d7c6fe6d5f888955803a0281204db9e
+  data.tar.gz: eb20d0dea61cad5ba3e353fe7a191652f3eb87d4b28e07210ba199231507364d2ba2183070002e63de7dbd4e917af7d8e0a02bbc26b80bf6142f85f0aa649c96

data/.gitignore

@@ -0,0 +1,9 @@
+# Ignore gem stuff
+/.bundle
+/sweettooth-*.gem
+.rvmrc
+Gemfile.lock
+
+# Mac stuff
+.DS_Store
+

data/CONTRIBUTORS

@@ -0,0 +1 @@
+Bill Curtis <wcurtis@sweettoothhq.com>

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Sweet Tooth
+
+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.rdoc

@@ -0,0 +1,32 @@
+= Sweet Tooth Ruby bindings
+
+== Installation
+
+You can install the Sweet Tooth gem by running:
+
+  gem install sweettooth
+
+== Basic Usage
+
+  require "sweettooth"
+  SweetTooth.api_key = "sk_gUjtToMzKybHZ3yGg3C4Sv4L"
+
+  SweetTooth::Customer.create(
+    :first_name => "Wayne",
+    :last_name => "Rooney",
+    :email => "wrooney@example.com"
+  )
+
+== Requirements
+
+* Ruby 1.8.7 or above. (Ruby 1.8.6 may work if you load
+  ActiveSupport.)
+* rest-client, multi_json
+
+== Tests
+
+Test cases can be run with: `bundle exec rake test`
+
+== Acknowledgements
+
+Inspired by the Stripe Ruby bindings

data/Rakefile

@@ -0,0 +1,15 @@
+task :default => [:all]
+
+task :test do
+  ret = true
+  Dir["test/**/*_test.rb"].each do |f|
+    ret = ret && ruby(f, '')
+  end
+end
+
+task :all do
+  Rake::Task["test"].invoke
+  require 'active_support/all'
+  Rake::Task["test"].reenable
+  Rake::Task["test"].invoke
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/gemfiles/default-with-activesupport.gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+gemspec :path => File.join(File.dirname(__FILE__), "..")
+gem "activesupport", "~> 3.0"

data/gemfiles/json.gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+gemspec :path => File.join(File.dirname(__FILE__), "..")
+gem "json"
+gem "activesupport", "~> 3.0"

data/gemfiles/yajl.gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+gemspec :path => File.join(File.dirname(__FILE__), "..")
+gem "yajl-ruby"
+gem "activesupport", "~> 3.0"

data/lib/sweettooth.rb

@@ -0,0 +1,237 @@
+# Sweet Tooth Ruby bindings
+# API spec at https://www.sweettoothrewards.com/api/docs
+require 'cgi'
+require 'set'
+require 'openssl'
+require 'rest_client'
+require 'multi_json'
+require 'base64'
+
+# Version
+require 'sweettooth/version'
+
+# API operations
+require 'sweettooth/api_operations/create'
+require 'sweettooth/api_operations/update'
+require 'sweettooth/api_operations/delete'
+require 'sweettooth/api_operations/list'
+
+# Resources
+require 'sweettooth/util'
+require 'sweettooth/json'
+require 'sweettooth/sweettooth_object'
+require 'sweettooth/api_resource'
+require 'sweettooth/singleton_api_resource'
+require 'sweettooth/collection_object'
+require 'sweettooth/activity'
+require 'sweettooth/customer'
+require 'sweettooth/redemption'
+require 'sweettooth/redemption_option'
+
+# Errors
+require 'sweettooth/errors/sweettooth_error'
+require 'sweettooth/errors/api_error'
+require 'sweettooth/errors/api_connection_error'
+require 'sweettooth/errors/invalid_request_error'
+require 'sweettooth/errors/authentication_error'
+
+module SweetTooth
+  @api_base = 'https://api.sweettooth.io'
+
+  @verify_ssl_certs = true
+
+  class << self
+    attr_accessor :api_key, :api_base, :verify_ssl_certs, :api_version
+  end
+
+  def self.api_url(url='')
+    @api_base + url
+  end
+
+  def self.request(method, url, api_key, params={}, headers={})
+    unless api_key ||= @api_key
+      raise AuthenticationError.new('No API key provided. ' +
+        'Set your API key using "SweetTooth.api_key = <API-KEY>". ' +
+        'You can generate API keys from the Sweet Tooth web interface. ' +
+        'See https://www.sweettoothrewards.com/api for details, or email support@sweettoothhq.com ' +
+        'if you have any questions.')
+    end
+
+    if api_key =~ /\s/
+      raise AuthenticationError.new('Your API key is invalid, as it contains ' +
+        'whitespace. (HINT: You can double-check your API key from the ' +
+        'Sweet Tooth web interface. See https://www.sweettoothrewards.com/api for details, or ' +
+        'email support@sweettoothhq.com if you have any questions.)')
+    end
+
+    request_opts = { :verify_ssl => false }
+
+    params = Util.objects_to_ids(params)
+    url = api_url(url)
+
+    case method.to_s.downcase.to_sym
+    when :get, :head, :delete
+      # Make params into GET parameters
+      url += "#{URI.parse(url).query ? '&' : '?'}#{uri_encode(params)}" if params && params.any?
+      payload = nil
+    else
+      payload = uri_encode(params)
+    end
+
+    request_opts.update(:headers => request_headers(api_key).update(headers),
+                        :method => method, :open_timeout => 30,
+                        :payload => payload, :url => url, :timeout => 80)
+
+    begin
+      response = execute_request(request_opts)
+    rescue SocketError => e
+      handle_restclient_error(e)
+    rescue NoMethodError => e
+      # Work around RestClient bug
+      if e.message =~ /\WRequestFailed\W/
+        e = APIConnectionError.new('Unexpected HTTP response code')
+        handle_restclient_error(e)
+      else
+        raise
+      end
+    rescue RestClient::ExceptionWithResponse => e
+      if rcode = e.http_code and rbody = e.http_body
+        handle_api_error(rcode, rbody)
+      else
+        handle_restclient_error(e)
+      end
+    rescue RestClient::Exception, Errno::ECONNREFUSED => e
+      handle_restclient_error(e)
+    end
+
+    [parse(response), api_key]
+  end
+
+  private
+
+  def self.user_agent
+    @uname ||= get_uname
+    lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+    {
+      :bindings_version => SweetTooth::VERSION,
+      :lang => 'ruby',
+      :lang_version => lang_version,
+      :platform => RUBY_PLATFORM,
+      :publisher => 'sweettooth',
+      :uname => @uname
+    }
+
+  end
+
+  def self.get_uname
+    `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
+  rescue Errno::ENOMEM => ex # couldn't create subprocess
+    "uname lookup failed"
+  end
+
+  def self.uri_encode(params)
+    Util.flatten_params(params).
+      map { |k,v| "#{k}=#{Util.url_encode(v)}" }.join('&')
+  end
+
+  def self.request_headers(api_key)
+    headers = {
+      :user_agent => "SweetTooth/v1 RubyBindings/#{SweetTooth::VERSION}",
+      :authorization => "Basic " + Base64.encode64(api_key + ':'),
+      :content_type => 'application/x-www-form-urlencoded'
+    }
+
+    headers[:sweettooth_version] = api_version if api_version
+
+    begin
+      headers.update(:x_sweettooth_client_user_agent => SweetTooth::JSON.dump(user_agent))
+    rescue => e
+      headers.update(:x_sweettooth_client_raw_user_agent => user_agent.inspect,
+                     :error => "#{e} (#{e.class})")
+    end
+  end
+
+  def self.execute_request(opts)
+    RestClient::Request.execute(opts)
+  end
+
+  def self.parse(response)
+    begin
+      # Would use :symbolize_names => true, but apparently there is
+      # some library out there that makes symbolize_names not work.
+      response = SweetTooth::JSON.load(response.body)
+    rescue MultiJson::DecodeError
+      raise general_api_error(response.code, response.body)
+    end
+
+    Util.symbolize_names(response)
+  end
+
+  def self.general_api_error(rcode, rbody)
+    APIError.new("Invalid response object from API: #{rbody.inspect} " +
+                 "(HTTP response code was #{rcode})", rcode, rbody)
+  end
+
+  def self.handle_api_error(rcode, rbody)
+    begin
+      error_obj = SweetTooth::JSON.load(rbody)
+      error_obj = Util.symbolize_names(error_obj)
+      error = error_obj or raise SweetToothError.new # escape from parsing
+
+    rescue MultiJson::DecodeError, SweetToothError
+      raise general_api_error(rcode, rbody)
+    end
+
+    case rcode
+    when 400, 404
+      raise invalid_request_error error, rcode, rbody, error_obj
+    when 401
+      raise authentication_error error, rcode, rbody, error_obj
+    else
+      raise api_error error, rcode, rbody, error_obj
+    end
+
+  end
+
+  def self.invalid_request_error(error, rcode, rbody, error_obj)
+    InvalidRequestError.new(error[:message], error[:param], rcode,
+                            rbody, error_obj)
+  end
+
+  def self.authentication_error(error, rcode, rbody, error_obj)
+    AuthenticationError.new(error[:message], rcode, rbody, error_obj)
+  end
+
+  def self.api_error(error, rcode, rbody, error_obj)
+    APIError.new(error[:message], rcode, rbody, error_obj)
+  end
+
+  def self.handle_restclient_error(e)
+    case e
+    when RestClient::ServerBrokeConnection, RestClient::RequestTimeout
+      message = "Could not connect to Sweet Tooth (#{@api_base}). " +
+        "Please check your internet connection and try again. " +
+        "If this problem persists, you should check Sweet Tooth's service status at " +
+        "https://twitter.com/sweettoothstatus, or let us know at support@sweettoothhq.com."
+
+    when RestClient::SSLCertificateNotVerified
+      message = "Could not verify Sweet Tooth's SSL certificate. " +
+        "Please make sure that your network is not intercepting certificates. " +
+        "(Try going to https://api.sweettooth.io/v1 in your browser.) " +
+        "If this problem persists, let us know at support@sweettoothhq.com."
+
+    when SocketError
+      message = "Unexpected error communicating when trying to connect to Sweet Tooth. " +
+        "You may be seeing this message because your DNS is not working. " +
+        "To check, try running 'host sweettooth.io' from the command line."
+
+    else
+      message = "Unexpected error communicating with Sweet Tooth. " +
+        "If this problem persists, let us know at support@sweettoothhq.com."
+
+    end
+
+    raise APIConnectionError.new(message + "\n\n(Network error: #{e.message})")
+  end
+end

data/lib/sweettooth/account.rb

@@ -0,0 +1,4 @@
+module SweetTooth
+  class Account < SingletonAPIResource
+  end
+end

data/lib/sweettooth/activity.rb

@@ -0,0 +1,10 @@
+module SweetTooth
+  class Activity < APIResource
+
+    def self.class_name_plural
+      'Activities'
+    end
+
+    include SweetTooth::APIOperations::Create
+  end
+end

data/lib/sweettooth/api_operations/create.rb

@@ -0,0 +1,16 @@
+module SweetTooth
+  module APIOperations
+    module Create
+      module ClassMethods
+        def create(params={}, api_key=nil)
+          response, api_key = SweetTooth.request(:post, self.url, api_key, params)
+          Util.convert_to_sweettooth_object(response, api_key)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/sweettooth/api_operations/delete.rb

@@ -0,0 +1,11 @@
+module SweetTooth
+  module APIOperations
+    module Delete
+      def delete
+        response, api_key = SweetTooth.request(:delete, url, @api_key)
+        refresh_from(response, api_key)
+        self
+      end
+    end
+  end
+end

data/lib/sweettooth/api_operations/list.rb

@@ -0,0 +1,16 @@
+module SweetTooth
+  module APIOperations
+    module List
+      module ClassMethods
+        def all(filters={}, api_key=nil)
+          response, api_key = SweetTooth.request(:get, url, api_key, filters)
+          Util.convert_to_sweettooth_object(response, api_key)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/sweettooth/api_operations/update.rb

@@ -0,0 +1,57 @@
+module SweetTooth
+  module APIOperations
+    module Update
+      def save
+        values = serialize_params(self)
+
+        if @values[:metadata]
+          values[:metadata] = serialize_metadata
+        end
+
+        if values.length > 0
+          values.delete(:id)
+
+          response, api_key = SweetTooth.request(:post, url, @api_key, values)
+          refresh_from(response, api_key)
+        end
+        self
+      end
+
+      def serialize_metadata
+        if @unsaved_values.include?(:metadata)
+          # the metadata object has been reassigned
+          # i.e. as object.metadata = {key => val}
+          metadata_update = @values[:metadata]  # new hash
+          new_keys = metadata_update.keys.map(&:to_sym)
+          # remove keys at the server, but not known locally
+          keys_to_unset = @previous_metadata.keys - new_keys
+          keys_to_unset.each {|key| metadata_update[key] = ''}
+
+          metadata_update
+        else
+          # metadata is a SweetToothObject, and can be serialized normally
+          serialize_params(@values[:metadata])
+        end
+      end
+
+      def serialize_params(obj)
+        case obj
+        when nil
+          ''
+        when SweetToothObject
+          unsaved_keys = obj.instance_variable_get(:@unsaved_values)
+          obj_values = obj.instance_variable_get(:@values)
+          update_hash = {}
+
+          unsaved_keys.each do |k|
+            update_hash[k] = serialize_params(obj_values[k])
+          end
+
+          update_hash
+        else
+          obj
+        end
+      end
+    end
+  end
+end