trailguide 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1f31e734d2b0165ffe08887a4e7a21cceebe8c6aba8c4ff72d9393f1fd6095a
-  data.tar.gz: ea8cd225a315add5f4512f8bc38bd28bc372741c45185eb4c987069165c3ad4b
+  metadata.gz: ad497aad0d4ac4af551fac70eb9191271586a4d3a3d9a6f45b9ae5879fb1cbaf
+  data.tar.gz: a2c20d6786785ee59e7c9bd15f14bb155078ff9f84ef4d1767aa939b3266cb00
 SHA512:
-  metadata.gz: ccb5f9cd9e367481380b8afbc6a763149967bd59f0bbe6d7f0c0693d90ccae7d0b6a16bf9e2544ef4362504cb417cb327f44001a044d8bbc4e318a1377b6ac45
-  data.tar.gz: 19b6761660d76db06b36114496fd9f835d08fdf70e99a7e117369d800175a79f18e21c6436f7f37a84529e3370bdae2f8285a49e25ae00182cc05f801c8daea9
+  metadata.gz: 4ebc9638bbdbbb2c9ad168441643fa61d12e9d1ecef0ca945fcd28157b2169ddf549b87f7e691c0735bd6c952be4552517f20cbb94a0002ea966e3351d845c02
+  data.tar.gz: 135fcf0f3bde5583232921bbb40c981ef29fbe044a178e41bf41891af9a5371fae403aa0de83000ed1b9ed4ba27bb886ea2a9e5e3d0ad06236cd52ec15c0d7d3

data/app/views/layouts/trail_guide/admin/_footer.html.erb

@@ -16,7 +16,7 @@
       <span class="fas fa-flask" data-toggle="tooltip" title="experiments"></span>
     </div>
     <div class="col-sm-3 text-right">
-      <small class="text-muted"><%= TrailGuide.redis._client.id %><%= "/#{TrailGuide.redis.namespace}" if TrailGuide.redis.respond_to?(:namespace) %></small>
+      <small class="text-muted"><%= TrailGuide.redis_client.id %><%= "/#{TrailGuide.redis.namespace}" if TrailGuide.redis.respond_to?(:namespace) %></small>
       <button type="button" class="btn btn-link text-muted" style="font-size: 80%; margin: 0; padding: 0;" data-toggle="modal" data-target="#import-modal" data-tooltip="tooltip" title="Import/Export">
         <span class="fas fa-file-download"></span>
       </button>

data/lib/trail_guide/config.rb

@@ -27,6 +27,10 @@ module TrailGuide
       end
     end
 
+    def redis_client
+      redis.try(:_client) || redis.try(:client)
+    end
+
     def ignore_orphaned_groups?
       !!self[:ignore_orphaned_groups]
     end

data/lib/trail_guide/experiments/base.rb

@@ -1,9 +1,20 @@
 require "trail_guide/experiments/config"
+require "trail_guide/experiments/persistence"
+require "trail_guide/experiments/lifecycle"
+require "trail_guide/experiments/enrollment"
+require "trail_guide/experiments/conversion"
+require "trail_guide/experiments/results"
 require "trail_guide/experiments/participant"
 
 module TrailGuide
   module Experiments
     class Base
+      include Persistence
+      include Lifecycle
+      include Enrollment
+      include Conversion
+      include Results
+
       class << self
         delegate :groups, :algorithm, :control, :goals, :callbacks, :combined,
           :combined?, :allow_multiple_conversions?, :allow_multiple_goals?,
@@ -23,10 +34,6 @@ module TrailGuide
           configuration.configure(*args, &block)
         end
 
-        def adapter
-          @adapter ||= TrailGuide::Adapters::Experiments::Redis.new(self)
-        end
-
         # TODO alias name once specs have solid coverage
         def experiment_name
           configuration.name
@@ -48,173 +55,6 @@ module TrailGuide
           combined.map { |combo| TrailGuide.catalog.find(combo) }
         end
 
