hackle-ruby-sdk 1.0.0 → 2.0.0

data/lib/hackle/events/user_event.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Hackle
-
-  class UserEvent
-
-    # @!attribute [r] timestamp
-    #  @return [Integer]
-    # @!attribute [r] user
-    #  @return [User]
-    attr_reader :timestamp, :user
-
-    # @param user [User]
-    def initialize(user:)
-      @timestamp = UserEvent.generate_timestamp
-      @user = user
-    end
-
-    class Exposure < UserEvent
-
-      # @!attribute [r] experiment
-      #  @return [Experiment]
-      # @!attribute [r] variation
-      #  @return [Variation]
-      attr_reader :experiment, :variation
-
-      # @param user [User]
-      # @param experiment [Experiment]
-      # @param variation [Variation]
-      def initialize(user:, experiment:, variation:)
-        super(user: user)
-        @experiment = experiment
-        @variation = variation
-      end
-    end
-
-
-    class Track < UserEvent
-
-      # @!attribute [r] event_type
-      #  @return [EventType]
-      # @!attribute [r] event
-      #  @return [Event]
-      attr_reader :event_type, :event
-
-      # @param user [User]
-      # @param event_type [EventType]
-      # @param event [Event]
-      def initialize(user:, event_type:, event:)
-        super(user: user)
-        @event_type = event_type
-        @event = event
-      end
-    end
-
-    # @return [Integer]
-    def self.generate_timestamp
-      (Time.now.to_f * 1000).to_i
-    end
-  end
-end

data/lib/hackle/http/http.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/http'
-
-module Hackle
-  class UnexpectedResponseError < StandardError
-  end
-
-  class HTTP
-    def self.client(base_uri:)
-      uri = URI.parse(base_uri)
-      client = Net::HTTP.new(uri.host, uri.port)
-      client.use_ssl = uri.scheme == 'https'
-      client.open_timeout = 5
-      client.read_timeout = 10
-      client
-    end
-
-    def self.sdk_headers(sdk_info:)
-      {
-        'X-HACKLE-SDK-KEY' => sdk_info.key,
-        'X-HACKLE-SDK-NAME' => sdk_info.name,
-        'X-HACKLE-SDK-VERSION' => sdk_info.version
-      }
-    end
-
-    def self.successful?(status_code:)
-      status_code >= 200 && status_code < 300
-    end
-
-    def self.check_successful(status_code:)
-      unless successful?(status_code: status_code)
-        raise UnexpectedResponseError, "HTTP status code #{status_code}"
-      end
-    end
-  end
-end

data/lib/hackle/models/bucket.rb

@@ -1,26 +0,0 @@
-module Hackle
-
-  class Bucket
-
-    # @!attribute [r] seed
-    #  @return [Integer]
-    # @!attribute [r] slot_size
-    #  @return [Integer]
-    attr_reader :seed, :slot_size
-
-    # @param seed [Integer]
-    # @param slot_size [Integer]
-    # @param slots [Array]
-    def initialize(seed:, slot_size:, slots:)
-      @seed = seed
-      @slot_size = slot_size
-      @slots = slots
-    end
-
-    # @param slot_number [Integer]
-    # @return [Slot, nil]
-    def get_slot(slot_number:)
-      @slots.find { |slot| slot.contains?(slot_number: slot_number) }
-    end
-  end
-end

data/lib/hackle/models/event.rb

@@ -1,26 +0,0 @@
-module Hackle
-  class Event
-
-    # @!attribute [r] key
-    #   @return [String]
-    # @!attribute [r] value
-    #   @return [Float, nil]
-    # @!attribute [r] properties
-    #   @return [Hash]
-    attr_reader :key, :value, :properties
-
-
-    # @param key [String]
-    # @param value [Float, nil]
-    # @param properties [Hash{Symbol => String, Number, boolean}]
-    def initialize(key:, value:, properties:)
-      @key = key
-      @value = value
-      @properties = properties
-    end
-
-    def valid?
-      !key.nil? && key.is_a?(String)
-    end
-  end
-end

data/lib/hackle/models/experiment.rb

