diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml
index 81cda7db..8d6cad1d 100644
--- a/.rubocop_todo.yml
+++ b/.rubocop_todo.yml
@@ -186,20 +186,6 @@ Style/DefWithParentheses:
   Exclude:
     - 'lib/split/helper.rb'
 
-# Offense count: 23
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle, UseHashRocketsWithSymbolValues, PreferHashRocketsForNonAlnumEndingSymbols.
-# SupportedStyles: ruby19, hash_rockets, no_mixed_keys, ruby19_no_mixed_keys
-Style/HashSyntax:
-  Exclude:
-    - 'Rakefile'
-    - 'lib/split/experiment.rb'
-    - 'lib/split/experiment_catalog.rb'
-    - 'lib/split/helper.rb'
-    - 'lib/split/metric.rb'
-    - 'lib/split/persistence.rb'
-    - 'lib/split/persistence/redis_adapter.rb'
-
 # Offense count: 1
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle.
diff --git a/Rakefile b/Rakefile
index 76d8776e..f47f8b65 100755
--- a/Rakefile
+++ b/Rakefile
@@ -6,4 +6,4 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new('spec')
 
-task :default => :spec
\ No newline at end of file
+task default: :spec
\ No newline at end of file
diff --git a/lib/split/algorithms.rb b/lib/split/algorithms.rb
index eddc0d01..defd8325 100644
--- a/lib/split/algorithms.rb
+++ b/lib/split/algorithms.rb
@@ -17,4 +17,4 @@ def beta_distribution_rng(a, b)
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/split/cache.rb b/lib/split/cache.rb
index 6611bfdb..f570af7f 100644
--- a/lib/split/cache.rb
+++ b/lib/split/cache.rb
@@ -2,7 +2,6 @@
 
 module Split
   class Cache
-
     def self.clear
       @cache = nil
     end
diff --git a/lib/split/experiment.rb b/lib/split/experiment.rb
index 2b892e85..b31e09a4 100644
--- a/lib/split/experiment.rb
+++ b/lib/split/experiment.rb
@@ -11,7 +11,7 @@ class Experiment
     attr_reader :resettable
 
     DEFAULT_OPTIONS = {
-      :resettable => true
+      resettable: true
     }
 
     def self.find(name)
diff --git a/lib/split/experiment_catalog.rb b/lib/split/experiment_catalog.rb
index 649b448a..076fd3e1 100644
--- a/lib/split/experiment_catalog.rb
+++ b/lib/split/experiment_catalog.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   class ExperimentCatalog
     # Return all experiments
@@ -26,7 +27,7 @@ def self.find_or_initialize(metric_descriptor, control = nil, *alternatives)
       experiment_name_with_version, goals = normalize_experiment(metric_descriptor)
       experiment_name = experiment_name_with_version.to_s.split(':')[0]
       Split::Experiment.new(experiment_name,
-          :alternatives => [control].compact + alternatives, :goals => goals)
+          alternatives: [control].compact + alternatives, goals: goals)
     end
 
     def self.find_or_create(metric_descriptor, control = nil, *alternatives)
diff --git a/lib/split/helper.rb b/lib/split/helper.rb
index 5494ca42..983cdded 100644
--- a/lib/split/helper.rb
+++ b/lib/split/helper.rb
@@ -12,9 +12,9 @@ def ab_test(metric_descriptor, control = nil, *alternatives)
         alternative = if Split.configuration.enabled && !exclude_visitor?
           experiment.save
           raise(Split::InvalidExperimentsFormatError) unless (Split.configuration.experiments || {}).fetch(experiment.name.to_sym, {})[:combined_experiments].nil?
-          trial = Trial.new(:user => ab_user, :experiment => experiment,
-              :override => override_alternative(experiment.name), :exclude => exclude_visitor?,
-              :disabled => split_generically_disabled?)
+          trial = Trial.new(user: ab_user, experiment: experiment,
+              override: override_alternative(experiment.name), exclude: exclude_visitor?,
+              disabled: split_generically_disabled?)
           alt = trial.choose!(self)
           alt ? alt.name : nil
         else
@@ -44,7 +44,7 @@ def reset!(experiment)
       ab_user.delete(experiment.key)
     end
 
-    def finish_experiment(experiment, options = {:reset => true})
+    def finish_experiment(experiment, options = {reset: true})
       return false if active_experiments[experiment.name].nil?
       return true if experiment.has_winner?
       should_reset = experiment.resettable? && options[:reset]
@@ -53,10 +53,10 @@ def finish_experiment(experiment, options = {:reset => true})
       else
         alternative_name = ab_user[experiment.key]
         trial = Trial.new(
-          :user => ab_user, 
-          :experiment => experiment,
-          :alternative => alternative_name,
-          :goals => options[:goals],
+          user: ab_user, 
+          experiment: experiment,
+          alternative: alternative_name,
+          goals: options[:goals],
         )      
         
         trial.complete!(self)
@@ -69,7 +69,7 @@ def finish_experiment(experiment, options = {:reset => true})
       end
     end
 
-    def ab_finished(metric_descriptor, options = {:reset => true})
+    def ab_finished(metric_descriptor, options = {reset: true})
       return if exclude_visitor? || Split.configuration.disabled?
       metric_descriptor, goals = normalize_metric(metric_descriptor)
       experiments = Metric.possible_experiments(metric_descriptor)
@@ -77,7 +77,7 @@ def ab_finished(metric_descriptor, options = {:reset => true})
       if experiments.any?
         experiments.each do |experiment|
           next if override_present?(experiment.key)
-          finish_experiment(experiment, options.merge(:goals => goals))
+          finish_experiment(experiment, options.merge(goals: goals))
         end
       end
     rescue => e
