trailguide 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5adb31d9a97b2a73b6ff57b91d7f3907d408c511821b72fe0f7b1f857873a794
-  data.tar.gz: 3e054cb7abcd176989b6a322f3f9b34e69d2b2b662824a2a84b4e2c3a6c1040a
+  metadata.gz: a43a9a982533a051bb03fb7c0d8dc4434be3b60e653fa8225ecb001268acd03f
+  data.tar.gz: c80071f1f4e4f0c442b3e875a77810d92c9ed775518b19f1f13390577fb1c1c0
 SHA512:
-  metadata.gz: eeefcc9c9b4e08bfe433b576ca5da9614e6295ae354a4858811af3fad1660cd5c3acdecd8afeaa61ed17edbff34d7eebc2bd797ae8c421c199096c4402bc8d83
-  data.tar.gz: 92d4106bff4e3ba5db67e4812b02029126ce3fb43790525c1be0a024fa5dae84cd4b44f4a75e361f4f1c605228bf8fb84e9fa371485ef77058bf3310b33042e2
+  metadata.gz: d084c8a7461256672372a1440e2a4c68d73ebe393acd8378346c45c1ad082aebe4b0d2346919e0f4f5324c09257bb525dda244fe0a72b9114e094e657d4938c1
+  data.tar.gz: f3ddb4f30ef7b0928f2851a42ce194c3b67bc46ea863821fd50154fecdf72b8b56a355bf6b7d2b2cb937d7b9d8f9029cf22f142d1f28c5eec7dbd13ce29e12bb

data/app/controllers/trail_guide/experiments_controller.rb

@@ -1,7 +1,12 @@
 module TrailGuide
   class ExperimentsController < ::ApplicationController
-    before_action do
-      render json: { error: "Experiment does not exist" }, status: 404 and return unless experiment.present?
+    before_action :ensure_experiment, except: [:index]
+
+    def index
+      participant = trailguide.participant
+      render json: {
+        experiments: participant.active_experiments
+      }
     end
 
     def choose
@@ -39,5 +44,9 @@ module TrailGuide
     def metadata
       @metadata ||= params[:metadata].try(:permit!) || {}
     end
+
+    def ensure_experiment
+      render json: { error: "Experiment does not exist" }, status: 404 and return false unless experiment.present?
+    end
   end
 end

data/config/routes.rb

@@ -1,4 +1,6 @@
 TrailGuide::Engine.routes.draw do
+  get   '/' => 'experiments#index',
+        defaults: { format: :json }
   get   '/:experiment_name' => 'experiments#choose',
         defaults: { format: :json }
   match '/:experiment_name' => 'experiments#convert',

data/lib/trail_guide/adapters/participants/cookie.rb

@@ -26,7 +26,7 @@ module TrailGuide
 
         # instance method, creates a new adapter and passes through config
         def new(context)
-          raise NoMethodError, "Your current context (#{context}) does not support cookies" unless context.respond_to?(:cookies, true)
+          raise UnsupportedContextError, "Your current context (#{context}) does not support cookies" unless context.respond_to?(:cookies, true)
           Adapter.new(context, configuration)
         end
 

data/lib/trail_guide/adapters/participants/redis.rb

@@ -43,8 +43,7 @@ module TrailGuide
               end
               @storage_key = "#{config.namespace}:#{key}"
             else
-              # TODO better error
-              raise ArgumentError, "You must configure a `lookup` proc"
+              raise ArgumentError, "You must configure a `lookup` proc to use the redis adapter."
             end
           end
 

data/lib/trail_guide/adapters/participants/session.rb

@@ -21,7 +21,7 @@ module TrailGuide
 
         # instance method, creates a new adapter and passes through config
         def new(context)
-          raise NoMethodError, "Your current context (#{context}) does not support sessions" unless context.respond_to?(:session, true)
+          raise UnsupportedContextError, "Your current context (#{context}) does not support sessions" unless context.respond_to?(:session, true)
           Adapter.new(context, configuration)
         end
 

data/lib/trail_guide/engine.rb

@@ -38,17 +38,20 @@ module TrailGuide
           end
         end
 
-        DSL.experiment(name) do
+        DSL.experiment(name) do |config|
           expvars.each do |expvar|
             variant *expvar
           end
