tamber 0.1.0

data/lib/tamber.rb

@@ -0,0 +1,202 @@
+# Tamber Ruby bindings
+# API spec at https://tamber.com/docs/api
+require 'cgi'
+require 'openssl'
+require 'rbconfig'
+require 'set'
+require 'socket'
+require 'base64'
+
+require 'rest-client'
+require 'json'
+
+require 'tamber/version'
+
+require 'tamber/api_operations/create'
+require 'tamber/api_operations/update'
+require 'tamber/api_operations/remove'
+require 'tamber/api_operations/retrieve'
+require 'tamber/api_operations/request'
+
+require 'tamber/tamber_object'
+require 'tamber/util'
+require 'tamber/api_resource'
+require 'tamber/discover'
+require 'tamber/event'
+require 'tamber/user'
+require 'tamber/item'
+require 'tamber/behavior'
+require 'tamber/property'
+
+
+require 'tamber/tamber_error'
+
+
+module Tamber
+  DEFAULT_CA_BUNDLE_PATH = File.dirname(__FILE__) + '/security/ca-bundle.crt'
+
+  @ca_bundle_path  = DEFAULT_CA_BUNDLE_PATH
+  @verify_ssl_certs = true
+
+  @api_url = 'https://api.tamber.com/v1'
+  @open_timeout = 30
+  @read_timeout = 80
+
+  class << self
+    attr_accessor :api_key, :api_base, :api_version, :verify_ssl_certs, :open_timeout, :read_timeout
+
+    # attr_reader :max_network_retry_delay, :initial_network_retry_delay
+  end
+
+
+  def self.api_url(api_base_url=nil, url='')
+    (api_base_url || @api_url) + url
+  end
+
+  def self.ca_bundle_path
+    @ca_bundle_path
+  end
+
+  def self.ca_bundle_path=(path)
+    @ca_bundle_path = path
+  end
+
+  def self.request(method, url, params={})
+    api_base_url = api_base_url || @api_base
+
+    unless api_key ||= @api_key
+      raise TamberError.new('No API key provided. ' \
+                            'Set your engine-specific API key using "Tamber.api_key = <ENGINE-API-KEY>". ' \
+                            'You can get your engine\'s api key from the Tamber dashboard. ' \
+                            'See https://dashboard.tamber.com to get your engine\'s key, or ' \
+                            'email support@tamber.com if you have any questions.)')
+    end
+
+    if api_key =~ /\s/
+      raise TamberError.new('Your API key is invalid, as it contains ' \
+                            'whitespace. (HINT: You can double-check your API key from the ' \
+                            'Tamber dashboard. See https://dashboard.tamber.com to get your engine\'s key, or ' \
+                            'email support@tamber.com if you have any questions.)')
+    end
+
+    if verify_ssl_certs
+      request_opts = {:verify_ssl => OpenSSL::SSL::VERIFY_PEER,
+                      :ssl_ca_file => @ca_bundle_path}
+    else
+      request_opts = {:verify_ssl => false}
+      unless @verify_ssl_warned
+        @verify_ssl_warned = true
+        $stderr.puts("WARNING: Running without SSL cert verification. " \
+                     "You should never do this in production. " \
+                     "Execute 'Tamber.verify_ssl_certs = true' to enable verification.")
+      end
+    end
+
+    # params = Util.objects_to_ids(params)
+    url = api_url(api_base_url,url)
+
+    case method.to_s.downcase.to_sym
+    when :get, :head, :delete
+      # Make params into GET parameters
+      url += "#{URI.parse(url).query ? '&' : '?'}#{Util.encode_parameters(params)}" if params && params.any?
+      payload = nil
+    else
+      payload = Util.encode_parameters(params)
+    end
+
+    request_opts.update(:headers => request_headers(api_key, method),
+                        :method => method, :open_timeout => open_timeout,
+                        :payload => payload, :url => url, :timeout => read_timeout)
+
+    response = execute_request_with_rescues(request_opts, api_base_url)
+
+    [parse(response)]
+  end
+
+
+
+  def self.request_headers(api_key, method)
+    encoded_key  = Base64.encode64(api_key + ':')
+    headers = {
+      :user_agent => "Tamber/v1 RubyBindings/#{Tamber::VERSION}",
+      :authorization => "Basic "+encoded_key,
+      :content_type => 'application/x-www-form-urlencoded'
+    }
+
+    headers[:tamber_version] = api_version if api_version
+
+    begin
+      headers.update(:x_tamber_client_user_agent => JSON.generate(user_agent))
+    rescue => e
+      headers.update(:x_tamber_client_raw_user_agent => user_agent.inspect,
+                     :error => "#{e} (#{e.class})")
+    end
+  end
+
+  def self.user_agent
+    lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+    {
+      :bindings_version => Tamber::VERSION,
+      :lang => 'ruby',
+      :lang_version => lang_version,
+      :platform => RUBY_PLATFORM,
+      :engine => defined?(RUBY_ENGINE) ? RUBY_ENGINE : '',
+      :publisher => 'tamber',
+      :hostname => Socket.gethostname,
+    }
+
+  end
+
+  def self.general_api_error(rbody)
+    TamberError.new("Invalid response object from API: "+rbody.inspect)
+  end
+
+  def self.execute_request(opts)
+    RestClient::Request.execute(opts)
+  end
+
+  def self.parse(response)
+    begin
+      response = JSON.parse(response.body)
+      if response["success"]
+        response = response["result"]
+      else
+        raise TamberError.new("Error: "+response["error"])
+      end
+    rescue JSON::ParserError
+      raise general_api_error(response.body)
+    end
+
+    Util.symbolize_names(response)
+  end
+
+  private
+
+  def self.execute_request_with_rescues(request_opts, api_base_url, retry_count = 0)
+    response = execute_request(request_opts)
+    # begin
+    #   response = execute_request(request_opts)
+    # rescue SocketError => e
+    #   response = handle_restclient_error(e, request_opts, retry_count, api_base_url)
+    # rescue NoMethodError => e
+    #   # Work around RestClient bug
+    #   if e.message =~ /\WRequestFailed\W/
+    #     e = APIConnectionError.new('Unexpected HTTP response code')
+    #     response = handle_restclient_error(e, request_opts, retry_count, api_base_url)
+    #   else
+    #     raise
+    #   end
+    # rescue RestClient::ExceptionWithResponse => e
+    #   if e.response
+    #     handle_api_error(e.response)
+    #   else
+    #     response = handle_restclient_error(e, request_opts, retry_count, api_base_url)
+    #   end
+    # rescue RestClient::Exception, Errno::ECONNREFUSED => e
+    #   response = handle_restclient_error(e, request_opts, retry_count, api_base_url)
+    # end
+
+    # response
+  end
+end

