algolia 2.0.0.pre.alpha.2

data/lib/algolia/config/analytics_config.rb

@@ -0,0 +1,20 @@
+module Algolia
+  module Analytics
+    class Config < AlgoliaConfig
+      attr_accessor :region, :default_hosts
+
+      # Initialize a config
+      #
+      # @option options [String] :app_id
+      # @option options [String] :api_key
+      # @option options [String] :region
+      #
+      def initialize(opts = {})
+        super(opts)
+
+        @region        = opts[:region] || 'us'
+        @default_hosts = [Transport::StatefulHost.new("analytics.#{region}.algolia.com")]
+      end
+    end
+  end
+end

data/lib/algolia/config/insights_config.rb

@@ -0,0 +1,20 @@
+module Algolia
+  module Insights
+    class Config < AlgoliaConfig
+      attr_accessor :region, :default_hosts
+
+      # Initialize a config
+      #
+      # @option options [String] :app_id
+      # @option options [String] :api_key
+      # @option options [String] :region
+      #
+      def initialize(opts = {})
+        super(opts)
+
+        @region        = opts[:region] || 'us'
+        @default_hosts = [Transport::StatefulHost.new("insights.#{region}.algolia.io")]
+      end
+    end
+  end
+end

data/lib/algolia/config/recommendation_config.rb

@@ -0,0 +1,20 @@
+module Algolia
+  module Recommendation
+    class Config < AlgoliaConfig
+      attr_accessor :region, :default_hosts
+
+      # Initialize a config
+      #
+      # @option options [String] :app_id
+      # @option options [String] :api_key
+      # @option options [String] :region
+      #
+      def initialize(opts = {})
+        super(opts)
+
+        @region        = opts[:region] || 'us'
+        @default_hosts = [Transport::StatefulHost.new("recommendation.#{region}.algolia.com")]
+      end
+    end
+  end
+end

data/lib/algolia/config/search_config.rb

@@ -0,0 +1,40 @@
+require 'faraday'
+require 'json'
+
+require 'algolia/enums/call_type'
+
+module Algolia
+  module Search
+    class Config < AlgoliaConfig
+      include CallType
+      attr_accessor :default_hosts
+
+      # Initialize a config
+      #
+      # @option options [String] :app_id
+      # @option options [String] :api_key
+      # @option options [Hash] :custom_hosts
+      #
+      def initialize(opts = {})
+        super(opts)
+        @default_hosts = []
+        hosts          = []
+        hosts << Transport::StatefulHost.new("#{app_id}-dsn.algolia.net", accept: READ)
+        hosts << Transport::StatefulHost.new("#{app_id}.algolia.net", accept: WRITE)
+
+        stateful_hosts = 1.upto(3).map do |i|
+          Transport::StatefulHost.new("#{app_id}-#{i}.algolianet.com", accept: READ | WRITE)
+        end.shuffle
+
+        if opts.has_key?(:custom_hosts)
+          opts[:custom_hosts].each do |host|
+            host = Transport::StatefulHost.new(host)
+            @default_hosts.push(host)
+          end
+        else
+          @default_hosts = hosts + stateful_hosts
+        end
+      end
+    end
+  end
+end

data/lib/algolia/defaults.rb

@@ -0,0 +1,35 @@
+module Defaults
+  REQUESTER_CLASS = Algolia::Http::HttpRequester
+  ADAPTER         = 'net_http_persistent'
+  TTL             = 300
+  # The version of the REST API implemented by this module.
+  VERSION         = 1
+
+  # HTTP Headers
+  # ----------------------------------------
+
+  # The HTTP header used for passing your application ID to the Algolia API.
+  HEADER_APP_ID            = 'X-Algolia-Application-Id'.freeze
+
+  # The HTTP header used for passing your API key to the Algolia API.
+  HEADER_API_KEY           = 'X-Algolia-API-Key'.freeze
+
+  # HTTP ERROR CODES
+  # ----------------------------------------
+
+  ERROR_BAD_REQUEST = 400
+  ERROR_FORBIDDEN   = 403
+  ERROR_NOT_FOUND   = 404
+  ERROR_TIMED_OUT   = 408
+
+  BATCH_SIZE      = 1000
+  CONNECT_TIMEOUT = 2
+  READ_TIMEOUT    = 30
+  WRITE_TIMEOUT   = 5
+  USER_AGENT      = "Algolia for Ruby (#{Algolia::VERSION}), Ruby (#{RUBY_VERSION})"
+
+  WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY = 100
+
+  GZIP_ENCODING = 'gzip'
+  NONE_ENCODING = 'none'
+end

data/lib/algolia/enums/call_type.rb

@@ -0,0 +1,4 @@
+module CallType
+  READ  = 1
+  WRITE = 2
+end