-          control                     options[:control] if options[:control]
-          algorithm                   options[:algorithm] if options[:algorithm]
-          goals                       options[:goals] if options[:goals]
-          metric                      options[:metric] if options[:metric]
-          resettable                  options[:resettable] if options.key?(:resettable)
-          allow_multiple_conversions  options[:allow_multiple_conversions] if options.key?(:allow_multiple_conversions)
-          allow_multiple_goals        options[:allow_multiple_goals] if options.key?(:allow_multiple_goals)
+          config.control                    = options[:control] if options[:control]
+          config.metric                     = options[:metric] if options[:metric]
+          config.algorithm                  = options[:algorithm] if options[:algorithm]
+          config.goals                      = options[:goals] if options[:goals]
+          config.reset_manually             = options[:reset_manually] if options.key?(:reset_manually)
+          config.start_manually             = options[:start_manually] if options.key?(:start_manually)
+          config.store_override             = options[:store_override] if options.key?(:store_override)
+          config.track_override             = options[:track_override] if options.key?(:track_override)
+          config.allow_multiple_conversions = options[:allow_multiple_conversions] if options.key?(:allow_multiple_conversions)
+          config.allow_multiple_goals       = options[:allow_multiple_goals] if options.key?(:allow_multiple_goals)
         end
       end
     end
@@ -56,8 +59,8 @@ module TrailGuide
     class DSL
       def self.experiment(name, &block)
         Class.new(TrailGuide::Experiment) do
-          experiment_name name
-          instance_eval &block
+          configure name: name
+          configure &block
         end
       end
     end

data/lib/trail_guide/errors.rb

@@ -0,0 +1,7 @@
+module TrailGuide
+  class InvalidGoalError < ArgumentError; end
+  class UnsupportedContextError < NoMethodError; end
+  class NoExperimentsError < ArgumentError; end
+  class TooManyExperimentsError < ArgumentError; end
+  class NoVariantMethodError < NoMethodError; end
+end

data/lib/trail_guide/experiment.rb

@@ -1,160 +1,40 @@
+require "trail_guide/experiment_config"
+
 module TrailGuide
   class Experiment
     class << self
+      delegate :metric, :algorithm, :control, :goals, :callbacks,
+        :allow_multiple_conversions?, :allow_multiple_goals?, to: :configuration
+      alias_method :funnels, :goals
+
       def inherited(child)
-        # TODO allow inheriting algo, variants, goals, metrics, etc.
         TrailGuide::Catalog.register(child)
       end
 
-      # TODO could probably move all this configuration stuff at the class level
-      # into a canfig object instead...?
-      def experiment_name(name=nil)
-        @experiment_name = name.to_s.underscore.to_sym unless name.nil?
-        @experiment_name || self.name.try(:underscore).try(:to_sym)
+      def configuration
+        @configuration ||= ExperimentConfig.new(self)
       end
 
-      def config_algorithm
-        config_algo = TrailGuide.configuration.algorithm
-        case config_algo
-        when :weighted
-          config_algo = TrailGuide::Algorithms::Weighted
-        when :bandit
-          config_algo = TrailGuide::Algorithms::Bandit
-        when :distributed
-          config_algo = TrailGuide::Algorithms::Distributed
-        when :random
-          config_algo = TrailGuide::Algorithms::Random
-        else
-          config_algo = config_algo.constantize if config_algo.is_a?(String)
-        end
-        config_algo
-      end
-
-      def algorithm(algo=nil)
-        @algorithm = TrailGuide::Algorithms.algorithm(algo) unless algo.nil?
-        @algorithm ||= TrailGuide::Algorithms.algorithm(TrailGuide.configuration.algorithm)
-      end
-
-      def resettable(reset)
-        @resettable = reset
+      def configure(*args, &block)
+        configuration.configure(*args, &block)
       end
 
       def resettable?
-        if @resettable.nil?
-          !TrailGuide.configuration.reset_manually
-        else
-          !!@resettable
-        end
+        !configuration.reset_manually
       end
 
-      def variant(name, metadata: {}, weight: 1, control: false)
-        raise ArgumentError, "The variant #{name} already exists in experiment #{experiment_name}" if variants.any? { |var| var == name }
-        control = true if variants.empty?
-        variant = Variant.new(self, name, metadata: metadata, weight: weight, control: control)
-        variants << variant
-        variant
+      def experiment_name
+        configuration.name
       end
 
       def variants(include_control=true)
