tamber 0.1.4 → 0.1.6

data/lib/tamber.rb

@@ -1,202 +0,0 @@
-# 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/lib/tamber/api_operations/create.rb

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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

data/lib/tamber/discover.rb

@@ -1,54 +0,0 @@
-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 + '/recommended_similar'
-    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

@@ -1,24 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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/tamber_error.rb

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

data/lib/tamber/tamber_object.rb

@@ -1,35 +0,0 @@
-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

@@ -1,7 +0,0 @@
-module Tamber
-  class User < APIResource
-    extend Tamber::APIOperations::Create
-    extend Tamber::APIOperations::Update
-    extend Tamber::APIOperations::Retrieve
-  end
-end