-        def run_callbacks(hook, *args)
-          return unless callbacks[hook]
-          return args[0] if hook == :rollout_winner # TODO do we need to account for this case here at the class level?
-          args.unshift(self)
-          callbacks[hook].each do |callback|
-            if callback.respond_to?(:call)
-              callback.call(*args)
-            else
-              send(callback, *args)
-            end
-          end
-        end
-
-        def start!(context=nil)
-          return false if started?
-          save! unless persisted?
-          started = adapter.set(:started_at, Time.now.to_i)
-          run_callbacks(:on_start, context)
-          started
-        end
-
-        def schedule!(start_at, stop_at=nil, context=nil)
-          return false if started?
-          save! unless persisted?
-          scheduled = adapter.set(:started_at, start_at.to_i)
-          adapter.set(:stopped_at, stop_at.to_i) if stop_at
-          run_callbacks(:on_schedule, start_at, stop_at, context)
-          scheduled
-        end
-
-        def pause!(context=nil)
-          return false unless running? && configuration.can_resume?
-          paused = adapter.set(:paused_at, Time.now.to_i)
-          run_callbacks(:on_pause, context)
-          paused
-        end
-
-        def stop!(context=nil)
-          return false unless started? && !stopped?
-          stopped = adapter.set(:stopped_at, Time.now.to_i)
-          run_callbacks(:on_stop, context)
-          stopped
-        end
-
-        def resume!(context=nil)
-          return false unless paused? && configuration.can_resume?
-          resumed = adapter.delete(:paused_at)
-          run_callbacks(:on_resume, context)
-          !!resumed
-        end
-
-        def started_at
-          started = adapter.get(:started_at)
-          return Time.at(started.to_i) if started
-        end
-
-        def paused_at
-          paused = adapter.get(:paused_at)
-          return Time.at(paused.to_i) if paused
-        end
-
-        def stopped_at
-          stopped = adapter.get(:stopped_at)
-          return Time.at(stopped.to_i) if stopped
-        end
-
-        def started?
-          time = started_at
-          time && time <= Time.now
-        end
-
-        def scheduled?
-          time = started_at
-          time && time > Time.now
-        end
-
-        def paused?
-          time = paused_at
-          time && time <= Time.now
-        end
-
-        def stopped?
-          time = stopped_at
-          time && time <= Time.now
-        end
-
-        def running?
-          started? && !paused? && !stopped?
-        end
-
-        def calibrating?
-          enable_calibration? && start_manually? && !started?
-        end
-
-        def fresh?
-          !started? && !scheduled? && !winner?
-        end
-
-        def declare_winner!(variant, context=nil)
-          variant = variants.find { |var| var == variant } unless variant.is_a?(Variant)
-          return false unless variant.present? && variant.experiment == self
-          run_callbacks(:on_winner, variant, context)
-          adapter.set(:winner, variant.name)
-          variant
-        end
-
-        def clear_winner!
-          adapter.delete(:winner)
-        end
-
-        def winner
-          winner = adapter.get(:winner)
-          return variants.find { |var| var == winner } if winner
-        end
-
-        def winner?
-          if combined?
-            combined.all? { |combo| TrailGuide.catalog.find(combo).winner? }
-          else
-            adapter.exists?(:winner)
-          end
-        end
-
-        def persisted?
-          adapter.persisted?
-        end
-
-        def save!
-          combined_experiments.each(&:save!)
-          variants.each(&:save!)
-          adapter.setnx(:name, experiment_name)
-        end
-
-        def delete!(context=nil)
-          combined.each { |combo| TrailGuide.catalog.find(combo).delete! }
-          variants.each(&:delete!)
-          deleted = adapter.destroy
-          run_callbacks(:on_delete, context)
-          true
-        end
-
-        def reset!(context=nil)
-          delete!(context)
-          save!
-          run_callbacks(:on_reset, context)
-          true
-        end
-
-        def participants
-          variants.sum(&:participants)
-        end
-
-        def converted(checkpoint=nil)
-          variants.sum { |var| var.converted(checkpoint) }
-        end
-
-        def unconverted
-          participants - converted
-        end
-
-        def target_sample_size_reached?
-          return true unless configuration.target_sample_size
-          return true if participants >= configuration.target_sample_size
-          return false
-        end
-
-        # export the experiment state (not config) as json
         def as_json(opts={})
           { experiment_name => {
             started_at: started_at,
@@ -224,10 +64,6 @@ module TrailGuide
             variants: variants.map(&:as_json).reduce({}) { |r,v| r.merge!(v) },
           } }
         end