@@ -1,69 +0,0 @@
-module Hackle
-  class Experiment
-
-    # @!attribute [r] id
-    #   @return [Integer]
-    # @!attribute [r] key
-    #   @return [Integer]
-    attr_reader :id, :key
-
-    # @param id [Integer]
-    # @param key [Integer]
-    def initialize(id:, key:)
-      @id = id
-      @key = key
-    end
-
-    class Running < Experiment
-
-      # @!attribute [r] bucket
-      #   @return [Bucket]
-      attr_reader :bucket
-
-      # @param id [Integer]
-      # @param key [Integer]
-      # @param bucket [Bucket]
-      # @param variations [Hash{String => Variation}]
-      # @param overrides [Hash{String => Integer}]
-      def initialize(id:, key:, bucket:, variations:, overrides:)
-        super(id: id, key: key)
-        @bucket = bucket
-
-        # @type [Hash{String => Variation}]
-        @variations = variations
-
-        # @type [Hash{String => Integer}]
-        @overrides = overrides
-      end
-
-      # @param variation_id [Integer]
-      # @return [Variation, nil]
-      def get_variation(variation_id:)
-        @variations[variation_id]
-      end
-
-      # @param user [User]
-      # @return [Variation, nil]
-      def get_overridden_variation(user:)
-        overridden_variation_id = @overrides[user.id]
-        return nil if overridden_variation_id.nil?
-        get_variation(variation_id: overridden_variation_id)
-      end
-    end
-
-    class Completed < Experiment
-
-      # @!attribute [r] winner_variation_key
-      #  @return [String]
-      attr_reader :winner_variation_key
-
-      # @param id [Integer]
-      # @param key [Integer]
-      # @param winner_variation_key [String]
-      def initialize(id:, key:, winner_variation_key:)
-        super(id: id, key: key)
-        @winner_variation_key = winner_variation_key
-      end
-    end
-  end
-end

data/lib/hackle/models/slot.rb

@@ -1,22 +0,0 @@
-module Hackle
-  class Slot
-    # @!attribute variation_id
-    #   @return [Integer]
-    attr_reader :variation_id
-
-    # @param start_inclusive [Integer]
-    # @param end_exclusive [Integer]
-    # @param variation_id [Integer]
-    def initialize(start_inclusive:, end_exclusive:, variation_id:)
-      @start_inclusive = start_inclusive
-      @end_exclusive = end_exclusive
-      @variation_id = variation_id
-    end
-
-    # @param slot_number [Integer]
-    # @return [boolean]
-    def contains?(slot_number:)
-      @start_inclusive <= slot_number && slot_number < @end_exclusive
-    end
-  end
-end

data/lib/hackle/models/user.rb

@@ -1,24 +0,0 @@
-module Hackle
-
-  class User
-
-    # @!attribute [r] id
-    #   @return [String]
-    # @!attribute [r] properties
-    #   @return [Hash]
-    attr_reader :id, :properties
-
-    #
-    # @param id [String]
-    # @param properties [Hash]
-    #
-    def initialize(id:, properties:)
-      @id = id
-      @properties = properties
-    end
-
-    def valid?
-      !id.nil? && id.is_a?(String)
-    end
-  end
-end

data/lib/hackle/models/variation.rb

@@ -1,21 +0,0 @@
-module Hackle
-  class Variation
-
-    # @!attribute id
-    #   @return [Integer]
-    # @!attribute key
-    #   @return [String]
-    # @!attribute dropped
-    #   @return [boolean]
-    attr_reader :id, :key, :dropped
-
-    # @param id [Integer]
-    # @param key [String]
-    # @param dropped [boolean]
-    def initialize(id:, key:, dropped:)
-      @id = id
-      @key = key
-      @dropped = dropped
-    end
-  end
-end

data/lib/hackle/workspaces/http_workspace_fetcher.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Hackle
-  class HttpWorkspaceFetcher
-
-    def initialize(config:, sdk_info:)
-      @client = HTTP.client(base_uri: config.base_uri)
-      @headers = HTTP.sdk_headers(sdk_info: sdk_info)
-    end
-
-    def fetch
-      request = Net::HTTP::Get.new('/api/v1/workspaces', @headers)
-      response = @client.request(request)
-
-      status_code = response.code.to_i
-      HTTP.check_successful(status_code: status_code)
-
-      response_body = JSON.parse(response.body, symbolize_names: true)
-      Workspace.create(data: response_body)
-    end
-  end
-end