diff --git a/lib/split/metric.rb b/lib/split/metric.rb
index b367da6c..6b4f1a9a 100644
--- a/lib/split/metric.rb
+++ b/lib/split/metric.rb
@@ -22,7 +22,7 @@ def self.load_from_redis(name)
           Split::ExperimentCatalog.find(experiment_name)
         end
 
-        Split::Metric.new(:name => name, :experiments => experiments)
+        Split::Metric.new(name: name, experiments: experiments)
       else
         nil
       end
@@ -31,7 +31,7 @@ def self.load_from_redis(name)
     def self.load_from_configuration(name)
       metrics = Split.configuration.metrics
       if metrics && metrics[name]
-        Split::Metric.new(:experiments => metrics[name], :name => name)
+        Split::Metric.new(experiments: metrics[name], name: name)
       else
         nil
       end
diff --git a/lib/split/persistence/redis_adapter.rb b/lib/split/persistence/redis_adapter.rb
index 40ed3fd2..480f38ae 100644
--- a/lib/split/persistence/redis_adapter.rb
+++ b/lib/split/persistence/redis_adapter.rb
@@ -3,7 +3,7 @@
 module Split
   module Persistence
     class RedisAdapter
-      DEFAULT_CONFIG = {:namespace => 'persistence'}.freeze
+      DEFAULT_CONFIG = {namespace: 'persistence'}.freeze
 
       attr_reader :redis_key
 
diff --git a/spec/alternative_spec.rb b/spec/alternative_spec.rb
index 5e6d3704..8ed16fa2 100644
--- a/spec/alternative_spec.rb
+++ b/spec/alternative_spec.rb
@@ -29,7 +29,7 @@
 
   describe 'weights' do
     it "should set the weights" do
-      experiment = Split::Experiment.new('basket_text', :alternatives => [{'Basket' => 0.6}, {"Cart" => 0.4}])
+      experiment = Split::Experiment.new('basket_text', alternatives: [{'Basket' => 0.6}, {"Cart" => 0.4}])
       first = experiment.alternatives[0]
       expect(first.name).to eq('Basket')
       expect(first.weight).to eq(0.6)
@@ -41,11 +41,11 @@
 
     it "accepts probability on alternatives" do
       Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => [
-            { :name => "control_opt", :percent => 67 },
-            { :name => "second_opt", :percent => 10 },
-            { :name => "third_opt", :percent => 23 },
+        my_experiment: {
+          alternatives: [
+            { name: "control_opt", percent: 67 },
+            { name: "second_opt", percent: 10 },
+            { name: "third_opt", percent: 23 },
           ]
         }
       }