-
-        def storage_key
-          configuration.name
-        end
       end
 
       attr_reader :participant
@@ -237,181 +73,7 @@ module TrailGuide
         :enable_calibration?, :track_winner_conversions?, :callbacks, to: :class
 
       def initialize(participant)
-        @participant = TrailGuide::Experiments::Participant.new(self, participant)
-      end
-
-      def algorithm
-        @algorithm ||= self.class.algorithm.new(self)
-      end
-
-      def winning_variant
-        return nil unless winner?
-        run_callbacks(:rollout_winner, winner, participant)
-      end
-
-      def choose!(override: nil, metadata: nil, **opts)
-        return control if TrailGuide.configuration.disabled
-
-        variant = choose_variant!(override: override, metadata: metadata, **opts)
-        run_callbacks(:on_use, variant, participant, metadata)
-        variant
-      rescue Errno::ECONNREFUSED, Redis::BaseError, SocketError => e
-        run_callbacks(:on_redis_failover, e)
-        return variants.find { |var| var == override } || control if override.present?
-        return control
-      end
-
-      def choose_variant!(override: nil, excluded: false, metadata: nil)
-        return control if TrailGuide.configuration.disabled
-
-        if override.present?
-          variant = variants.find { |var| var == override } || control
-          if running? && !is_combined?
-            variant.increment_participation! if configuration.track_override
-            participant.participating!(variant) if configuration.store_override
-          end
-          return variant
-        end
-
-        if winner?
-          variant = winning_variant
-          if track_winner_conversions? && running?
-            variant.increment_participation! unless participant.variant == variant
-            participant.exit! if participant.participating? && participant.variant != variant
-            participant.participating!(variant)
-          end
-          return variant
-        end
-
-        return control if excluded || stopped?
-
-        if !started? && start_manually?
-          if enable_calibration?
-            unless participant.variant == control
-              control.increment_participation!
-              parent.control.increment_participation! if is_combined?
-            end
-
-            if participant.participating? && participant.variant != control
-              participant.exit!
-              parent.participant.exit! if is_combined?
-            end
-
-            participant.participating!(control)
-            parent.participant.participating!(parent.control) if is_combined?
-          end
-          return control
-        end
-
-        start! unless started? || scheduled?
-        return control unless running?
-
-        # only re-use the variant for experiments that store participation,
-        # all other (i.e. content-based) experiments should re-select and
-        # re-assign on enrollment
-        if configuration.sticky_assignment? && participant.participating?
-          variant = participant.variant
-          participant.participating!(variant)
-          return variant
-        end
-
-        return control unless is_combined? || TrailGuide.configuration.allow_multiple_experiments == true || !participant.participating_in_active_experiments?(TrailGuide.configuration.allow_multiple_experiments == false)
-        return control unless allow_participation?(metadata)
-
-        variant = algorithm_choose!(metadata: metadata)
-        variant.increment_participation!
-        participant.participating!(variant)
-        run_callbacks(:on_choose, variant, participant, metadata)
-        variant
-      end
-
-      def algorithm_choose!(metadata: nil)
-        algorithm.choose!(metadata: metadata)
-      end
-
-      def convert!(checkpoint=nil, metadata: nil)
-        if !started?
-          return false unless enable_calibration?
-          variant = participant.variant
-          return false unless variant.present? && variant == control
-        else
-          return false unless running?
-          variant = participant.variant
-          return false unless variant.present?
-
-          if winner?
-            return false unless track_winner_conversions? && variant == winner
-          end
-        end
-
-        if checkpoint.nil?
-          raise InvalidGoalError, "You must provide a valid goal checkpoint for `#{experiment_name}`." unless goals.empty?
-        else
-          goal = goals.find { |g| g == checkpoint }
-          raise InvalidGoalError, "Invalid goal checkpoint `#{checkpoint}` for `#{experiment_name}`." if goal.nil?
-          checkpoint = goal
-        end
-
-        # TODO eventually allow progressing through funnel checkpoints towards goals
-        if participant.converted?(checkpoint)
-          return false unless (checkpoint.nil? && allow_multiple_conversions?) || (checkpoint.present? && checkpoint.allow_multiple_conversions?)
-        elsif participant.converted?
-          return false unless allow_multiple_goals?
-        end
-        return false unless allow_conversion?(variant, checkpoint, metadata)
-
-        # TODO only reset if !reset_manually? AND they've converted all goals if
-        # allow_multiple_goals? is set
-        # TODO what should happen when allow_multiple_conversions? and !reset_manually?
-        # TODO eventually only reset if we're at the final goal in a funnel
-        participant.converted!(variant, checkpoint, reset: !reset_manually?)
-        variant.increment_conversion!(checkpoint)
-        if checkpoint.nil?
-          run_callbacks(:on_convert, checkpoint, variant, participant, metadata)
-        else
-          checkpoint.run_callbacks(:on_convert, self, variant, participant, metadata)
-        end
-        variant
-      rescue Errno::ECONNREFUSED, Redis::BaseError, SocketError => e
-        run_callbacks(:on_redis_failover, e)
-        return false
-      end
-
-      def allow_participation?(metadata=nil)
-        return true if callbacks[:allow_participation].empty?
-        run_callbacks(:allow_participation, true, participant, metadata)
-      end
-
-      def allow_conversion?(variant, checkpoint=nil, metadata=nil)
-        if checkpoint.nil?
-          return true if callbacks[:allow_conversion].empty?
-          # TODO why pass checkpoint through here if checkpoints are handled by their own method? it will always be nil here given current logic
-          run_callbacks(:allow_conversion, true, checkpoint, variant, participant, metadata)
-        else
-          checkpoint.allow_conversion?(self, variant, metadata)
-        end
-      end
-
-      def run_callbacks(hook, *args)
-        return unless callbacks[hook]
-        if [:allow_participation, :allow_conversion, :rollout_winner].include?(hook)
-          callbacks[hook].reduce(args.slice!(0,1)[0]) do |result, callback|
-            if callback.respond_to?(:call)
-              callback.call(self, result, *args)
-            else
-              send(callback, self, result, *args)
-            end
-          end
-        else
-          args.unshift(self)
-          callbacks[hook].each do |callback|
-            if callback.respond_to?(:call)
-              callback.call(*args)
-            else
-              send(callback, *args)
-            end
-          end
-        end
+        @participant = Experiments::Participant.new(self, participant)
       end
 
       def combined_experiments
