hackle-ruby-sdk 0.0.1 → 1.0.0

data/lib/hackle-ruby-sdk/models/slot.rb

@@ -1,15 +0,0 @@
-module Hackle
-  class Slot
-    attr_reader :variation_id
-
-    def initialize(start_inclusive, end_exclusive, variation_id)
-      @start_inclusive = start_inclusive
-      @end_exclusive = end_exclusive
-      @variation_id = variation_id
-    end
-
-    def contains?(slot_number)
-      @start_inclusive <= slot_number && slot_number < @end_exclusive
-    end
-  end
-end

data/lib/hackle-ruby-sdk/models/variation.rb

@@ -1,11 +0,0 @@
-module Hackle
-  class Variation
-    attr_reader :id, :key, :dropped
-
-    def initialize(id, key, dropped)
-      @id = id
-      @key = key
-      @dropped = dropped
-    end
-  end
-end

data/lib/hackle-ruby-sdk/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(config.base_uri)
-      @headers = HTTP.sdk_headers(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)
-
-      data = JSON.parse(response.body, symbolize_names: true)
-      Workspace.create(data)
-    end
-  end
-end

data/lib/hackle-ruby-sdk/workspaces/workspace.rb

@@ -1,78 +0,0 @@
-module Hackle
-  class Workspace
-    def initialize(experiments, event_types)
-      @experiments = experiments
-      @event_types = event_types
-    end
-
-    def get_experiment(experiment_key)
-      @experiments[experiment_key]
-    end
-
-    def get_event_type(event_type_key)
-      @event_types[event_type_key]
-    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, event_types)
-      end
-
-      private
-
-      def running_experiment(data, buckets)
-        Experiment::Running.new(
-          data[:id],
-          data[:key],
-          buckets[data[:bucketId]],
-          Hash[data[:variations].map { |v| [v[:id], variation(v)] }],
-          Hash[data[:execution][:userOverrides].map { |u| [u[:userId], u[:variationId]] }]
-        )
-      end
-
-      def completed_experiment(data)
-        Experiment::Completed.new(
-          data[:experimentId],
-          data[:experimentKey],
-          data[:winnerVariationKey]
-        )
-      end
-
-      def variation(data)
-        Variation.new(
-          data[:id],
-          data[:key],
-          data[:status] == 'DROPPED'
-        )
-      end
-
-      def bucket(data)
-        Bucket.new(
-          data[:seed],
-          data[:slotSize],
-          data[:slots].map { |s| slot(s) }
-        )
-      end
-
-      def slot(data)
-        Slot.new(
-          data[:startInclusive],
-          data[:endExclusive],
-          data[:variationId]
-        )
-      end
-
-      def event_type(data)
-        EventType.new(
-          data[:id],
-          data[:key]
-        )
-      end
-    end
-  end
-end