@@ -61,11 +61,11 @@
 
     it "accepts probability on some alternatives" do
       Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => [
-            { :name => "control_opt", :percent => 34 },
+        my_experiment: {
+          alternatives: [
+            { name: "control_opt", percent: 34 },
             "second_opt",
-            { :name => "third_opt", :percent => 23 },
+            { name: "third_opt", percent: 23 },
             "fourth_opt",
           ],
         }
@@ -87,11 +87,11 @@
     #
     it "allows name param without probability" do
       Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => [
-            { :name => "control_opt" },
+        my_experiment: {
+          alternatives: [
+            { name: "control_opt" },
             "second_opt",
-            { :name => "third_opt", :percent => 64 },
+            { name: "third_opt", percent: 64 },
           ],
         }
       }
diff --git a/spec/combined_experiments_helper_spec.rb b/spec/combined_experiments_helper_spec.rb
index 129eb258..a5561fb5 100644
--- a/spec/combined_experiments_helper_spec.rb
+++ b/spec/combined_experiments_helper_spec.rb
@@ -12,10 +12,10 @@
 
     before do
       Split.configuration.experiments = {
-        :combined_exp_1 => {
-          :alternatives => [ {"control"=> 0.5}, {"test-alt"=> 0.5} ],
-          :metric => :my_metric,
-          :combined_experiments => combined_experiments
+        combined_exp_1: {
+          alternatives: [ {"control"=> 0.5}, {"test-alt"=> 0.5} ],
+          metric: :my_metric,
+          combined_experiments: combined_experiments
         }
       }
       Split.configuration.enabled = config_enabled
diff --git a/spec/configuration_spec.rb b/spec/configuration_spec.rb
index c065229c..6299e949 100644
--- a/spec/configuration_spec.rb
+++ b/spec/configuration_spec.rb
@@ -58,17 +58,15 @@
   end
 
   it "should load a metric" do
-    @config.experiments = {:my_experiment=>
-        {:alternatives=>["control_opt", "other_opt"], :metric=>:my_metric}}
+    @config.experiments = { my_experiment: {alternatives: ["control_opt", "other_opt"], metric: :my_metric } }
 
     expect(@config.metrics).not_to be_nil
     expect(@config.metrics.keys).to eq([:my_metric])
   end
 
   it "should allow loading of experiment using experment_for" do
-    @config.experiments = {:my_experiment=>
-        {:alternatives=>["control_opt", "other_opt"], :metric=>:my_metric}}
-    expect(@config.experiment_for(:my_experiment)).to eq({:alternatives=>["control_opt", ["other_opt"]]})
+    @config.experiments = { my_experiment: { alternatives: ["control_opt", "other_opt"], metric: :my_metric } }
+    expect(@config.experiment_for(:my_experiment)).to eq({ alternatives: ["control_opt", ["other_opt"]] })
   end
 
   context "when experiments are defined via YAML" do
@@ -87,7 +85,7 @@
         end
 
         it 'should normalize experiments' do
-          expect(@config.normalized_experiments).to eq({:my_experiment=>{:resettable=>false,:alternatives=>["Control Opt", ["Alt One", "Alt Two"]]}})
+          expect(@config.normalized_experiments).to eq({ my_experiment: { resettable: false, alternatives: ["Control Opt", ["Alt One", "Alt Two"]] } })
         end
       end
 
@@ -143,8 +141,8 @@
         end
 
         it "should normalize experiments" do
-          expect(@config.normalized_experiments).to eq({:my_experiment=>{:resettable=>false,:alternatives=>[{"Control Opt"=>0.67},
-            [{"Alt One"=>0.1}, {"Alt Two"=>0.23}]]}, :another_experiment=>{:alternatives=>["a", ["b"]]}})
+          expect(@config.normalized_experiments).to eq({ my_experiment: { resettable: false, alternatives: [{"Control Opt"=>0.67},
+            [{"Alt One"=>0.1}, {"Alt Two"=>0.23}]]}, another_experiment: { alternatives: ["a", ["b"]]}})
         end
 
         it "should recognize metrics" do
@@ -171,7 +169,7 @@
         end
 
         it "should normalize experiments" do
-          expect(@config.normalized_experiments).to eq({:my_experiment=>{:resettable=>false,:alternatives=>["Control Opt", ["Alt One", "Alt Two"]]}})
+          expect(@config.normalized_experiments).to eq({my_experiment: { resettable: false, alternatives: ["Control Opt", ["Alt One", "Alt Two"]]}})
         end
       end
 
@@ -200,16 +198,16 @@
 
   it "should normalize experiments" do
     @config.experiments = {
-      :my_experiment => {
-        :alternatives => [
-          { :name => "control_opt", :percent => 67 },
-          { :name => "second_opt", :percent => 10 },
-          { :name => "third_opt", :percent => 23 },
+      my_experiment: {
+        alternatives: [
+          { name: "control_opt", percent: 67 },
+          { name: "second_opt", percent: 10 },
+          { name: "third_opt", percent: 23 },
         ],
       }
     }
 
-    expect(@config.normalized_experiments).to eq({:my_experiment=>{:alternatives=>[{"control_opt"=>0.67}, [{"second_opt"=>0.1}, {"third_opt"=>0.23}]]}})
+    expect(@config.normalized_experiments).to eq({ my_experiment: { alternatives: [{"control_opt"=>0.67}, [{"second_opt"=>0.1}, {"third_opt"=>0.23}]]}})
   end
 
   context "redis configuration" do
diff --git a/spec/dashboard_spec.rb b/spec/dashboard_spec.rb
index 314bbf5b..3bf0cfa0 100644
--- a/spec/dashboard_spec.rb
+++ b/spec/dashboard_spec.rb
@@ -226,7 +226,7 @@ def link(color)
 
   it "should mark an alternative as the winner" do
     expect(experiment.winner).to be_nil
-    post "/experiment?experiment=#{experiment.name}", :alternative => 'red'
+    post "/experiment?experiment=#{experiment.name}", alternative: 'red'
 
     expect(last_response).to be_redirect
     expect(experiment.winner.name).to eq('red')
diff --git a/spec/experiment_spec.rb b/spec/experiment_spec.rb
index ecaeeab0..7d7f27f9 100644
--- a/spec/experiment_spec.rb
+++ b/spec/experiment_spec.rb
@@ -4,7 +4,7 @@
 
 describe Split::Experiment do
   def new_experiment(goals=[])
-    Split::Experiment.new('link_color', :alternatives => ['blue', 'red', 'green'], :goals => goals)
+    Split::Experiment.new('link_color', alternatives: ['blue', 'red', 'green'], goals: goals)
   end
 
   def alternative(color)
@@ -17,7 +17,7 @@ def alternative(color)
   let(:green) { alternative("green") }
 
   context "with an experiment" do
-    let(:experiment) { Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"]) }
+    let(:experiment) { Split::Experiment.new('basket_text', alternatives: ['Basket', "Cart"]) }
 
     it "should have a name" do
       expect(experiment.name).to eq('basket_text')
@@ -110,12 +110,12 @@ def alternative(color)
 
   describe 'initialization' do
     it "should set the algorithm when passed as an option to the initializer" do
-       experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :algorithm =>  Split::Algorithms::Whiplash)
+       experiment = Split::Experiment.new('basket_text', alternatives: ['Basket', "Cart"], algorithm: Split::Algorithms::Whiplash)
        expect(experiment.algorithm).to eq(Split::Algorithms::Whiplash)
     end
 
     it "should be possible to make an experiment not resettable" do
-      experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :resettable => false)
+      experiment = Split::Experiment.new('basket_text', alternatives: ['Basket', "Cart"], resettable: false)
       expect(experiment.resettable).to be_falsey
     end
 
@@ -124,7 +124,7 @@ def alternative(color)
       let(:experiments) do
         {
           experiment_name => {
-            :alternatives => ['Control Opt', 'Alt one']
+            alternatives: ['Control Opt', 'Alt one']
           }
         }
       end
@@ -140,7 +140,7 @@ def alternative(color)
   describe 'persistent configuration' do
 
     it "should persist resettable in redis" do
-      experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :resettable => false)
+      experiment = Split::Experiment.new('basket_text', alternatives: ['Basket', "Cart"], resettable: false)
       experiment.save
 
       e = Split::ExperimentCatalog.find('basket_text')
@@ -150,7 +150,7 @@ def alternative(color)
     end
 
     describe '#metadata' do
-      let(:experiment) { Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :algorithm => Split::Algorithms::Whiplash, :metadata => meta) }
+      let(:experiment) { Split::Experiment.new('basket_text', alternatives: ['Basket', "Cart"], algorithm: Split::Algorithms::Whiplash, metadata: meta) }
       let(:meta) { { a: 'b' }}
 
       before do
@@ -185,7 +185,7 @@ def alternative(color)
     end
 
     it "should persist algorithm in redis" do
-      experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :algorithm => Split::Algorithms::Whiplash)
+      experiment = Split::Experiment.new('basket_text', alternatives: ['Basket', "Cart"], algorithm: Split::Algorithms::Whiplash)
       experiment.save
 
       e = Split::ExperimentCatalog.find('basket_text')