@@ -419,62 +81,6 @@ module TrailGuide
           combo.new(participant.participant)
         end
       end
-
-      ### MEMOIZATOIN ###
-      # This is a lot of seemingly unnecessary duplication, but it really helps
-      # to cut down on the number of redis requests while still being
-      # thread-safe by memoizing these methods/values here at the instance level
-
-      def start!
-        @started_at = nil
-        self.class.start!
-      end
-
-      def started_at
-        @started_at ||= self.class.started_at
-      end
-
-      def paused_at
-        @paused_at ||= self.class.paused_at
-      end
-
-      def stopped_at
-        @stopped_at ||= self.class.stopped_at
-      end
-
-      def winner
-        @winner ||= self.class.winner
-      end
-
-      def scheduled?
-        started_at && started_at > Time.now
-      end
-
-      def started?
-        started_at && started_at <= Time.now
-      end
-
-      def paused?
-        paused_at && paused_at <= Time.now
-      end
-
-      def stopped?
-        stopped_at && stopped_at <= Time.now
-      end
-
-      def running?
-        started? && !paused? && !stopped?
-      end
-
-      def calibrating?
-        enable_calibration? && start_manually? && !started?
-      end
-
-      def winner?
-        return @has_winner unless @has_winner.nil?
-        @has_winner = self.class.winner?
-      end
-
     end
   end
 end

data/lib/trail_guide/experiments/config.rb

@@ -19,11 +19,7 @@ module TrailGuide
       def default_config
         DEFAULT_KEYS.map do |key|
           [key, nil]
-        end.to_h.merge({
-          variants: [],
-          goals: [],
-          combined: []
-        }).merge(callback_config)
+        end.to_h.merge(callback_config)
       end
 
       def callback_config