-        @variants ||= []
         if include_control
-          @variants
+          configuration.variants
         else
-          @variants.select { |var| !var.control? }
+          configuration.variants.select { |var| !var.control? }
         end
       end
 
-      def control(name=nil)
-        return variants.find { |var| var.control? } || variants.first if name.nil?
-
-        variants.each(&:variant!)
-        var_idx = variants.index { |var| var == name }
-
-        if var_idx.nil?
-          variant = Variant.new(self, name, control: true)
-        else
-          variant = variants.slice!(var_idx, 1)[0]
-          variant.control!
-        end
-
-        variants.unshift(variant)
-        return variant
-      end
-
-      def funnel(name)
-        funnels << name.to_s.underscore.to_sym
-      end
-      alias_method :goal, :funnel
-
-      def funnels(arr=nil)
-        @funnels = arr unless arr.nil?
-        @funnels ||= []
-      end
-      alias_method :goals, :funnels
-
-      def metric(key=nil)
-        @metric = key.to_s.underscore.to_sym unless key.nil?
-        @metric ||= experiment_name
-      end
-
-      def allow_multiple_conversions(allow)
-        @allow_multiple_conversions = allow
-      end
-
-      def allow_multiple_conversions?
-        !!@allow_multiple_conversions
-      end
-
-      def allow_multiple_goals(allow)
-        @allow_multiple_goals = allow
-      end
-
-      def allow_multiple_goals?
-        !!@allow_multiple_goals
-      end
-
-      def callbacks
-        @callbacks ||= begin
-          callbacks = {
-            on_choose:   [TrailGuide.configuration.on_experiment_choose].compact,
-            on_use:      [TrailGuide.configuration.on_experiment_use].compact,
-            on_convert:  [TrailGuide.configuration.on_experiment_convert].compact,
-            on_start:    [TrailGuide.configuration.on_experiment_start].compact,
-            on_stop:     [TrailGuide.configuration.on_experiment_stop].compact,
-            on_reset:    [TrailGuide.configuration.on_experiment_reset].compact,
-            on_delete:   [TrailGuide.configuration.on_experiment_delete].compact,
-          }
-        end
-      end
-
-      def on_choose(meth=nil, &block)
-        callbacks[:on_choose] << (meth || block)
-      end
-
-      def on_use(meth=nil, &block)
-        callbacks[:on_use] << (meth || block)
-      end
-
-      def on_convert(meth=nil, &block)
-        callbacks[:on_convert] << (meth || block)
-      end
-
-      def on_start(meth=nil, &block)
-        callbacks[:on_start] << (meth || block)
-      end
-
-      def on_stop(meth=nil, &block)
-        callbacks[:on_stop] << (meth || block)
-      end
-
-      def on_reset(meth=nil, &block)
-        callbacks[:on_reset] << (meth || block)
-      end
-
-      def on_delete(meth=nil, &block)
-        callbacks[:on_delete] << (meth || block)
-      end
-
       def run_callbacks(hook, *args)
         return unless callbacks[hook]
         args.unshift(self)
@@ -252,9 +132,9 @@ module TrailGuide
     end
 
     attr_reader :participant
-    delegate :experiment_name, :variants, :control, :funnels, :storage_key,
-      :started?, :started_at, :start!, :resettable?, :winner?, :winner,
-      :allow_multiple_conversions?, :allow_multiple_goals?, :callbacks,
+    delegate :configuration, :experiment_name, :variants, :control, :funnels,
+      :storage_key, :started?, :started_at, :start!, :resettable?, :winner?,
+      :winner, :allow_multiple_conversions?, :allow_multiple_goals?, :callbacks,
       to: :class
 
     def initialize(participant)
@@ -269,7 +149,7 @@ module TrailGuide
       return control if TrailGuide.configuration.disabled
 
       variant = choose_variant!(override: override, metadata: metadata, **opts)
-      participant.participating!(variant) unless override.present? && !TrailGuide.configuration.store_override
+      participant.participating!(variant) unless override.present? && !configuration.store_override
       run_callbacks(:on_use, variant, metadata)
       variant
     end
@@ -278,11 +158,11 @@ module TrailGuide
       return control if TrailGuide.configuration.disabled
       if override.present?
         variant = variants.find { |var| var == override }