@@ -194,7 +194,7 @@ def alternative(color)
     end
 
     it "should persist a new experiment in redis, that does not exist in the configuration file" do
-      experiment = Split::Experiment.new('foobar', :alternatives => ['tra', 'la'], :algorithm => Split::Algorithms::Whiplash)
+      experiment = Split::Experiment.new('foobar', alternatives: ['tra', 'la'], algorithm: Split::Algorithms::Whiplash)
       experiment.save
 
       e = Split::ExperimentCatalog.find('foobar')
@@ -205,7 +205,7 @@ def alternative(color)
 
   describe 'deleting' do
     it 'should delete itself' do
-      experiment = Split::Experiment.new('basket_text', :alternatives => [ 'Basket', "Cart"])
+      experiment = Split::Experiment.new('basket_text', alternatives: [ 'Basket', "Cart"])
       experiment.save
 
       experiment.delete
@@ -562,7 +562,7 @@ def same_but_different_alternative
       expect(experiment.alternatives[0].p_winner).to be_within(0.04).of(0.50)
     end
 
-    it "should calculate the probability of being the winning alternative separately for each goal", :skip => true do
+    it "should calculate the probability of being the winning alternative separately for each goal", skip: true do
       experiment = Split::ExperimentCatalog.find_or_create({'link_color3' => ["purchase", "refund"]}, 'blue', 'red', 'green')
       goal1 = experiment.goals[0]
       goal2 = experiment.goals[1]