@@ -44,7 +40,7 @@ module TrailGuide
           opts[:name] = nil
           opts[:goals] = ancestor.goals.dup
           opts[:combined] = ancestor.combined.dup
-          opts[:variants] = ancestor.variants.map { |var| var.dup(experiment) }
+          opts[:variants] = ancestor.variants.dup(experiment)
           opts = opts.merge(ancestor.callbacks.map { |k,v| [k,[v].flatten.compact] }.to_h)
         end
         super(*args, **opts, &block)
@@ -99,7 +95,7 @@ module TrailGuide
       end
 
       def variants
-        self[:variants]
+        self[:variants] ||= TrailGuide::Variants.new
       end
 
       def variant(varname, metadata: {}, weight: 1, control: false)
@@ -202,7 +198,7 @@ module TrailGuide
       end
 
       def combined
-        self[:combined]
+        self[:combined] ||= []
       end
 
       def combined?

data/lib/trail_guide/experiments/conversion.rb

@@ -0,0 +1,63 @@
+module TrailGuide
+  module Experiments
+    module Conversion
+      def convert!(checkpoint=nil, metadata: nil)
+        if !started?
+          return false unless enable_calibration?
+          variant = participant.variant
+          return false unless variant.present? && variant == control
+        else
+          return false unless running?
+          variant = participant.variant
+          return false unless variant.present?
+
+          if winner?
+            return false unless track_winner_conversions? && variant == winner
+          end
+        end
+
+        if checkpoint.nil?
+          raise InvalidGoalError, "You must provide a valid goal checkpoint for `#{experiment_name}`." unless goals.empty?
+        else
+          goal = goals.find { |g| g == checkpoint }
+          raise InvalidGoalError, "Invalid goal checkpoint `#{checkpoint}` for `#{experiment_name}`." if goal.nil?
+          checkpoint = goal
+        end
+
+        # TODO eventually allow progressing through funnel checkpoints towards goals
+        if participant.converted?(checkpoint)
+          return false unless (checkpoint.nil? && allow_multiple_conversions?) || (checkpoint.present? && checkpoint.allow_multiple_conversions?)
+        elsif participant.converted?
+          return false unless allow_multiple_goals?
+        end
+        return false unless allow_conversion?(variant, checkpoint, metadata)
+
+        # TODO only reset if !reset_manually? AND they've converted all goals if
+        # allow_multiple_goals? is set
+        # TODO what should happen when allow_multiple_conversions? and !reset_manually?
+        # TODO eventually only reset if we're at the final goal in a funnel
+        participant.converted!(variant, checkpoint, reset: !reset_manually?)
+        variant.increment_conversion!(checkpoint)
+        if checkpoint.nil?
+          run_callbacks(:on_convert, checkpoint, variant, participant, metadata)
+        else
+          checkpoint.run_callbacks(:on_convert, self, variant, participant, metadata)
+        end
+        variant
+      rescue Errno::ECONNREFUSED, Redis::BaseError, SocketError => e
+        run_callbacks(:on_redis_failover, e)
+        return false
+      end
+
+      def allow_conversion?(variant, checkpoint=nil, metadata=nil)
+        if checkpoint.nil?
+          return true if callbacks[:allow_conversion].empty?
+          # TODO why pass checkpoint through here if checkpoints are handled by their own method? it will always be nil here given current logic
+          run_callbacks(:allow_conversion, true, checkpoint, variant, participant, metadata)
+        else
+          checkpoint.allow_conversion?(self, variant, metadata)
+        end
+      end
+    end
+  end
+end

data/lib/trail_guide/experiments/enrollment.rb