data/lib/algolia/enums/retry_outcome_type.rb

@@ -0,0 +1,5 @@
+module RetryOutcomeType
+  SUCCESS = 'SUCCESS'.freeze
+  RETRY   = 'RETRY'.freeze
+  FAILURE = 'FAILURE'.freeze
+end

data/lib/algolia/error.rb

@@ -0,0 +1,29 @@
+module Algolia
+  # Base exception class for errors thrown by the Algolia
+  # client library. AlgoliaError will be raised by any
+  # network operation if Algolia.init() has not been called.
+  # Exception ... why? A:http://www.skorks.com/2009/09/ruby-exceptions-and-exception-handling/
+  #
+  class AlgoliaError < StandardError
+  end
+
+  # Used when hosts are unreachable
+  #
+  class AlgoliaUnreachableHostError < AlgoliaError
+  end
+
+  # An exception class raised when the REST API returns an error.
+  # The error code and message will be parsed out of the HTTP response,
+  # which is also included in the response attribute.
+  #
+  class AlgoliaHttpError < AlgoliaError
+    attr_accessor :code
+    attr_accessor :message
+
+    def initialize(code, message)
+      self.code    = code
+      self.message = message
+      super("#{self.code}: #{self.message}")
+    end
+  end
+end

data/lib/algolia/helpers.rb

@@ -0,0 +1,83 @@
+require 'multi_json'
+
+module Helpers
+  # Convert an Hash to json
+  #
+  def to_json(body)
+    body.is_a?(String) ? body : MultiJson.dump(body)
+  end
+
+  # Converts each key of a hash to symbols
+  #
+  def symbolize_hash(hash)
+    hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+  end
+
+  # Convert params to a full query string
+  #
+  def handle_params(params)
+    params.nil? || params.empty? ? '' : "?#{to_query_string(params)}"
+  end
+
+  # Create a query string from params
+  #
+  def to_query_string(params)
+    params.map do |key, value|
+      "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}"
+    end.join('&')
+  end
+
+  # Convert a json object to an hash
+  #
+  def json_to_hash(json, symbolize_keys)
+    MultiJson.load(json, symbolize_keys: symbolize_keys)
+  end
+
+  # Retrieve the given value associated with a key, in string or symbol format
+  #
+  def get_option(hash, key)
+    hash[key.to_sym] || hash[key] || nil
+  end
+
+  # Build a path with the given arguments
+  #
+  def path_encode(path, *args)
+    arguments = []
+    args.each do |arg|
+      arguments.push(CGI.escape(CGI.unescape(arg.to_s)))
+    end
+
+    format(path, *arguments)
+  end
+
+  # Support to convert old settings to their new names
+  #
+  def deserialize_settings(data)
+    settings = symbolize_hash(data)
+    keys     = {
+      attributesToIndex: 'searchableAttributes',
+      numericAttributesToIndex: 'numericAttributesForFiltering',
+      slaves: 'replicas'
+    }
+
+    keys.each do |deprecated_key, current_key|
+      if settings.has_key?(deprecated_key)
+        settings[current_key.to_sym] = settings.delete(deprecated_key)
+      end
+    end
+
+    settings
+  end
+
+  def self.included(base)
+    base.extend(Helpers)
+  end
+
+  def hash_includes_subset?(hash, subset)
+    res = true
+    subset.each do |k, v|
+      res &&= hash[k] == v
+    end
+    res
+  end
+end

data/lib/algolia/http/http_requester.rb

