tamber 0.1.6 → 0.1.7

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(:get, 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(:get, 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,81 @@
+module Tamber
+  class Discover < APIResource
+
+    def self.next(params={})
+      response = request(:get, self.next_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    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.uac(params={})
+      response = request(:get, self.uac_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    def self.new(params={})
+      response = request(:get, self.new_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 + '/recommended_similar'
+    end
+
+    def self.next_url
+      url + '/next'
+    end
+
+    def self.popular_url
+      url + '/popular'
+    end
+
+    def self.hot_url
+      url + '/hot'
+    end
+
+    def self.uac_url
+      url + '/uac'
+    end
+
+    def self.new_url
+      url + '/new'
+    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,37 @@
+module Tamber
+  class Item < APIResource
+    extend Tamber::APIOperations::Create
+    extend Tamber::APIOperations::Update
+    extend Tamber::APIOperations::Retrieve
+
+    # hide an item from all Discover results
+    def self.hide(params={})
+      response = request(:post, self.hide_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    # un-hide an item from all Discover results
+    def self.unhide(params={})
+      response = request(:post, self.unhide_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    # permenantly delete an item and all associated events
+    def self.delete(params={})
+      response = request(:post, self.delete_url, params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    def self.hide_url
+      url + '/hide'
+    end
+
+    def self.unhide_url
+      url + '/unhide'
+    end
+
+    def self.delete_url
+      url + '/delete'
+    end
+  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

data/lib/tamber/user.rb

@@ -0,0 +1,18 @@
+module Tamber
+  class User < APIResource
+    extend Tamber::APIOperations::Create
+    extend Tamber::APIOperations::Update
+    extend Tamber::APIOperations::Retrieve
+
+    def self.search(params={})
+      response = request(:post, url + '/search', params)
+      Util.convert_to_tamber_object(response)
+    end
+
+    def self.merge(params={})
+      response = request(:post, url + '/merge', params)
+      Util.convert_to_tamber_object(response)
+    end
+    
+  end
+end

data/lib/tamber/util.rb

@@ -0,0 +1,89 @@
+require "cgi"
+require "json"
+
+module Tamber
+  module Util
+
+    def self.encode_parameters(params)
+      Util.flatten_params(params).
+        map { |k,v| "#{url_encode(k)}=#{url_encode(v)}" }.join('&')
+    end
+
+    def self.url_encode(key)
+      CGI.escape(key.to_s).
+        gsub('%5B', '[').gsub('%5D', ']')
+    end
+
+    def self.flatten_params(params, parent_key=nil)
+      result = []
+
+      params.sort_by { |(k, v)| k.to_s }.each do |key, value|
+        calculated_key = parent_key ? "#{parent_key}[#{key}]" : "#{key}"
+        if value.is_a?(Hash) || value.is_a?(Array) || value.is_a?(APIResource)
+          result << [calculated_key, value.to_json]
+        else
+          result << [calculated_key, value]
+        end
+      end
+
+      result
+    end
+
+    def self.object_classes
+      @object_classes ||= {
+        # Core
+        'event' => Event,
+        'discovery' => Discovery,
+
+        # Expanded
+        'user' => User,
+        'item' => Item,
+        'behavior' => Behavior,
+      }
+    end
+
+    def self.convert_full(resp)
+      case resp
+      when Hash
+        object_classes.fetch(resp[:object],TamberObject).construct_from(resp)
+      when Array
+        resp.map { |i| convert_full(i) }
+      else
+        resp
+      end
+    end
+
+    def self.convert_to_tamber_object(resp)
+      case resp
+      when Hash
+        object_classes.fetch(resp[:object],TamberObject).construct_from(resp)
+      when Array
+        if resp.size == 1
+          resp = resp[0]
+          self.convert_full(resp)
+        else
+          resp.map { |i| convert_full(i) }
+        end
+      else
+        resp
+      end
+    end
+
+    def self.symbolize_names(object)
+      case object
+      when Hash
+        new_hash = {}
+        object.each do |key, value|
+          key = (key.to_sym rescue key) || key
+          new_hash[key] = symbolize_names(value)
+        end
+        new_hash
+      when Array
+        object.map { |value| symbolize_names(value) }
+      else
+        object
+      end
+    end
+
+  end
+end

data/lib/tamber/version.rb

@@ -0,0 +1,3 @@
+module Tamber
+  VERSION = '0.1.7'
+end

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/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 :project_key, :engine_key, :api_version, :verify_ssl_certs, :open_timeout, :read_timeout
+  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={})
+
+    if project_key =~ /\s/
+      raise TamberError.new('Your project key is invalid, as it contains ' \
+                            'whitespace. (HINT: You can double-check your project 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 engine_key =~ /\s/
+      raise TamberError.new('Your engine key is invalid, as it contains ' \
+                            'whitespace. (HINT: You can double-check your project 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
+
+    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 ? '&' : '?'}#{Util.encode_parameters(params)}" if params && params.any?
+      payload = nil
+    else
+      payload = Util.encode_parameters(params)
+    end
+
+    request_opts.update(:headers => request_headers(project_key, engine_key, method),
+                        :method => method, :open_timeout => open_timeout,
+                        :payload => payload, :url => url, :timeout => read_timeout)
+
+    response = execute_request_with_rescues(request_opts)
+
+    [parse(response)]
+  end
+
+
+
+  def self.request_headers(pkey, ekey, method)
+    pkey ||= ''
+    ekey ||= ''
+    encoded_key  = Base64.encode64(pkey + ':' + ekey)
+    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.handle_restclient_error(e, request_opts)
+    parse(e)
+  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)
+    # response = execute_request(request_opts)
+    begin
+      response = execute_request(request_opts)
+    rescue SocketError => e
+      response = handle_restclient_error(e, request_opts)
+    rescue NoMethodError => e
+      # Work around RestClient bug
+      if e.message =~ /\WRequestFailed\W/
+        raise TamberError.new('Error: Unexpected HTTP response code')
+      else
+        raise
+      end
+    rescue RestClient::ExceptionWithResponse => e
+      puts "ExceptionWithResponse: #{e}"
+      if e.response
+        puts "e.response"
+        parse(e.response)
+      else
+        response = handle_restclient_error(e, request_opts)
+      end
+    rescue RestClient::Exception, Errno::ECONNREFUSED => e
+      response = handle_restclient_error(e, request_opts)
+    end
+
+    response
+  end
+end

data/tamber.gemspec

@@ -0,0 +1,35 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'tamber/version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'tamber'
+  s.version = Tamber::VERSION
+  s.required_ruby_version = '>= 1.9.3'
+  s.summary = 'Ruby bindings for the Tamber API'
+  s.description = 'Tamber is the easiest way to put head-scratchingly accurate, real time recommendations in your app.  See https://tamber.com for details.'
+  s.homepage = 'https://tamber.com/docs/api'
+  s.license = 'MIT'
+  s.authors = ['Alexi Robbins', 'Mark Canning']
+  s.email = ['alexi@tamber.com', 'argusdusty@tamber.com']
+
+  s.add_dependency('rest-client', '~> 1.4')
+  s.add_dependency('json', '~> 1.8.1')
+  s.add_dependency('activesupport', '~> 4.2.4')
+
+  s.add_development_dependency('mocha', '~> 0.13.2')
+  s.add_development_dependency('shoulda', '~> 3.4.0')
+  s.add_development_dependency('test-unit')
+  s.add_development_dependency('rake')
+
+  # if Gem::Version.new(RUBY_VERSION.dup) > Gem::Version.new('2.0.0')
+  #   s.add_development_dependency("byebug")
+  #   s.add_development_dependency("pry")
+  #   s.add_development_dependency("pry-byebug")
+  # end
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end