@@ -0,0 +1,94 @@
+module TrailGuide
+  module Experiments
+    module Enrollment
+      def algorithm
+        @algorithm ||= self.class.algorithm.new(self)
+      end
+
+      def choose!(override: nil, metadata: nil, **opts)
+        return control if TrailGuide.configuration.disabled
+
+        variant = choose_variant!(override: override, metadata: metadata, **opts)
+        run_callbacks(:on_use, variant, participant, metadata)
+        variant
+      rescue Errno::ECONNREFUSED, Redis::BaseError, SocketError => e
+        run_callbacks(:on_redis_failover, e)
+        return variants.find { |var| var == override } || control if override.present?
+        return control
+      end
+
+      def choose_variant!(override: nil, excluded: false, metadata: nil)
+        return control if TrailGuide.configuration.disabled
+
+        if override.present?
+          variant = variants.find { |var| var == override } || control
+          if running? && !is_combined?
+            variant.increment_participation! if configuration.track_override
+            participant.participating!(variant) if configuration.store_override
+          end
+          return variant
+        end
+
+        if winner?
+          variant = winning_variant
+          if track_winner_conversions? && running?
+            variant.increment_participation! unless participant.variant == variant
+            participant.exit! if participant.participating? && participant.variant != variant
+            participant.participating!(variant)
+          end
+          return variant
+        end
+
+        return control if excluded || stopped?
+
+        if !started? && start_manually?
+          if enable_calibration?
+            unless participant.variant == control
+              control.increment_participation!
+              parent.control.increment_participation! if is_combined?
+            end
+
+            if participant.participating? && participant.variant != control
+              participant.exit!
+              parent.participant.exit! if is_combined?
+            end
+
+            participant.participating!(control)
+            parent.participant.participating!(parent.control) if is_combined?
+          end
+          return control
+        end
+
+        start! unless started? || scheduled?
+        return control unless running?
+
+        # only re-use the variant for experiments that store participation,
+        # all other (i.e. content-based) experiments should re-select and
+        # re-assign on enrollment
+        if configuration.sticky_assignment? && participant.participating?
+          variant = participant.variant
+          participant.participating!(variant)
+          return variant
+        end
+
+        return control unless is_combined? || TrailGuide.configuration.allow_multiple_experiments == true || !participant.participating_in_active_experiments?(TrailGuide.configuration.allow_multiple_experiments == false)
+        return control unless allow_participation?(metadata)
+
+        variant = algorithm_choose!(metadata: metadata)
+        variant.increment_participation!
+        participant.participating!(variant)
+        run_callbacks(:on_choose, variant, participant, metadata)
+        variant
+      end
+
+      def algorithm_choose!(metadata: nil)
+        algorithm.choose!(metadata: metadata)
+      end
+
+      def allow_participation?(metadata=nil)
+        return true if callbacks[:allow_participation].empty?
+        run_callbacks(:allow_participation, true, participant, metadata)
+      end
+    end
+  end
+end

data/lib/trail_guide/experiments/lifecycle.rb