diff --git a/spec/helper_spec.rb b/spec/helper_spec.rb
index 6decfe71..ad9c87ba 100755
--- a/spec/helper_spec.rb
+++ b/spec/helper_spec.rb
@@ -37,10 +37,10 @@
 
     it "raises an appropriate error when processing combined expirements" do
       Split.configuration.experiments = {
-        :combined_exp_1 => {
-          :alternatives => [  { name: "control", percent: 50 },  { name: "test-alt", percent: 50 } ],
-          :metric => :my_metric,
-          :combined_experiments => [:combined_exp_1_sub_1]
+        combined_exp_1: {
+          alternatives: [  { name: "control", percent: 50 },  { name: "test-alt", percent: 50 } ],
+          metric: :my_metric,
+          combined_experiments: [:combined_exp_1_sub_1]
         }
       }
       Split::ExperimentCatalog.find_or_create('combined_exp_1')
@@ -280,10 +280,10 @@
     context 'is defined' do
       before do
         Split.configuration.experiments = {
-          :my_experiment => {
-            :alternatives => ["one", "two"],
-            :resettable => false,
-            :metadata => { 'one' => 'Meta1', 'two' => 'Meta2' }
+          my_experiment: {
+            alternatives: ["one", "two"],
+            resettable: false,
+            metadata: { 'one' => 'Meta1', 'two' => 'Meta2' }
           }
         }
       end
@@ -311,10 +311,10 @@
     context 'is not defined' do
       before do
         Split.configuration.experiments = {
-          :my_experiment => {
-            :alternatives => ["one", "two"],
-            :resettable => false,
-            :metadata => nil
+          my_experiment: {
+            alternatives: ["one", "two"],
+            resettable: false,
+            metadata: nil
           }
         }
       end
@@ -354,13 +354,13 @@
       end
 
       it "should set experiment's finished key if reset is false" do
-        ab_finished(@experiment_name, {:reset => false})
+        ab_finished(@experiment_name, {reset: false})
         expect(ab_user[@experiment.key]).to eq(@alternative_name)
         expect(ab_user[@experiment.finished_key]).to eq(true)
       end
 
       it 'should not increment the counter if reset is false and the experiment has been already finished' do
-        2.times { ab_finished(@experiment_name, {:reset => false}) }
+        2.times { ab_finished(@experiment_name, {reset: false}) }
         new_completion_count = Split::Alternative.new(@alternative_name, @experiment_name).completed_count
         expect(new_completion_count).to eq(@previous_completion_count + 1)
       end
@@ -383,7 +383,7 @@
 
       it "should not clear out the users session if reset is false" do
         expect(ab_user[@experiment.key]).to eq(@alternative_name)
-        ab_finished(@experiment_name, {:reset => false})
+        ab_finished(@experiment_name, {reset: false})
         expect(ab_user[@experiment.key]).to eq(@alternative_name)
         expect(ab_user[@experiment.finished_key]).to eq(true)
       end
@@ -465,9 +465,9 @@
   context "finished with config" do
     it "passes reset option" do
       Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => ["one", "two"],
-          :resettable => false,
+        my_experiment: {
+          alternatives: ["one", "two"],
+          resettable: false,
         }
       }
       alternative = ab_test(:my_experiment)
@@ -499,8 +499,8 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "completes the test" do
       Split.configuration.experiments[:my_experiment] = {
-        :alternatives => [ "control_opt", "other_opt" ],
-        :metric => :my_metric
+        alternatives: [ "control_opt", "other_opt" ],
+        metric: :my_metric
       }
       should_finish_experiment :my_experiment
       ab_finished :my_metric
@@ -508,17 +508,17 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "completes all relevant tests" do
       Split.configuration.experiments = {
-        :exp_1 => {
-          :alternatives => [ "1-1", "1-2" ],
-          :metric => :my_metric
+        exp_1: {
+          alternatives: [ "1-1", "1-2" ],
+          metric: :my_metric
         },
-        :exp_2 => {
-          :alternatives => [ "2-1", "2-2" ],
-          :metric => :another_metric
+        exp_2: {
+          alternatives: [ "2-1", "2-2" ],
+          metric: :another_metric
         },
-        :exp_3 => {
-          :alternatives => [ "3-1", "3-2" ],
-          :metric => :my_metric
+        exp_3: {
+          alternatives: [ "3-1", "3-2" ],
+          metric: :my_metric
         },
       }
       should_finish_experiment :exp_1
@@ -529,10 +529,10 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "passes reset option" do
       Split.configuration.experiments = {
-        :my_exp => {
-          :alternatives => ["one", "two"],
-          :metric => :my_metric,
-          :resettable => false,
+        my_exp: {
+          alternatives: ["one", "two"],
+          metric: :my_metric,
+          resettable: false,
         }
       }
       alternative_name = ab_test(:my_exp)
@@ -545,15 +545,15 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "passes through options" do
       Split.configuration.experiments = {
-        :my_exp => {
-          :alternatives => ["one", "two"],
-          :metric => :my_metric,
+        my_exp: {
+          alternatives: ["one", "two"],
+          metric: :my_metric,
         }
       }
       alternative_name = ab_test(:my_exp)
       exp = Split::ExperimentCatalog.find :my_exp
 
-      ab_finished :my_metric, :reset => false
+      ab_finished :my_metric, reset: false
       expect(ab_user[exp.key]).to eq(alternative_name)
       expect(ab_user[exp.finished_key]).to be_truthy
     end
@@ -583,7 +583,7 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it 'should show a finished test' do
       alternative = ab_test('def', '4', '5', '6')
-      ab_finished('def', {:reset => false})
+      ab_finished('def', {reset: false})
       expect(active_experiments.count).to eq 1
       expect(active_experiments.first[0]).to eq "def"
       expect(active_experiments.first[1]).to eq alternative
@@ -635,7 +635,7 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
   describe 'when user is a robot' do
     before(:each) do
-      @request = OpenStruct.new(:user_agent => 'Googlebot/2.1 (+http://www.google.com/bot.html)')
+      @request = OpenStruct.new(user_agent: 'Googlebot/2.1 (+http://www.google.com/bot.html)')
     end
 
     describe 'ab_test' do
@@ -735,7 +735,7 @@ def should_finish_experiment(experiment_name, should_finish=true)
   describe 'when ip address is ignored' do
     context "individually" do
       before(:each) do
-        @request = OpenStruct.new(:ip => '81.19.48.130')
+        @request = OpenStruct.new(ip: '81.19.48.130')
         Split.configure do |c|
           c.ignore_ip_addresses << '81.19.48.130'
         end
@@ -746,7 +746,7 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     context "for a range" do
       before(:each) do
-        @request = OpenStruct.new(:ip => '81.19.48.129')
+        @request = OpenStruct.new(ip: '81.19.48.129')
         Split.configure do |c|
           c.ignore_ip_addresses << /81\.19\.48\.[0-9]+/
         end
@@ -757,7 +757,7 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     context "using both a range and a specific value" do
       before(:each) do
-        @request = OpenStruct.new(:ip => '81.19.48.128')
+        @request = OpenStruct.new(ip: '81.19.48.128')
         Split.configure do |c|
           c.ignore_ip_addresses << '81.19.48.130'
           c.ignore_ip_addresses << /81\.19\.48\.[0-9]+/
@@ -769,7 +769,7 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     context "when ignored other address" do
       before do
-        @request = OpenStruct.new(:ip => '1.1.1.1')
+        @request = OpenStruct.new(ip: '1.1.1.1')
         Split.configure do |c|
           c.ignore_ip_addresses << '81.19.48.130'
         end
@@ -959,7 +959,7 @@ def should_finish_experiment(experiment_name, should_finish=true)
         context 'and preloaded config given' do
           before do
             Split.configuration.experiments[:link_color] = {
-              :alternatives => [ "blue", "red" ],
+              alternatives: [ "blue", "red" ],
             }
           end
 
@@ -993,8 +993,8 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "pulls options from config file" do
       Split.configuration.experiments[:my_experiment] = {
-        :alternatives => [ "control_opt", "other_opt" ],
-        :goals => ["goal1", "goal2"]
+        alternatives: [ "control_opt", "other_opt" ],
+        goals: ["goal1", "goal2"]
       }
       ab_test :my_experiment
       expect(Split::Experiment.new(:my_experiment).alternatives.map(&:name)).to eq([ "control_opt", "other_opt" ])
@@ -1003,8 +1003,8 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "can be called multiple times" do
       Split.configuration.experiments[:my_experiment] = {
-        :alternatives => [ "control_opt", "other_opt" ],
-        :goals => ["goal1", "goal2"]
+        alternatives: [ "control_opt", "other_opt" ],
+        goals: ["goal1", "goal2"]
       }
       5.times { ab_test :my_experiment }
       experiment = Split::Experiment.new(:my_experiment)
@@ -1015,8 +1015,8 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "accepts multiple goals" do
       Split.configuration.experiments[:my_experiment] = {
-        :alternatives => [ "control_opt", "other_opt" ],
-        :goals => [ "goal1", "goal2", "goal3" ]
+        alternatives: [ "control_opt", "other_opt" ],
+        goals: [ "goal1", "goal2", "goal3" ]
       }
       ab_test :my_experiment
       experiment = Split::Experiment.new(:my_experiment)
@@ -1025,7 +1025,7 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "allow specifying goals to be optional" do
       Split.configuration.experiments[:my_experiment] = {
-        :alternatives => [ "control_opt", "other_opt" ]
+        alternatives: [ "control_opt", "other_opt" ]
       }
       experiment = Split::Experiment.new(:my_experiment)
       expect(experiment.goals).to eq([])
@@ -1033,7 +1033,7 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "accepts multiple alternatives" do
       Split.configuration.experiments[:my_experiment] = {
-        :alternatives => [ "control_opt", "second_opt", "third_opt" ],
+        alternatives: [ "control_opt", "second_opt", "third_opt" ],
       }
       ab_test :my_experiment
       experiment = Split::Experiment.new(:my_experiment)
@@ -1042,10 +1042,10 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "accepts probability on alternatives" do
       Split.configuration.experiments[:my_experiment] = {
-        :alternatives => [
-          { :name => "control_opt", :percent => 67 },
-          { :name => "second_opt", :percent => 10 },
-          { :name => "third_opt", :percent => 23 },
+        alternatives: [
+          { name: "control_opt", percent: 67 },
+          { name: "second_opt", percent: 10 },
+          { name: "third_opt", percent: 23 },
         ],
       }
       ab_test :my_experiment
@@ -1055,10 +1055,10 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "accepts probability on some alternatives" do
       Split.configuration.experiments[:my_experiment] = {
-        :alternatives => [
-          { :name => "control_opt", :percent => 34 },
+        alternatives: [
+          { name: "control_opt", percent: 34 },
           "second_opt",
-          { :name => "third_opt", :percent => 23 },
+          { name: "third_opt", percent: 23 },
           "fourth_opt",
         ],
       }
@@ -1071,10 +1071,10 @@ def should_finish_experiment(experiment_name, should_finish=true)
 
     it "allows name param without probability" do
       Split.configuration.experiments[:my_experiment] = {
-        :alternatives => [
-          { :name => "control_opt" },
+        alternatives: [
+          { name: "control_opt" },
           "second_opt",
-          { :name => "third_opt", :percent => 64 },
+          { name: "third_opt", percent: 64 },
         ],
       }
       ab_test :my_experiment
@@ -1085,7 +1085,7 @@ def should_finish_experiment(experiment_name, should_finish=true)
     end
 
     it "fails gracefully if config is missing experiment" do
-      Split.configuration.experiments = { :other_experiment => { :foo => "Bar" } }
+      Split.configuration.experiments = { other_experiment: { foo: "Bar" } }
       expect { ab_test :my_experiment }.to raise_error(Split::ExperimentNotFound)
     end
 
@@ -1094,7 +1094,7 @@ def should_finish_experiment(experiment_name, should_finish=true)
     end
 
     it "fails gracefully if config is missing alternatives" do
-      Split.configuration.experiments[:my_experiment] = { :foo => "Bar" }
+      Split.configuration.experiments[:my_experiment] = { foo: "Bar" }
       expect { ab_test :my_experiment }.to raise_error(NoMethodError)
     end
   end
diff --git a/spec/metric_spec.rb b/spec/metric_spec.rb
index 21bbc758..3dbc9b5f 100644
--- a/spec/metric_spec.rb
+++ b/spec/metric_spec.rb
@@ -13,7 +13,7 @@
       experiment1 = Split::ExperimentCatalog.find_or_create('color', 'red', 'blue')
       experiment2 = Split::ExperimentCatalog.find_or_create('size', 'big', 'small')
 
-      metric = Split::Metric.new(:name => 'purchase', :experiments => [experiment1, experiment2])
+      metric = Split::Metric.new(name: 'purchase', experiments: [experiment1, experiment2])
       metric.save
       expect(Split::Metric.possible_experiments('purchase')).to include(experiment1, experiment2)
     end
@@ -22,7 +22,7 @@
       experiment1 = Split::ExperimentCatalog.find_or_create('purchase', 'red', 'blue')
       experiment2 = Split::ExperimentCatalog.find_or_create('size', 'big', 'small')
 
-      metric = Split::Metric.new(:name => 'purchase', :experiments => [experiment2])
+      metric = Split::Metric.new(name: 'purchase', experiments: [experiment2])
       metric.save
       expect(Split::Metric.possible_experiments('purchase')).to include(experiment1, experiment2)
     end
diff --git a/spec/persistence/cookie_adapter_spec.rb b/spec/persistence/cookie_adapter_spec.rb
index e9758a47..0e8719b1 100644
--- a/spec/persistence/cookie_adapter_spec.rb
+++ b/spec/persistence/cookie_adapter_spec.rb
@@ -14,8 +14,8 @@
 
       it "handles invalid JSON" do
         context.request.cookies[:split] = {
-          :value => '{"foo":2,',
-          :expires => Time.now
+          value: '{"foo":2,',
+          expires: Time.now
         }
         expect(subject["my_key"]).to be_nil
         subject["my_key"] = "my_value"
diff --git a/spec/persistence/redis_adapter_spec.rb b/spec/persistence/redis_adapter_spec.rb
index c7321c86..d7e20213 100644
--- a/spec/persistence/redis_adapter_spec.rb
+++ b/spec/persistence/redis_adapter_spec.rb
@@ -3,7 +3,7 @@
 
 describe Split::Persistence::RedisAdapter do
 
-  let(:context) { double(:lookup => 'blah') }
+  let(:context) { double(lookup: 'blah') }
 
   subject { Split::Persistence::RedisAdapter.new(context) }
 
@@ -26,7 +26,7 @@
     end
 
     context 'config with lookup_by = proc { "block" }' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'block'}) }
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc{'block'}) }
 
       it 'should be "persistence:block"' do
         expect(subject.redis_key).to eq('persistence:block')
@@ -34,8 +34,8 @@
     end
 
     context 'config with lookup_by = proc { |context| context.test }' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'block'}) }
-      let(:context) { double(:test => 'block') }
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc{'block'}) }
+      let(:context) { double(test: 'block') }
 
       it 'should be "persistence:block"' do
         expect(subject.redis_key).to eq('persistence:block')