data/lib/tamber/api_operations/create.rb

@@ -0,0 +1,10 @@
+module Tamber
+  module APIOperations
+    module Create
+      def create(params={})
+        response = request(:post, url+"/create", params)
+        Util.convert_to_tamber_object(response)
+      end
+    end
+  end
+end

data/lib/tamber/api_operations/remove.rb

@@ -0,0 +1,10 @@
+module Tamber
+  module APIOperations
+    module Remove
+      def remove(params={})
+        response = request(:delete, url+"/remove", params)
+        # initialize_from(response, opts)
+      end
+    end
+  end
+end

data/lib/tamber/api_operations/request.rb

@@ -0,0 +1,21 @@
+module Tamber
+  module APIOperations
+    module Request
+      module ClassMethods
+        def request(method, url, params={})
+          response = Tamber.request(method, url, params)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      protected
+
+      def request(method, url, params={})
+        self.class.request(method, url, params)
+      end
+    end
+  end
+end

data/lib/tamber/api_operations/retrieve.rb

@@ -0,0 +1,10 @@
+module Tamber
+  module APIOperations
+    module Retrieve
+      def retrieve(params={})
+        response = request(:post, url+"/retrieve", params)
+        Util.convert_to_tamber_object(response)
+      end
+    end
+  end
+end

data/lib/tamber/api_operations/update.rb