@@ -0,0 +1,199 @@
+module TrailGuide
+  module Experiments
+    module Lifecycle
+
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+
+      module ClassMethods
+        def start!(context=nil)
+          return false if started?
+          save! unless persisted?
+          started = adapter.set(:started_at, Time.now.to_i)
+          run_callbacks(:on_start, context)
+          started
+        end
+
+        def schedule!(start_at, stop_at=nil, context=nil)
+          return false if started?
+          save! unless persisted?
+          scheduled = adapter.set(:started_at, start_at.to_i)
+          adapter.set(:stopped_at, stop_at.to_i) if stop_at
+          run_callbacks(:on_schedule, start_at, stop_at, context)
+          scheduled
+        end
+
+        def pause!(context=nil)
+          return false unless running? && configuration.can_resume?
+          paused = adapter.set(:paused_at, Time.now.to_i)
+          run_callbacks(:on_pause, context)
+          paused
+        end
+
+        def stop!(context=nil)
+          return false unless started? && !stopped?
+          stopped = adapter.set(:stopped_at, Time.now.to_i)
+          run_callbacks(:on_stop, context)
+          stopped
+        end
+
+        def resume!(context=nil)
+          return false unless paused? && configuration.can_resume?
+          resumed = adapter.delete(:paused_at)
+          run_callbacks(:on_resume, context)
+          !!resumed
+        end
+
+        def started_at
+          started = adapter.get(:started_at)
+          return Time.at(started.to_i) if started
+        end
+
+        def paused_at
+          paused = adapter.get(:paused_at)
+          return Time.at(paused.to_i) if paused
+        end
+
+        def stopped_at
+          stopped = adapter.get(:stopped_at)
+          return Time.at(stopped.to_i) if stopped
+        end
+
+        def started?
+          time = started_at
+          time && time <= Time.now
+        end
+
+        def scheduled?
+          time = started_at
+          time && time > Time.now
+        end
+
+        def paused?
+          time = paused_at
+          time && time <= Time.now
+        end
+
+        def stopped?
+          time = stopped_at
+          time && time <= Time.now
+        end
+
+        def running?
+          started? && !paused? && !stopped?
+        end
+
+        def calibrating?
+          enable_calibration? && start_manually? && !started?
+        end
+
+        def fresh?
+          !started? && !scheduled? && !winner?
+        end
+
+        def declare_winner!(variant, context=nil)
+          variant = variants.find { |var| var == variant } unless variant.is_a?(Variant)
+          return false unless variant.present? && variant.experiment == self
+          run_callbacks(:on_winner, variant, context)
+          adapter.set(:winner, variant.name)
+          variant
+        end
+
+        def clear_winner!
+          adapter.delete(:winner)
+        end
+
+        def winner?
+          if combined?
+            combined.all? { |combo| TrailGuide.catalog.find(combo).winner? }
+          else
+            adapter.exists?(:winner)
+          end
+        end
+
+        def run_callbacks(hook, *args)
+          return unless callbacks[hook]
+          return args[0] if hook == :rollout_winner # TODO do we need to account for this case here at the class level?
+          args.unshift(self)
+          callbacks[hook].each do |callback|
+            if callback.respond_to?(:call)
+              callback.call(*args)
+            else
+              send(callback, *args)
+            end
+          end
+        end
+      end
+
+      def run_callbacks(hook, *args)
+        return unless callbacks[hook]
+        if [:allow_participation, :allow_conversion, :rollout_winner].include?(hook)
+          callbacks[hook].reduce(args.slice!(0,1)[0]) do |result, callback|
+            if callback.respond_to?(:call)
+              callback.call(self, result, *args)
+            else
+              send(callback, self, result, *args)
+            end
+          end
+        else
+          args.unshift(self)
+          callbacks[hook].each do |callback|
+            if callback.respond_to?(:call)
+              callback.call(*args)
+            else
+              send(callback, *args)
+            end
+          end
+        end
+      end
+
+      def start!
+        @started_at = nil
+        self.class.start!
+      end
+
+      def started_at
+        @started_at ||= self.class.started_at
+      end
+
+      def paused_at
+        @paused_at ||= self.class.paused_at
+      end
+
+      def stopped_at
+        @stopped_at ||= self.class.stopped_at
+      end
+
+      def scheduled?
+        started_at && started_at > Time.now
+      end
+
+      def started?
+        started_at && started_at <= Time.now
+      end
+
+      def paused?
+        paused_at && paused_at <= Time.now
+      end
+
+      def stopped?
+        stopped_at && stopped_at <= Time.now
+      end
+
+      def running?
+        started? && !paused? && !stopped?
+      end
+
+      def calibrating?
+        enable_calibration? && start_manually? && !started?
+      end
+
+      def winner?
+        return @has_winner unless @has_winner.nil?
+        @has_winner = self.class.winner?
+      end
+
+    end
+  end
+end

data/lib/trail_guide/experiments/persistence.rb

@@ -0,0 +1,45 @@
+module TrailGuide
+  module Experiments
+    module Persistence
+
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+
+      module ClassMethods
+        def adapter
+          @adapter ||= TrailGuide::Adapters::Experiments::Redis.new(self)
+        end
+
+        def persisted?
+          adapter.persisted?
+        end
+
+        def save!
+          combined_experiments.each(&:save!)
+          variants.each(&:save!)
+          adapter.setnx(:name, experiment_name)
+        end
+
+        def delete!(context=nil)
+          combined.each { |combo| TrailGuide.catalog.find(combo).delete! }
+          variants.each(&:delete!)
+          deleted = adapter.destroy
+          run_callbacks(:on_delete, context)
+          true
+        end
+
+        def reset!(context=nil)
+          delete!(context)
+          save!
+          run_callbacks(:on_reset, context)
+          true
+        end
+
+        def storage_key
+          configuration.name
+        end
+      end
+    end
+  end
+end