@@ -0,0 +1,84 @@
+module Algolia
+  module Http
+    class HttpRequester
+      include Helpers
+      attr_accessor :adapter, :logger
+
+      #
+      # @param adapter [Object] adapter used to make requests. Defaults to Net::Http
+      # @param logger [Object] logger used to log requests. Defaults to Algolia::LoggerHelper
+      #
+      def initialize(adapter, logger)
+        @adapter    = adapter
+        @logger     = logger
+        @connection = nil
+      end
+
+      # Sends request to the engine
+      #
+      # @param host [StatefulHost]
+      # @param method [Symbol]
+      # @param path [String]
+      # @param body [JSON]
+      # @param headers [Hash]
+      #
+      # @return [Http::Response]
+      #
+      def send_request(host, method, path, body, headers, timeout, connect_timeout)
+        connection                      = connection(host)
+        connection.options.timeout      = timeout
+        connection.options.open_timeout = connect_timeout
+
+        if ENV['ALGOLIA_DEBUG']
+          @logger.info("Sending #{method.to_s.upcase!} request to #{path} with body #{body}")
+        end
+
+        response = connection.run_request(method, path, body, headers)
+
+        if response.success?
+          if ENV['ALGOLIA_DEBUG']
+            @logger.info("Request succeeded. Response status: #{response.status}, body: #{response.body}")
+          end
+          return Http::Response.new(status: response.status, body: response.body, headers: response.headers)
+        end
+
+        if ENV['ALGOLIA_DEBUG']
+          @logger.info("Request failed. Response status: #{response.status}, error: #{response.body}")
+        end
+        Http::Response.new(status: response.status, error: response.body, headers: response.headers)
+      rescue Faraday::TimeoutError => e
+        if ENV['ALGOLIA_DEBUG']
+          @logger.info("Request timed out. Error: #{e.message}")
+        end
+        Http::Response.new(error: e.message, has_timed_out: true)
+      rescue ::StandardError => e
+        if ENV['ALGOLIA_DEBUG']
+          @logger.info("Request failed. Error: #{e.message}")
+        end
+        Http::Response.new(error: e.message, network_failure: true)
+      end
+
+      # Retrieve the connection from the @connections
+      #
+      # @param host [StatefulHost]
+      #
+      # @return [Faraday::Connection]
+      #
+      def connection(host)
+        @connection ||= Faraday.new(build_url(host)) do |f|
+          f.adapter @adapter.to_sym
+        end
+      end
+
+      # Build url from host, path and parameters
+      #
+      # @param host [StatefulHost]
+      #
+      # @return [String]
+      #
+      def build_url(host)
+        host.protocol + host.url
+      end
+    end
+  end
+end

data/lib/algolia/http/response.rb

@@ -0,0 +1,23 @@
+module Algolia
+  module Http
+    class Response
+      attr_reader :status, :body, :error, :headers, :has_timed_out, :network_failure
+
+      #
+      # @option status    [String]  Response status
+      # @option body    [String]  Response body
+      # @option error    [String]  Response error or caught error
+      # @option headers    [String]  Response headers
+      # @option has_timed_out    [String]  If the request has timed out
+      #
+      def initialize(opts = {})
+        @status          = opts[:status]
+        @body            = opts[:body] || ''
+        @error           = opts[:error] || ''
+        @headers         = opts[:headers] || ''
+        @has_timed_out   = opts[:has_timed_out] || false
+        @network_failure = opts[:network_failure] || false
+      end
+    end
+  end
+end

data/lib/algolia/insights_client.rb