data/lib/hackle/workspaces/polling_workspace_fetcher.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'concurrent'
-
-module Hackle
-  class PollingWorkspaceFetcher
-
-    DEFAULT_POLLING_INTERVAL = 10
-
-    def initialize(config:, http_fetcher:)
-      @logger = config.logger
-      @http_fetcher = http_fetcher
-      @current_workspace = Concurrent::AtomicReference.new
-      @task = Concurrent::TimerTask.new(execution_interval: DEFAULT_POLLING_INTERVAL) { poll }
-      @running = false
-    end
-
-    # @return [Workspace, nil]
-    def fetch
-      @current_workspace.get
-    end
-
-    def start!
-      return if @running
-
-      poll
-      @task.execute
-      @running = true
-    end
-
-    def stop!
-      return unless @running
-
-      @logger.info { 'Shutting down Hackle workspace_fetcher' }
-
-      @task.shutdown
-      @running = false
-    end
-
-    def poll
-      workspace = @http_fetcher.fetch
-      @current_workspace.set(workspace)
-    rescue => e
-      @logger.error { "Failed to poll Workspace: #{e.inspect}" }
-    end
-  end
-end

data/lib/hackle/workspaces/workspace.rb

@@ -1,100 +0,0 @@
-module Hackle
-  class Workspace
-
-    # @param experiments [Hash{Integer => Experiment}]
-    # @param event_types [Hash{String => EventType}]
-    def initialize(experiments:, event_types:)
-
-      # @type [Hash{Integer => Experiment}]
-      @experiments = experiments
-
-      # @type [Hash{String => EventType}]
-      @event_types = event_types
-    end
-
-    # @param experiment_key [Integer]
-    #
-    # @return [Experiment, nil]
-    def get_experiment(experiment_key:)
-      @experiments[experiment_key]
-    end
-
-    # @param event_type_key [String]
-    #
-    # @return [EventType]
-    def get_event_type(event_type_key:)
-      event_type = @event_types[event_type_key]
-
-      if event_type.nil?
-        EventType.undefined(key: event_type_key)
-      else
-        event_type
-      end
-    end
-
-    class << self
-      def create(data:)
-        buckets = Hash[data[:buckets].map { |b| [b[:id], bucket(b)] }]
-        running_experiments = Hash[data[:experiments].map { |re| [re[:key], running_experiment(re, buckets)] }]
-        completed_experiment = Hash[data[:completedExperiments].map { |ce| [ce[:experimentKey], completed_experiment(ce)] }]
-        event_types = Hash[data[:events].map { |e| [e[:key], event_type(e)] }]
-        experiments = running_experiments.merge(completed_experiment)
-        Workspace.new(
-          experiments: experiments,
-          event_types: event_types
-        )
-      end
-
-      private
-
-      def running_experiment(data, buckets)
-        Experiment::Running.new(
-          id: data[:id],
-          key: data[:key],
-          bucket: buckets[data[:bucketId]],
-          variations: Hash[data[:variations].map { |v| [v[:id], variation(v)] }],
-          overrides: Hash[data[:execution][:userOverrides].map { |u| [u[:userId], u[:variationId]] }]
-        )
-      end
-
-      def completed_experiment(data)
-        Experiment::Completed.new(
-          id: data[:experimentId],
-          key: data[:experimentKey],
-          winner_variation_key: data[:winnerVariationKey]
-        )
-      end
-
-      def variation(data)
-        Variation.new(
-          id: data[:id],
-          key: data[:key],
-          dropped: data[:status] == 'DROPPED'
-        )
-      end
-
-      def bucket(data)
-        Bucket.new(
-          seed: data[:seed],
-          slot_size: data[:slotSize],
-          slots: data[:slots].map { |s| slot(s) }
-        )
-      end
-
-      def slot(data)
-        Slot.new(
-          start_inclusive: data[:startInclusive],
-          end_exclusive: data[:endExclusive],
-          variation_id: data[:variationId]
-        )
-      end
-
-      def event_type(data)
-        EventType.new(
-          id: data[:id],
-          key: data[:key]
-        )
-      end
-    end
-  end
-end