data/lib/trail_guide/experiments/results.rb

@@ -0,0 +1,44 @@
+module TrailGuide
+  module Experiments
+    module Results
+
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+
+      module ClassMethods
+        def winner
+          winner = adapter.get(:winner)
+          return variants.find { |var| var == winner } if winner
+        end
+
+        def participants
+          variants.sum(&:participants)
+        end
+
+        def converted(checkpoint=nil)
+          variants.sum { |var| var.converted(checkpoint) }
+        end
+
+        def unconverted
+          participants - converted
+        end
+
+        def target_sample_size_reached?
+          return true unless configuration.target_sample_size
+          return true if participants >= configuration.target_sample_size
+          return false
+        end
+      end
+
+      def winner
+        @winner ||= self.class.winner
+      end
+
+      def winning_variant
+        return nil unless winner?
+        run_callbacks(:rollout_winner, winner, participant)
+      end
+    end
+  end
+end

data/lib/trail_guide/variants.rb

@@ -0,0 +1,39 @@
+module TrailGuide
+  class Variants
+    attr_reader :variants
+    alias_method :to_a, :variants
+    delegate :each, :map, to: :variants
+
+    def initialize(*vars)
+      @variants = vars.flatten
+    end
+
+    def dup(experiment)
+      self.class.new(variants.map { |var| var.dup(experiment) })
+    end
+
+    def control
+      variants.find { |var| var.control? }
+    end
+
+    def method_missing(meth, *args, &block)
+      variant = variants.find { |var| var == meth }
+      return variant if variant.present?
+
+      if variants.respond_to?(meth, true)
+        result = variants.send(meth, *args, &block)
+        if result.is_a?(Array)
+          return self.class.new(result)
+        else
+          return result
+        end
+      end
+
+      super
+    end
+
+    def respond_to_missing?(meth, include_private=false)
+      variants.find { |var| var == meth }.present? || variants.respond_to?(meth, include_private)
+    end
+  end
+end

data/lib/trail_guide/version.rb

@@ -2,7 +2,7 @@ module TrailGuide
   module Version
     MAJOR = 0
     MINOR = 3
-    PATCH = 0
+    PATCH = 1
     VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
 
     class << self

data/lib/trailguide.rb

@@ -9,6 +9,7 @@ require "trail_guide/metrics"
 require "trail_guide/calculators"
 require "trail_guide/participant"
 require "trail_guide/variant"
+require "trail_guide/variants"
 require "trail_guide/experiment"
 require "trail_guide/combined_experiment"
 require "trail_guide/catalog"
@@ -23,6 +24,6 @@ module TrailGuide
   SCHEDULE_DATE_FORMAT = "%m/%d/%Y %I:%M %p %Z"
 
   class << self
-    delegate :logger, :redis, to: :configuration
+    delegate :logger, :redis, :redis_client, to: :configuration
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailguide
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Mark Rebec
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-27 00:00:00.000000000 Z
+date: 2020-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -269,7 +269,12 @@ files:
 - lib/trail_guide/experiments/base.rb
 - lib/trail_guide/experiments/combined_config.rb
 - lib/trail_guide/experiments/config.rb
+- lib/trail_guide/experiments/conversion.rb
+- lib/trail_guide/experiments/enrollment.rb
+- lib/trail_guide/experiments/lifecycle.rb
 - lib/trail_guide/experiments/participant.rb
+- lib/trail_guide/experiments/persistence.rb
+- lib/trail_guide/experiments/results.rb
 - lib/trail_guide/helper.rb
 - lib/trail_guide/helper/experiment_proxy.rb
 - lib/trail_guide/helper/helper_proxy.rb
@@ -282,6 +287,7 @@ files:
 - lib/trail_guide/spec_helper.rb
 - lib/trail_guide/unity.rb
 - lib/trail_guide/variant.rb
+- lib/trail_guide/variants.rb
 - lib/trail_guide/version.rb
 - lib/trailguide.rb
 homepage: https://github.com/markrebec/trailguide
@@ -303,8 +309,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: User experiments for rails