-        return variant unless TrailGuide.configuration.track_override && started?
+        return variant unless configuration.track_override && started?
       else
         return winner if winner?
         return control if excluded
-        return control if !started? && TrailGuide.configuration.start_manually
+        return control if !started? && configuration.start_manually
         start! unless started?
         return variants.find { |var| var == participant[storage_key] } if participating?
         return control unless TrailGuide.configuration.allow_multiple_experiments == true || !participant.participating_in_active_experiments?(TrailGuide.configuration.allow_multiple_experiments == false) 
@@ -297,8 +177,8 @@ module TrailGuide
 
     def convert!(checkpoint=nil, metadata: nil)
       return false unless participating?
-      raise ArgumentError, "You must provide a valid goal checkpoint for #{experiment_name}" unless checkpoint.present? || funnels.empty?
-      raise ArgumentError, "Unknown goal checkpoint: #{checkpoint}" unless checkpoint.nil? || funnels.any? { |funnel| funnel == checkpoint.to_s.underscore.to_sym }
+      raise InvalidGoalError, "Invalid goal checkpoint `#{checkpoint}` for `#{experiment_name}`." unless checkpoint.present? || funnels.empty?
+      raise InvalidGoalError, "Invalid goal checkpoint `#{checkpoint}` for `#{experiment_name}`." unless checkpoint.nil? || funnels.any? { |funnel| funnel == checkpoint.to_s.underscore.to_sym }
       # TODO eventually allow progressing through funnel checkpoints towards goals
       if converted?(checkpoint)
         return false unless allow_multiple_conversions?

data/lib/trail_guide/experiment_config.rb

@@ -0,0 +1,132 @@
+module TrailGuide
+  class ExperimentConfig < Canfig::Config
+    ENGINE_CONFIG_KEYS = [
+      :start_manually, :reset_manually, :store_override, :track_override,
+      :algorithm, :allow_multiple_conversions, :allow_multiple_goals
+    ].freeze
+
+    def self.engine_config
+      ENGINE_CONFIG_KEYS.map do |key|
+        [key, TrailGuide.configuration.send(key.to_sym)]
+      end.to_h
+    end
+
+    def self.default_config
+      { name: nil, metric: nil, variants: [], goals: [] }
+    end
+
+    def self.callbacks_config
+      {
+        callbacks: {
+          on_choose:   [TrailGuide.configuration.on_experiment_choose].flatten.compact,
+          on_use:      [TrailGuide.configuration.on_experiment_use].flatten.compact,
+          on_convert:  [TrailGuide.configuration.on_experiment_convert].flatten.compact,
+          on_start:    [TrailGuide.configuration.on_experiment_start].flatten.compact,
+          on_stop:     [TrailGuide.configuration.on_experiment_stop].flatten.compact,
+          on_reset:    [TrailGuide.configuration.on_experiment_reset].flatten.compact,
+          on_delete:   [TrailGuide.configuration.on_experiment_delete].flatten.compact,
+        }
+      }
+    end
+
+    attr_reader :experiment
+
+    def initialize(experiment, *args, **opts, &block)
+      @experiment = experiment
+      opts = opts.merge(self.class.engine_config)
+      opts = opts.merge(self.class.default_config)
+      opts = opts.merge(self.class.callbacks_config)
+      super(*args, **opts, &block)
+    end
+
+    def resettable?
+      !reset_manually
+    end
+
+    def allow_multiple_conversions?
+      allow_multiple_conversions
+    end
+
+    def allow_multiple_goals?
+      allow_multiple_goals
+    end
+
+    def name
+      @name ||= (self[:name] || experiment.name).try(:to_s).try(:underscore).try(:to_sym)
+    end
+
+    def metric
+      @metric ||= (self[:metric] || name).try(:to_s).try(:underscore).try(:to_sym)
+    end
+
+    def algorithm
+      @algorithm ||= TrailGuide::Algorithms.algorithm(self[:algorithm])
+    end
+
+    def variant(varname, metadata: {}, weight: 1, control: false)
+      raise ArgumentError, "The variant `#{varname}` already exists in the experiment `#{name}`" if variants.any? { |var| var == varname }
+      control = true if variants.empty?
+      variants.each(&:variant!) if control
+      variant = Variant.new(experiment, varname, metadata: metadata, weight: weight, control: control)
+      variants << variant
+      variant
+    end
+
+    def control
+      return variants.find { |var| var.control? } || variants.first
+    end
+
+    def control=(name)
+      variants.each(&:variant!)
+      var_idx = variants.index { |var| var == name }
+
+      if var_idx.nil?
+        variant = Variant.new(experiment, name, control: true)
+      else
+        variant = variants.slice!(var_idx, 1)[0]
+        variant.control!
+      end
+
+      variants.unshift(variant)
+      variant
+    end
+
+    def goal(name)
+      goals << name.to_s.underscore.to_sym
+    end
+    alias_method :funnel, :goal
+
+    def goals
+      self[:goals]
+    end
+    alias_method :funnels, :goals
+
+    def on_choose(meth=nil, &block)
+      callbacks[:on_choose] << (meth || block)
+    end
+
+    def on_use(meth=nil, &block)
+      callbacks[:on_use] << (meth || block)
+    end
+
+    def on_convert(meth=nil, &block)
+      callbacks[:on_convert] << (meth || block)
+    end
+
+    def on_start(meth=nil, &block)
+      callbacks[:on_start] << (meth || block)
+    end
+
+    def on_stop(meth=nil, &block)
+      callbacks[:on_stop] << (meth || block)
+    end
+
+    def on_reset(meth=nil, &block)
+      callbacks[:on_reset] << (meth || block)
+    end
+
+    def on_delete(meth=nil, &block)
+      callbacks[:on_delete] << (meth || block)
+    end
+  end
+end