@@ -0,0 +1,10 @@
+module Tamber
+  module APIOperations
+    module Update
+      def update(params={})
+        response = request(:post, url+"/update", params)
+        Util.convert_to_tamber_object(response)
+      end
+    end
+  end
+end

data/lib/tamber/api_resource.rb

@@ -0,0 +1,21 @@
+module Tamber
+  class APIResource < TamberObject
+    include Tamber::APIOperations::Request
+
+    def self.class_name
+      self.name.split('::')[-1]
+    end
+
+    def self.url
+      if self == APIResource
+        raise TamberError.new('APIResource is an abstract class.  You should perform actions on its subclasses (Event, Discover, etc.)')
+      end
+      "/#{CGI.escape(class_name.downcase)}"
+    end
+
+    def url
+      "#{self.class.url}"
+    end
+
+  end
+end

data/lib/tamber/behavior.rb

@@ -0,0 +1,6 @@
+module Tamber
+  class Behavior < APIResource
+    extend Tamber::APIOperations::Create
+    extend Tamber::APIOperations::Retrieve
+  end
+end

data/lib/tamber/discover.rb

@@ -0,0 +1,54 @@
+module Tamber
+  class Discover < APIResource
+
+    def self.recommended(params={})
+      response = request(:get, self.recommended_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    def self.similar(params={})
+      response = request(:get, self.similar_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    def self.recommendedSimilar(params={})
+      response = request(:get, self.recommendedSimilar_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    def self.popular(params={})
+      response = request(:get, self.popular_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    def self.hot(params={})
+      response = request(:get, self.hot_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    def self.recommended_url
+      url + '/recommended'
+    end
+
+    def self.similar_url
+      url + '/similar'
+    end
+
+    def self.recommendedSimilar_url
+      url + '/recommendedSimilar'
+    end
+
+    def self.popular_url
+      url + '/popular'
+    end
+
+    def self.hot_url
+      url + '/hot'
+    end
+
+  end
+
+  # Discover requests return an array of 'discovery' objects
+  class Discovery < TamberObject
+  end
+end

data/lib/tamber/event.rb

@@ -0,0 +1,24 @@
+module Tamber
+  class Event < APIResource
+
+    extend Tamber::APIOperations::Retrieve
+
+    def self.track_url
+      url + '/track'
+    end
+
+    def self.batch_url
+      url + '/batch'
+    end
+
+    def self.track(params={})
+      response = request(:post, self.track_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    def self.batch(params={})
+      response = request(:post, self.batch_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+  end
+end

data/lib/tamber/item.rb

@@ -0,0 +1,8 @@
+module Tamber
+  class Item < APIResource
+    extend Tamber::APIOperations::Create
+    extend Tamber::APIOperations::Update
+    extend Tamber::APIOperations::Retrieve
+    extend Tamber::APIOperations::Remove
+  end
+end

data/lib/tamber/property.rb

@@ -0,0 +1,6 @@
+module Tamber
+  class Property < APIResource
+    extend Tamber::APIOperations::Create
+    extend Tamber::APIOperations::Retrieve
+  end
+end

data/lib/tamber/tamber_error.rb

@@ -0,0 +1,10 @@
+module Tamber
+  class TamberError < StandardError
+    attr_reader :message
+
+    def initialize(message=nil)
+      @message = message
+    end
+
+  end
+end

data/lib/tamber/tamber_object.rb

@@ -0,0 +1,35 @@
+module Tamber
+  class TamberObject
+
+    def initialize(values={})
+      values.each do |k,v|
+        val = self.class.curvert(v)
+        self.instance_variable_set("@#{k}", val)
+        self.singleton_class.send(:attr_accessor, k)
+      end
+    end
+
+    def self.construct_from(values)
+      values = Tamber::Util.symbolize_names(values)
+      self.new(values)
+    end
+
+    def self.curvert(values={})
+      case values
+      when Hash
+        if values.has_key?(:object)
+          Tamber::Util.object_classes.fetch(values[:object],TamberObject).new(values)
+        else
+          values.each do |k,v|
+            values[k] = curvert(v)
+          end
+        end
+      when Array
+        values.map { |i| curvert(i) }
+      else
+        values
+      end
+    end
+
+  end
+end