@@ -43,8 +43,8 @@
     end
 
     context 'config with lookup_by = "method_name"' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => 'method_name') }
-      let(:context) { double(:method_name => 'val') }
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: 'method_name') }
+      let(:context) { double(method_name: 'val') }
 
       it 'should be "persistence:bar"' do
         expect(subject.redis_key).to eq('persistence:val')
@@ -52,7 +52,7 @@
     end
 
     context 'config with namespace and lookup_by' do
-      before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'frag'}, :namespace => 'namer') }
+      before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc{'frag'}, namespace: 'namer') }
 
       it 'should be "namer"' do
         expect(subject.redis_key).to eq('namer:frag')
@@ -61,7 +61,7 @@
   end
 
   describe '#find' do
-    before { Split::Persistence::RedisAdapter.with_config(:lookup_by => proc{'frag'}, :namespace => 'a_namespace') }
+    before { Split::Persistence::RedisAdapter.with_config(lookup_by: proc{'frag'}, namespace: 'a_namespace') }
 
     it "should create and user from a given key" do
       adapter = Split::Persistence::RedisAdapter.find(2)
@@ -70,7 +70,7 @@
   end
 
   context 'functional tests' do
-    before { Split::Persistence::RedisAdapter.with_config(:lookup_by => 'lookup') }
+    before { Split::Persistence::RedisAdapter.with_config(lookup_by: 'lookup') }
 
     describe "#[] and #[]=" do
       it "should set and return the value for given key" do