data/lib/trail_guide/helper.rb

@@ -53,10 +53,11 @@ module TrailGuide
       def initialize(context, metric, **opts)
         super(context, **opts)
         @metric = metric
+        raise NoExperimentsError, "Could not find any experiments matching `#{metric}`." if experiments.empty?
       end
 
       def choose!(**opts, &block)
-        raise ArgumentError, "Please provide a single experiment" unless experiments.length == 1
+        raise TooManyExperimentsError, "Selecting a variant requires a single experiment, but the metric `#{metric}` matches more than one experiment." if experiments.length > 1
         opts = {override: override_variant, excluded: exclude_visitor?}.merge(opts)
         variant = experiment.choose!(**opts)
         if block_given?
@@ -67,21 +68,20 @@ module TrailGuide
       end
 
       def run!(methods: nil, **opts)
-        raise ArgumentError, "Please provide a single experiment" unless experiments.length == 1
         choose!(**opts) do |variant, metadata|
           varmeth = methods[variant.name] if methods
           varmeth ||= variant.name
 
           unless context.respond_to?(varmeth, true)
             if context_type == :controller
-              raise NoMethodError,
-                "You must define a controller method that matches variant `#{variant.name}` in your experiment `#{metric}`. In this case it looks like you need to define #{context.class.name}##{varmeth}(metadata={})"
+              raise NoVariantMethodError,
+                "Undefined local method `#{varmeth}`. You must define a controller method matching the variant `#{variant.name}` in your experiment `#{metric}`. In this case it looks like you need to define #{context.class.name}##{varmeth}(metadata={})"
             elsif context_type == :template
-              raise NoMethodError,
-                "You must define a helper method that matches variant `#{variant.name}` in your experiment `#{metric}`. In this case it looks like you need to define ApplicationHelper##{varmeth}(metadata={})"
+              raise NoVariantMethodError,
+                "Undefined local method `#{varmeth}`. You must define a helper method matching the variant `#{variant.name}` in your experiment `#{metric}`. In this case it looks like you need to define ApplicationHelper##{varmeth}(metadata={})"
             else
-              raise NoMethodError,
-                "You must define a method that matches variant `#{variant.name}` in your experiment `#{metric}`. In this case it looks like you need to define #{context.class.name}##{varmeth}(metadata={})"
+              raise NoVariantMethodError,
+                "Undefined local method `#{varmeth}`. You must define a method matching the variant `#{variant.name}` in your experiment `#{metric}`. In this case it looks like you need to define #{context.class.name}##{varmeth}(metadata={})"
             end
           end
 
@@ -97,8 +97,7 @@ module TrailGuide
       end
 
       def render!(prefix: nil, templates: nil, **opts)