@@ -0,0 +1,238 @@
+module Algolia
+  module Insights
+    class Client
+      include Helpers
+
+      # Initializes the Insights client
+      #
+      # @param insights_config [Insights::Config] an Insights::Config object which contains your APP_ID and API_KEY
+      # @option adapter [Object] adapter object used for the connection
+      # @option logger [Object]
+      # @option http_requester [Object] http_requester object used for the connection
+      #
+      def initialize(insights_config, opts = {})
+        @config      = insights_config
+        adapter      = opts[:adapter] || Defaults::ADAPTER
+        logger       = opts[:logger] || LoggerHelper.create('debug.log')
+        requester    = opts[:http_requester] || Defaults::REQUESTER_CLASS.new(adapter, logger)
+        @transporter = Transport::Transport.new(@config, requester)
+      end
+
+      # Create a new client providing only app ID and API key
+      #
+      # @param app_id [String] Algolia application ID
+      # @param api_key [String] Algolia API key
+      #
+      # @return self
+      #
+      def self.create(app_id, api_key)
+        config = Insights::Config.new(app_id: app_id, api_key: api_key)
+        create_with_config(config)
+      end
+
+      # Create a new client providing only an Analytics::Config object
+      #
+      # @param config [Insights::Config]
+      #
+      # @return self
+      #
+      def self.create_with_config(config)
+        new(config)
+      end
+
+      # Create a new Insight User Client
+      #
+      # @param user_token [String]
+      #
+      # @return [UserClient]
+      #
+      def user(user_token)
+        UserClient.new(self, user_token)
+      end
+
+      # Push an event to the Insights API.
+      #
+      # @param event [Hash]
+      #
+      # @return [Hash]
+      #
+      def send_event(event, opts = {})
+        send_events([event], opts)
+      end
+
+      # Push an array of events to the Insights API.
+      #
+      # @param events [Array]
+      #
+      # @return [Hash]
+      #
+      def send_events(events, opts = {})
+        @transporter.write(:POST, '/1/events', { events: events }, opts)
+      end
+    end
+
+    class UserClient
+      # Initializes the Insights userClient
+      #
+      # @param insights_client [Insights::Client] Insights Client used to make API calls
+      # @param user_token [String] user token used to build the client
+      #
+      def initialize(insights_client, user_token)
+        @insights_client = insights_client
+        @user_token      = user_token
+      end
+
+      # Send a click event to capture clicked items.
+      #
+      # @param event_name [String] Name of the event.
+      # @param index_name [String] Name of the index related to the click.
+      # @param object_ids [Array] A list of objectIDs (limited to 20)
+      #
+      # @return [Hash]
+      #
+      def clicked_object_ids(event_name, index_name, object_ids, opts = {})
+        @insights_client.send_event({
+          eventType: 'click',
+          eventName: event_name,
+          index: index_name,
+          userToken: @user_token,
+          objectIds: object_ids
+        }, opts)
+      end
+
+      # Send a click event to capture a query and its clicked items and positions.
+      #
+      # @param event_name [String] Name of the event.
+      # @param index_name [String] Name of the index related to the click.
+      # @param object_ids [Array] A list of objectIDs (limited to 20)
+      # @param positions [Array] Position of the click in the list of Algolia search results.
+      # @param query_id [String] Algolia queryID that can be found in the search response when using clickAnalytics
+      #
+      # @return [Hash]
+      #
+      def clicked_object_ids_after_search(event_name, index_name,
+        object_ids, positions, query_id, opts = {})
+        @insights_client.send_event({
+          eventType: 'click',
+          eventName: event_name,
+          index: index_name,
+          userToken: @user_token,
+          objectIds: object_ids,
+          positions: positions,
+          queryId: query_id
+        }, opts)
+      end
+
+      # Send a click event to capture the filters a user clicks on.
+      #
+      # @param event_name [String] Name of the event.
+      # @param index_name [String] Name of the index related to the click.
+      # @param filters [Array] A list of filters (limited to 10)
+      #
+      # @return [Hash]
+      #
+      def clicked_filters(event_name, index_name, filters, opts = {})
+        @insights_client.send_event({
+          eventType: 'click',
+          eventName: event_name,
+          index: index_name,
+          userToken: @user_token,
+          filters: filters
+        }, opts)
+      end
+
+      # Send a conversion event to capture clicked items.
+      #
+      # @param event_name [String] Name of the event.
+      # @param index_name [String] Name of the index related to the click.
+      # @param object_ids [Array] A list of objectIDs (limited to 20)
+      #
+      # @return [Hash]
+      #
+      def converted_object_ids(event_name, index_name, object_ids, opts = {})
+        @insights_client.send_event({
+          eventType: 'conversion',
+          eventName: event_name,
+          index: index_name,
+          userToken: @user_token,
+          objectIds: object_ids
+        }, opts)
+      end
+
+      # Send a conversion event to capture a query and its clicked items.
+      #
+      # @param event_name [String] Name of the event.
+      # @param index_name [String] Name of the index related to the click.
+      # @param object_ids [Array] A list of objectIDs (limited to 20)
+      # @param query_id [String] Algolia queryID, format: [a-z1-9]{32}.
+      #
+      # @return [Hash]
+      #
+      def converted_object_ids_after_search(event_name, index_name,
+        object_ids, query_id, opts = {})
+        @insights_client.send_event({
+          eventType: 'conversion',
+          eventName: event_name,
+          index: index_name,
+          userToken: @user_token,
+          objectIds: object_ids,
+          queryId: query_id
+        }, opts)
+      end
+
+      # Send a conversion event to capture the filters a user uses when converting.
+      #
+      # @param event_name [String] Name of the event.
+      # @param index_name [String] Name of the index related to the click.
+      # @param filters [Array] A list of filters (limited to 10)
+      #
+      # @return [Hash]
+      #
+      def converted_filters(event_name, index_name, filters, opts = {})
+        @insights_client.send_event({
+          eventType: 'conversion',
+          eventName: event_name,
+          index: index_name,
+          userToken: @user_token,
+          filters: filters
+        }, opts)
+      end
+
+      # Send a view event to capture clicked items.
+      #
+      # @param event_name [String] Name of the event.
+      # @param index_name [String] Name of the index related to the click.
+      # @param object_ids [Array] A list of objectIDs (limited to 20)
+      #
+      # @return [Hash]
+      #
+      def viewed_object_ids(event_name, index_name, object_ids, opts = {})
+        @insights_client.send_event({
+          eventType: 'view',
+          eventName: event_name,
+          index: index_name,
+          userToken: @user_token,
+          objectIds: object_ids
+        }, opts)
+      end
+
+      # Send a view event to capture the filters a user uses when viewing.
+      #
+      # @param event_name [String] Name of the event.
+      # @param index_name [String] Name of the index related to the click.
+      # @param filters [Array] A list of filters (limited to 10)
+      #
+      # @return [Hash]
+      #
+      def viewed_filters(event_name, index_name, filters, opts = {})
+        @insights_client.send_event({
+          eventType: 'view',
+          eventName: event_name,
+          index: index_name,
+          userToken: @user_token,
+          filters: filters
+        }, opts)
+      end
+    end
+  end
+end