diff --git a/spec/persistence/session_adapter_spec.rb b/spec/persistence/session_adapter_spec.rb
index 2d57d1ed..bda18969 100644
--- a/spec/persistence/session_adapter_spec.rb
+++ b/spec/persistence/session_adapter_spec.rb
@@ -3,7 +3,7 @@
 
 describe Split::Persistence::SessionAdapter do
 
-  let(:context) { double(:session => {}) }
+  let(:context) { double(session: {}) }
   subject { Split::Persistence::SessionAdapter.new(context) }
 
   describe "#[] and #[]=" do
diff --git a/spec/trial_spec.rb b/spec/trial_spec.rb
index c171944b..80bafe04 100644
--- a/spec/trial_spec.rb
+++ b/spec/trial_spec.rb
@@ -6,31 +6,31 @@
   let(:user) { mock_user }
   let(:alternatives) { ['basket', 'cart'] }
   let(:experiment) do
-    Split::Experiment.new('basket_text', :alternatives => alternatives).save
+    Split::Experiment.new('basket_text', alternatives: alternatives).save
   end
 
   it "should be initializeable" do
     experiment  = double('experiment')
-    alternative = double('alternative', :kind_of? => Split::Alternative)
-    trial = Split::Trial.new(:experiment => experiment, :alternative => alternative)
+    alternative = double('alternative', kind_of?: Split::Alternative)
+    trial = Split::Trial.new(experiment: experiment, alternative: alternative)
     expect(trial.experiment).to eq(experiment)
     expect(trial.alternative).to eq(alternative)
   end
 
   describe "alternative" do
     it "should use the alternative if specified" do
-      alternative = double('alternative', :kind_of? => Split::Alternative)
-      trial = Split::Trial.new(:experiment => double('experiment'),
-          :alternative => alternative, :user => user)
+      alternative = double('alternative', kind_of?: Split::Alternative)
+      trial = Split::Trial.new(experiment: double('experiment'),
+          alternative: alternative, user: user)
       expect(trial).not_to receive(:choose)
       expect(trial.alternative).to eq(alternative)
     end
 
     it "should load the alternative when the alternative name is set" do
-      experiment = Split::Experiment.new('basket_text', :alternatives => ['basket', 'cart'])
+      experiment = Split::Experiment.new('basket_text', alternatives: ['basket', 'cart'])
       experiment.save
 
-      trial = Split::Trial.new(:experiment => experiment, :alternative => 'basket')
+      trial = Split::Trial.new(experiment: experiment, alternative: 'basket')
       expect(trial.alternative.name).to eq('basket')
     end
   end
@@ -38,17 +38,17 @@
   describe "metadata" do
     let(:metadata) { Hash[alternatives.map { |k| [k, "Metadata for #{k}"] }] }
     let(:experiment) do
-      Split::Experiment.new('basket_text', :alternatives => alternatives, :metadata => metadata).save
+      Split::Experiment.new('basket_text', alternatives: alternatives, metadata: metadata).save
     end
 
     it 'has metadata on each trial' do
-      trial = Split::Trial.new(:experiment => experiment, :user => user, :metadata => metadata['cart'],
-                               :override => 'cart')
+      trial = Split::Trial.new(experiment: experiment, user: user, metadata: metadata['cart'],
+                               override: 'cart')
       expect(trial.metadata).to eq(metadata['cart'])
     end
 
     it 'has metadata on each trial from the experiment' do