-        raise NoMethodError, "The current context does not support rendering. Rendering is only available for controllers and views." unless context.respond_to?(:render, true)
-        raise ArgumentError, "Please provide a single experiment" unless experiments.length == 1
+        raise UnsupportedContextError, "The current context (#{context}) does not support rendering. Rendering is only available in controllers and views." unless context.respond_to?(:render, true)
         choose!(**opts) do |variant, metadata|
           locals = { variant: variant, metadata: variant.metadata }
           locals = { locals: locals } if context_type == :controller

data/lib/trail_guide/participant.rb

@@ -42,14 +42,14 @@ module TrailGuide
 
     def converted?(experiment, checkpoint=nil)
       if experiment.funnels.empty?
-        raise ArgumentError, "This experiment does not have any defined goal checkpoints" unless checkpoint.nil?
+        raise InvalidGoalError, "You provided the checkpoint `#{checkpoint}` but the experiment `#{experiment.experiment_name}` does not have any goals defined." unless checkpoint.nil?
         storage_key = "#{experiment.storage_key}:converted"
         return false unless adapter.key?(storage_key)
 
         converted_at = Time.at(adapter[storage_key].to_i)
         converted_at >= experiment.started_at
       elsif !checkpoint.nil?
-        raise ArgumentError, "Invalid goal checkpoint: #{checkpoint}" unless experiment.funnels.any? { |funnel| funnel == checkpoint.to_s.underscore.to_sym }
+        raise InvalidGoalError, "Invalid goal checkpoint `#{checkpoint}` for experiment `#{experiment.experiment_name}`." unless experiment.funnels.any? { |funnel| funnel == checkpoint.to_s.underscore.to_sym }
         storage_key = "#{experiment.storage_key}:#{checkpoint.to_s.underscore}"
         return false unless adapter.key?(storage_key)
 

data/lib/trail_guide/variant.rb

@@ -58,10 +58,10 @@ module TrailGuide
 
     def converted(checkpoint=nil)
       if experiment.funnels.empty?
-        raise ArgumentError, "This experiment does not have any defined goal checkpoints" unless checkpoint.nil?
+        raise InvalidGoalError, "You provided the checkpoint `#{checkpoint}` but the experiment `#{experiment.experiment_name}` does not have any goals defined." unless checkpoint.nil?
         (TrailGuide.redis.hget(storage_key, 'converted') || 0).to_i
       elsif !checkpoint.nil?
-        raise ArgumentError, "Invalid goal checkpoint: #{checkpoint}" unless experiment.funnels.any? { |funnel| funnel == checkpoint.to_s.underscore.to_sym }
+        raise InvalidGoalError, "Invalid goal checkpoint `#{checkpoint}` for experiment `#{experiment.experiment_name}`." unless experiment.funnels.any? { |funnel| funnel == checkpoint.to_s.underscore.to_sym }
         (TrailGuide.redis.hget(storage_key, checkpoint.to_s.underscore) || 0).to_i
       else
         experiment.funnels.sum do |checkpoint|

data/lib/trail_guide/version.rb

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

data/lib/trailguide.rb

@@ -1,5 +1,6 @@
 require "canfig"
 require "redis"
+require "trail_guide/errors"
 require "trail_guide/adapters"
 require "trail_guide/algorithms"
 require "trail_guide/participant"
@@ -20,9 +21,11 @@ module TrailGuide
     config.store_override = false
     config.track_override = false
     config.override_parameter = :experiment
-    config.allow_multiple_experiments = true # false / :control
     config.algorithm = :weighted
     config.adapter = :multi
+    config.allow_multiple_experiments = true # false / :control
+    config.allow_multiple_conversions = false
+    config.allow_multiple_goals = false
 
     config.on_experiment_choose = nil  # -> (experiment, variant, metadata) { ... }
     config.on_experiment_use = nil     # -> (experiment, variant, metadata) { ... }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trailguide
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Mark Rebec
@@ -130,7 +130,9 @@ files:
 - lib/trail_guide/algorithms/weighted.rb
 - lib/trail_guide/catalog.rb
 - lib/trail_guide/engine.rb
+- lib/trail_guide/errors.rb
 - lib/trail_guide/experiment.rb
+- lib/trail_guide/experiment_config.rb
 - lib/trail_guide/helper.rb
 - lib/trail_guide/participant.rb
 - lib/trail_guide/unity.rb