-      trial = Split::Trial.new(:experiment => experiment, :user => user)
+      trial = Split::Trial.new(experiment: experiment, user: user)
       trial.choose!
       expect(trial.metadata).to eq(metadata[trial.alternative.name])
       expect(trial.metadata).to match(/#{trial.alternative.name}/)
@@ -58,7 +58,7 @@
   describe "#choose!" do
     let(:context) { double(on_trial_callback: 'test callback') }
     let(:trial) do
-      Split::Trial.new(:user => user, :experiment => experiment)
+      Split::Trial.new(user: user, experiment: experiment)
     end
 
     shared_examples_for 'a trial with callbacks' do
@@ -90,7 +90,7 @@ def expect_alternative(trial, alternative_name)
     context "when override is present" do
       let(:override) { 'cart' }
       let(:trial) do
-        Split::Trial.new(:user => user, :experiment => experiment, :override => override)
+        Split::Trial.new(user: user, experiment: experiment, override: override)
       end
 
       it_behaves_like 'a trial with callbacks'
@@ -111,7 +111,7 @@ def expect_alternative(trial, alternative_name)
 
     context "when disabled option is true" do
       let(:trial) do
-        Split::Trial.new(:user => user, :experiment => experiment, :disabled => true)
+        Split::Trial.new(user: user, experiment: experiment, disabled: true)
       end
 
       it "picks the control", :aggregate_failures do
@@ -141,7 +141,7 @@ def expect_alternative(trial, alternative_name)
 
     context "when experiment has winner" do
       let(:trial) do
-        Split::Trial.new(:user => user, :experiment => experiment)
+        Split::Trial.new(user: user, experiment: experiment)
       end
 
       it_behaves_like 'a trial with callbacks'
@@ -156,7 +156,7 @@ def expect_alternative(trial, alternative_name)
 
     context "when exclude is true" do
       let(:trial) do
-        Split::Trial.new(:user => user, :experiment => experiment, :exclude => true)
+        Split::Trial.new(user: user, experiment: experiment, exclude: true)
       end
 
       it_behaves_like 'a trial with callbacks'
@@ -230,7 +230,7 @@ def expect_alternative(trial, alternative_name)
 
   describe "#complete!" do
     context 'when there are no goals' do
-      let(:trial) { Split::Trial.new(:user => user, :experiment => experiment) }
+      let(:trial) { Split::Trial.new(user: user, experiment: experiment) }
       it 'should complete the trial' do
         trial.choose!
         old_completed_count = trial.alternative.completed_count
@@ -241,7 +241,7 @@ def expect_alternative(trial, alternative_name)
 
     context "when there are many goals" do
       let(:goals) { [ "goal1", "goal2" ] }
-      let(:trial) { Split::Trial.new(:user => user, :experiment => experiment, :goals => goals) }
+      let(:trial) { Split::Trial.new(user: user, experiment: experiment, goals: goals) }
 
       it "increments the completed count corresponding to the goals" do
         trial.choose!
@@ -253,7 +253,7 @@ def expect_alternative(trial, alternative_name)
 
     context "when there is 1 goal of type string" do
       let(:goal) { "goal" }
-      let(:trial) { Split::Trial.new(:user => user, :experiment => experiment, :goals => goal) }
+      let(:trial) { Split::Trial.new(user: user, experiment: experiment, goals: goal) }
       it "increments the completed count corresponding to the goal" do
         trial.choose!
         old_completed_count = trial.alternative.completed_count(goal)
@@ -268,7 +268,7 @@ def expect_alternative(trial, alternative_name)
 
     context "when override is present" do
       it "stores when store_override is true" do
-        trial = Split::Trial.new(:user => user, :experiment => experiment, :override => 'basket')
+        trial = Split::Trial.new(user: user, experiment: experiment, override: 'basket')
 
         Split.configuration.store_override = true
         expect(user).to receive("[]=")
@@ -277,7 +277,7 @@ def expect_alternative(trial, alternative_name)
       end
 
       it "does not store when store_override is false" do
-        trial = Split::Trial.new(:user => user, :experiment => experiment, :override => 'basket')
+        trial = Split::Trial.new(user: user, experiment: experiment, override: 'basket')
 
         expect(user).to_not receive("[]=")
         trial.choose!
@@ -286,7 +286,7 @@ def expect_alternative(trial, alternative_name)
 
     context "when disabled is present" do
       it "stores when store_override is true" do
-        trial = Split::Trial.new(:user => user, :experiment => experiment, :disabled => true)
+        trial = Split::Trial.new(user: user, experiment: experiment, disabled: true)
 
         Split.configuration.store_override = true
         expect(user).to receive("[]=")
@@ -294,7 +294,7 @@ def expect_alternative(trial, alternative_name)
       end
 
       it "does not store when store_override is false" do
-        trial = Split::Trial.new(:user => user, :experiment => experiment, :disabled => true)
+        trial = Split::Trial.new(user: user, experiment: experiment, disabled: true)
 
         expect(user).to_not receive("[]=")
         trial.choose!
@@ -303,7 +303,7 @@ def expect_alternative(trial, alternative_name)
 
     context "when exclude is present" do
       it "does not store" do
-        trial = Split::Trial.new(:user => user, :experiment => experiment, :exclude => true)
+        trial = Split::Trial.new(user: user, experiment: experiment, exclude: true)
 
         expect(user).to_not receive("[]=")
         trial.choose!
@@ -313,7 +313,7 @@ def expect_alternative(trial, alternative_name)
     context 'when experiment has winner' do
       let(:trial) do
         experiment.winner = 'cart'
-        Split::Trial.new(:user => user, :experiment => experiment)
+        Split::Trial.new(user: user, experiment: experiment)
       end
 
       it 'does not store' do
diff --git a/spec/user_spec.rb b/spec/user_spec.rb
index 0291e593..62e6ed0a 100644
--- a/spec/user_spec.rb
+++ b/spec/user_spec.rb
@@ -5,7 +5,7 @@
 
 describe Split::User do
   let(:user_keys) { { 'link_color' => 'blue' } }
-  let(:context) { double(:session => { split:  user_keys }) }
+  let(:context) { double(session: { split:  user_keys }) }
   let(:experiment) { Split::Experiment.new('link_color') }
 
   before(:each) do