vanity 3.1.0 → 4.0.0

data/lib/vanity/adapters/active_record_adapter.rb

@@ -27,7 +27,7 @@ module Vanity
               send :"find_or_create_by_#{method}", value
             end
           rescue ActiveRecord::RecordNotUnique
-            if retried
+            if retried # rubocop:todo Style/GuardClause
               raise
             else
               retried = true
@@ -71,7 +71,7 @@ module Vanity
       # Experiment model
       class VanityExperiment < VanityRecord
         self.table_name = :vanity_experiments
-        has_many :vanity_conversions, :dependent => :destroy
+        has_many :vanity_conversions, dependent: :destroy
         attr_accessible :experiment_id if needs_attr_accessible?
 
         # Finds or creates the experiment
@@ -104,14 +104,14 @@ module Vanity
         def self.retrieve(experiment, identity, create = true, update_with = nil)
           retried = false
           begin
-            if record = VanityParticipant.where(:experiment_id => experiment.to_s, :identity => identity.to_s).first
+            if record = VanityParticipant.where(experiment_id: experiment.to_s, identity: identity.to_s).first # rubocop:todo Lint/AssignmentInCondition
               record.update(update_with) if update_with
             elsif create
-              record = VanityParticipant.create({ :experiment_id => experiment.to_s, :identity => identity.to_s }.merge(update_with || {}))
+              record = VanityParticipant.create({ experiment_id: experiment.to_s, identity: identity.to_s }.merge(update_with || {}))
             end
             record
           rescue ActiveRecord::RecordNotUnique => e
-            if retried
+            if retried # rubocop:todo Style/GuardClause
               raise e
             else
               retried = true
@@ -121,9 +121,11 @@ module Vanity
         end
       end
 
-      def initialize(options)
-        @options = options.inject({}) { |h,kv| h[kv.first.to_s] = kv.last ; h }
-        if @options["active_record_adapter"] && (@options["active_record_adapter"] != "default")
+      def initialize(options) # rubocop:todo Lint/MissingSuper
+        @options = options.each_with_object({}) do |kv, h|
+          h[kv.first.to_s] = kv.last
+        end
+        if @options["active_record_adapter"] && (@options["active_record_adapter"] != "default") # rubocop:todo Style/GuardClause
           @options["adapter"] = @options["active_record_adapter"]
           VanityRecord.establish_connection(@options)
         end
@@ -147,7 +149,6 @@ module Vanity
         end
       end
 
-
       # -- Metrics --
 
       def get_metric_last_update_at(metric)
@@ -155,11 +156,11 @@ module Vanity
         record && record.updated_at
       end
 
-      def metric_track(metric, timestamp, identity, values)
+      def metric_track(metric, timestamp, _identity, values)
         record = VanityMetric.retrieve(metric)
 
         values.each_with_index do |value, index|
-          record.vanity_metric_values.create(:date => timestamp.to_date.to_s, :index => index, :value => value)
+          record.vanity_metric_values.create(date: timestamp.to_date.to_s, index: index, value: value)
         end
 
         record.touch_with_grace_period
@@ -171,14 +172,14 @@ module Vanity
         record = VanityMetric.retrieve(metric)
         dates = (from.to_date..to.to_date).map(&:to_s)
         conditions = [connection.quote_column_name('date') + ' BETWEEN ? AND ?', from.to_date, to.to_date]
-        order = "#{connection.quote_column_name('date')}"
+        order = connection.quote_column_name('date').to_s # rubocop:todo Lint/UselessAssignment
         select = "sum(#{connection.quote_column_name('value')}) AS value, #{connection.quote_column_name('date')}"
-        group_by = "#{connection.quote_column_name('date')}"
+        group_by = connection.quote_column_name('date').to_s
 
         values = record.vanity_metric_values.select(select).where(conditions).group(group_by)
 
         dates.map do |date|
-          value = values.detect{|v| v.date == date }
+          value = values.detect { |v| v.date == date }
           [(value && value.value) || 0]
         end
       end
@@ -188,7 +189,6 @@ module Vanity
         record && record.destroy
       end
 
-
       # -- Experiments --
 
       def experiment_persisted?(experiment)
@@ -198,7 +198,7 @@ module Vanity
       # Store when experiment was created (do not write over existing value).
       def set_experiment_created_at(experiment, time)
         record = VanityExperiment.find_by_experiment_id(experiment.to_s) ||
-                VanityExperiment.new(:experiment_id => experiment.to_s)
+                 VanityExperiment.new(experiment_id: experiment.to_s)
         record.created_at ||= time
         record.save
       end
@@ -218,7 +218,7 @@ module Vanity
       end
 
       # Returns true if experiment completed.
-      def is_experiment_completed?(experiment)
+      def is_experiment_completed?(experiment) # rubocop:todo Naming/PredicateName
         !!VanityExperiment.retrieve(experiment).completed_at
       end
 
@@ -226,7 +226,7 @@ module Vanity
         VanityExperiment.retrieve(experiment).update_attribute(:enabled, enabled)
       end
 
-      def is_experiment_enabled?(experiment)
+      def is_experiment_enabled?(experiment) # rubocop:todo Naming/PredicateName
         record = VanityExperiment.retrieve(experiment)
         if Vanity.configuration.experiments_start_enabled
           record.enabled != false
@@ -240,21 +240,21 @@ module Vanity
       # :conversions.
       def ab_counts(experiment, alternative)
         record = VanityExperiment.retrieve(experiment)
-        participants = VanityParticipant.where(:experiment_id => experiment.to_s, :seen => alternative).count
-        converted = VanityParticipant.where(:experiment_id => experiment.to_s, :converted => alternative).count
-        conversions = record.vanity_conversions.where(:alternative => alternative).sum(:conversions)
+        participants = VanityParticipant.where(experiment_id: experiment.to_s, seen: alternative).count
+        converted = VanityParticipant.where(experiment_id: experiment.to_s, converted: alternative).count
+        conversions = record.vanity_conversions.where(alternative: alternative).sum(:conversions)
 
         {
-          :participants => participants,
-          :converted => converted,
-          :conversions => conversions
+          participants: participants,
+          converted: converted,
+          conversions: conversions,
         }
       end
 
       # Pick particular alternative (by index) to show to this particular
       # participant (by identity).
       def ab_show(experiment, identity, alternative)
-        VanityParticipant.retrieve(experiment, identity, true, :shown => alternative)
+        VanityParticipant.retrieve(experiment, identity, true, shown: alternative)
       end
 
       # Indicates which alternative to show to this participant. See #ab_show.
@@ -266,12 +266,12 @@ module Vanity
       # Cancels previously set association between identity and alternative. See
       # #ab_show.
       def ab_not_showing(experiment, identity)
-        VanityParticipant.retrieve(experiment, identity, true, :shown => nil)
+        VanityParticipant.retrieve(experiment, identity, true, shown: nil)
       end
 
       # Records a participant in this experiment for the given alternative.
       def ab_add_participant(experiment, alternative, identity)
-        VanityParticipant.retrieve(experiment, identity, true, :seen => alternative)
+        VanityParticipant.retrieve(experiment, identity, true, seen: alternative)
       end
 
       # Determines if a participant already has seen this alternative in this experiment.
@@ -294,8 +294,8 @@ module Vanity
       # implicit is false (default), only add conversion if participant
       # previously recorded as participating in this experiment.
       def ab_add_conversion(experiment, alternative, identity, count = 1, implicit = false)
-        participant = VanityParticipant.retrieve(experiment, identity, false)
-        VanityParticipant.retrieve(experiment, identity, implicit, :converted => alternative, :seen => alternative)
+        participant = VanityParticipant.retrieve(experiment, identity, false) # rubocop:todo Lint/UselessAssignment
+        VanityParticipant.retrieve(experiment, identity, implicit, converted: alternative, seen: alternative)
         VanityExperiment.retrieve(experiment).increment_conversion(alternative, count)
       end
 
@@ -312,7 +312,7 @@ module Vanity
 
       # Deletes all information about this experiment.
       def destroy_experiment(experiment)
-        VanityParticipant.where(:experiment_id => experiment.to_s).delete_all
+        VanityParticipant.where(experiment_id: experiment.to_s).delete_all
         record = VanityExperiment.find_by_experiment_id(experiment.to_s)
         record && record.destroy
       end

data/lib/vanity/adapters/mock_adapter.rb

@@ -14,9 +14,9 @@ module Vanity
     #
     # @since 1.4.0
     class MockAdapter < AbstractAdapter
-      def initialize(options)
-        @metrics = @@metrics ||= {}
-        @experiments = @@experiments ||= {}
+      def initialize(_options) # rubocop:todo Lint/MissingSuper
+        @metrics = @@metrics ||= {} # rubocop:todo Style/ClassVars
+        @experiments = @@experiments ||= {} # rubocop:todo Style/ClassVars
       end
 
       def active?
@@ -42,18 +42,17 @@ module Vanity
         @experiments.clear
       end
 
-
       # -- Metrics --
 
       def get_metric_last_update_at(metric)
         @metrics[metric] && @metrics[metric][:last_update_at]
       end
 
-      def metric_track(metric, timestamp, identity, values)
+      def metric_track(metric, timestamp, _identity, values)
         @metrics[metric] ||= {}
         current = @metrics[metric][timestamp.to_date] ||= []
-        values.each_with_index do |v,i|
-          current[i] = (current[i] || 0) + v || 0
+        values.each_with_index do |v, i|
+          current[i] = ((current[i] || 0) + v) || 0
         end
         @metrics[metric][:last_update_at] = Time.now
       end
@@ -67,7 +66,6 @@ module Vanity
         @metrics.delete metric
       end
 
-
       # -- Experiments --
 
       def experiment_persisted?(experiment)
@@ -92,7 +90,7 @@ module Vanity
         @experiments[experiment] && @experiments[experiment][:completed_at]
       end
 
-      def is_experiment_completed?(experiment)
+      def is_experiment_completed?(experiment) # rubocop:todo Naming/PredicateName
         @experiments[experiment] && @experiments[experiment][:completed_at]
       end
 
@@ -101,10 +99,10 @@ module Vanity
         @experiments[experiment][:enabled] = enabled
       end
 
-      def is_experiment_enabled?(experiment)
+      def is_experiment_enabled?(experiment) # rubocop:todo Naming/PredicateName
         record = @experiments[experiment]
         if Vanity.configuration.experiments_start_enabled
-          record == nil || record[:enabled] != false
+          record.nil? || record[:enabled] != false
         else
           record && record[:enabled] == true
         end
@@ -112,9 +110,9 @@ module Vanity
 
       def ab_counts(experiment, alternative)
         alt = alternative(experiment, alternative)
-        { :participants => alt[:participants] ? alt[:participants].size : 0,
-          :converted    => alt[:converted] ? alt[:converted].size : 0,
-          :conversions  => alt[:conversions] || 0 }
+        { participants: alt[:participants] ? alt[:participants].size : 0,
+          converted: alt[:converted] ? alt[:converted].size : 0,
+          conversions: alt[:conversions] || 0 }
       end
 
       def ab_show(experiment, identity, alternative)
@@ -139,9 +137,7 @@ module Vanity
 
       def ab_seen(experiment, identity, alternative_or_id)
         with_ab_seen_deprecation(experiment, identity, alternative_or_id) do |expt, ident, alt_id|
-          if ab_assigned(expt, ident) == alt_id
-            alt_id
-          end
+          alt_id if ab_assigned(expt, ident) == alt_id
         end
       end
 
@@ -161,7 +157,7 @@ module Vanity
         if implicit
           alt[:participants] << identity
         else
-    participating = alt[:participants].include?(identity)
+          participating = alt[:participants].include?(identity)
         end
         alt[:converted] << identity if implicit || participating
         alt[:conversions] += count

data/lib/vanity/adapters/mongodb_adapter.rb

@@ -8,7 +8,7 @@ module Vanity
         require "mongo"
         MongodbAdapter.new(spec)
       end
-      alias :mongodb_connection :mongo_connection
+      alias mongodb_connection mongo_connection
     end
 
     # MongoDB adapter.
@@ -17,7 +17,7 @@ module Vanity
     class MongodbAdapter < AbstractAdapter
       attr_reader :mongo
 
-      def initialize(options)
+      def initialize(options) # rubocop:todo Lint/MissingSuper
         @options = options.clone
         @options[:database] ||= (@options[:path] && @options[:path].split("/")[1]) || "vanity"
         connect!
@@ -28,7 +28,13 @@ module Vanity
       end
 
       def disconnect!
-        @mongo.close rescue nil if @mongo
+        if @mongo
+          begin
+            @mongo.close
+          rescue StandardError
+            nil
+          end
+        end
         @metrics, @experiments = nil
         @mongo = nil
       end
@@ -49,9 +55,9 @@ module Vanity
         @participants = @mongo["vanity.participants"]
         @participants.create unless @mongo.database.collection_names.include?("vanity.participants")
         @participants.indexes.create_many(
-          { :key => { :experiment => 1, :identity => 1 }, :unique=>true },
-          { :key => { :experiment => 1, :seen => 1 } },
-          { :key => { :experiment => 1, :converted => 1 } }
+          { key: { experiment: 1, identity: 1 }, unique: true },
+          { key: { experiment: 1, seen: 1 } },
+          { key: { experiment: 1, converted: 1 } }
         )
 
         @mongo
@@ -59,7 +65,7 @@ module Vanity
 
       def to_s
         userinfo = @options.values_at(:username, :password).join(":") if @options[:username]
-        URI::Generic.build(:scheme=>"mongodb", :userinfo=>userinfo, :host=>(@mongo.host || @options[:host]), :port=>(@mongo.port || @options[:port]), :path=>"/#{@options[:database]}").to_s
+        URI::Generic.build(scheme: "mongodb", userinfo: userinfo, host: (@mongo.host || @options[:host]), port: (@mongo.port || @options[:port]), path: "/#{@options[:database]}").to_s
       end
 
       def flushdb
@@ -68,197 +74,195 @@ module Vanity
         @participants.drop
       end
 
-
       # -- Metrics --
 
       def get_metric_last_update_at(metric)
-        record = @metrics.find(:_id=>metric).limit(1).first
+        record = @metrics.find(_id: metric).limit(1).first
         record && record["last_update_at"]
       end
 
-      def metric_track(metric, timestamp, identity, values)
+      def metric_track(metric, timestamp, _identity, values)
         inc = {}
-        values.each_with_index do |v,i|
+        values.each_with_index do |v, i|
           inc["data.#{timestamp.to_date}.#{i}"] = v
         end
-        @metrics.find(:_id=>metric).find_one_and_replace(
+        @metrics.find(_id: metric).find_one_and_replace(
           {
-            "$inc"=>inc,
-            "$set"=>{ :last_update_at=>Time.now }
+            "$inc" => inc,
+            "$set" => { last_update_at: Time.now },
           },
-          :upsert=>true
+          upsert: true
         )
       end
 
       def metric_values(metric, from, to)
-        record = @metrics.find(:_id=>metric).limit(1).first
-        data = record && record["data"] || {}
+        record = @metrics.find(_id: metric).limit(1).first
+        data = (record && record["data"]) || {}
         (from.to_date..to.to_date).map { |date| (data[date.to_s] || {}).values }
       end
 
       def destroy_metric(metric)
-        @metrics.find(:_id=>metric).delete_one
+        @metrics.find(_id: metric).delete_one
       end
 
-
       # -- Experiments --
 
       def experiment_persisted?(experiment)
-        !!@experiments.find(:_id=>experiment).limit(1).first
+        !!@experiments.find(_id: experiment).limit(1).first
       end
 
       def set_experiment_created_at(experiment, time)
         # @experiments.insert_one(:_id=>experiment, :created_at=>time)
-        @experiments.find(:_id=>experiment).find_one_and_replace(
+        @experiments.find(_id: experiment).find_one_and_replace(
           {
-            "$setOnInsert"=>{ :created_at=>time }
+            "$setOnInsert" => { created_at: time },
           },
-          :upsert=>true
+          upsert: true
         )
       end
 
       def get_experiment_created_at(experiment)
-        record = @experiments.find(:_id=>experiment).limit(1).projection(:created_at=>1).first
+        record = @experiments.find(_id: experiment).limit(1).projection(created_at: 1).first
         record && record["created_at"]
-        #Returns nil if either the record or the field doesn't exist
+        # Returns nil if either the record or the field doesn't exist
       end
 
       def set_experiment_completed_at(experiment, time)
-        @experiments.find(:_id=>experiment).find_one_and_replace(
+        @experiments.find(_id: experiment).find_one_and_replace(
           {
-            "$set"=>{ :completed_at=>time }
+            "$set" => { completed_at: time },
           },
-          :upsert=>true
+          upsert: true
         )
       end
 
       def get_experiment_completed_at(experiment)
-        record = @experiments.find(:_id=>experiment).limit(1).projection(:completed_at=>1).first
+        record = @experiments.find(_id: experiment).limit(1).projection(completed_at: 1).first
         record && record["completed_at"]
       end
 
-      def is_experiment_completed?(experiment)
-        !!@experiments.find(:_id=>experiment, :completed_at=>{ "$exists"=>true }).limit(1).first
+      def is_experiment_completed?(experiment) # rubocop:todo Naming/PredicateName
+        !!@experiments.find(_id: experiment, completed_at: { "$exists" => true }).limit(1).first
       end
 
       def set_experiment_enabled(experiment, enabled)
-        @experiments.find(:_id=>experiment).find_one_and_replace(
+        @experiments.find(_id: experiment).find_one_and_replace(
           {
-            "$set"=>{ :enabled=>enabled }
+            "$set" => { enabled: enabled },
           },
-          :upsert=>true
+          upsert: true
         )
       end
 
-      def is_experiment_enabled?(experiment)
-        record = @experiments.find(:_id=>experiment).limit(1).projection(:enabled=>1).first
+      def is_experiment_enabled?(experiment) # rubocop:todo Naming/PredicateName
+        record = @experiments.find(_id: experiment).limit(1).projection(enabled: 1).first
         if Vanity.configuration.experiments_start_enabled
-          record == nil || record["enabled"] != false
+          record.nil? || record["enabled"] != false
         else
           record && record["enabled"] == true
         end
       end
 
       def ab_counts(experiment, alternative)
-        record = @experiments.find(:_id=>experiment ).limit(1).projection(:conversions=>1).first
+        record = @experiments.find(_id: experiment).limit(1).projection(conversions: 1).first
         conversions = record && record["conversions"]
-        { :participants => @participants.find({ :experiment=>experiment, :seen=>alternative }).count,
-          :converted    => @participants.find({ :experiment=>experiment, :converted=>alternative }).count,
-          :conversions  => conversions && conversions[alternative.to_s] || 0 }
+        { participants: @participants.find({ experiment: experiment, seen: alternative }).count,
+          converted: @participants.find({ experiment: experiment, converted: alternative }).count,
+          conversions: (conversions && conversions[alternative.to_s]) || 0 }
       end
 
       def ab_show(experiment, identity, alternative)
-        @participants.find(:experiment=>experiment, :identity=>identity).find_one_and_replace(
+        @participants.find(experiment: experiment, identity: identity).find_one_and_replace(
           {
-            "$set"=>{ :show=>alternative }
+            "$set" => { show: alternative },
           },
-          :upsert=>true
+          upsert: true
         )
       end
 
       def ab_showing(experiment, identity)
-        participant = @participants.find(:experiment=>experiment, :identity=>identity).limit(1).projection(:show=>1).first
+        participant = @participants.find(experiment: experiment, identity: identity).limit(1).projection(show: 1).first
         participant && participant["show"]
       end
 
       def ab_not_showing(experiment, identity)
-        @participants.find(:experiment=>experiment, :identity=>identity).find_one_and_replace(
+        @participants.find(experiment: experiment, identity: identity).find_one_and_replace(
           {
-            "$unset"=> { :show => "" }
+            "$unset" => { show: "" },
           },
-          :upsert=>true
+          upsert: true
         )
       end
 
       def ab_add_participant(experiment, alternative, identity)
-        @participants.find(:experiment=>experiment, :identity=>identity).find_one_and_replace(
+        @participants.find(experiment: experiment, identity: identity).find_one_and_replace(
           {
-            "$push"=>{ :seen=>alternative }
+            "$push" => { seen: alternative },
           },
-          :upsert=>true
+          upsert: true
         )
       end
 
       # Determines if a participant already has seen this alternative in this experiment.
       def ab_seen(experiment, identity, alternative_or_id)
         with_ab_seen_deprecation(experiment, identity, alternative_or_id) do |expt, ident, alt_id|
-          participant = @participants.find(:experiment=>expt, :identity=>ident).limit(1).projection(:seen=>1).first
+          participant = @participants.find(experiment: expt, identity: ident).limit(1).projection(seen: 1).first
           participant && participant["seen"].first == alt_id
         end
       end
 
       # Returns the participant's seen alternative in this experiment, if it exists
       def ab_assigned(experiment, identity)
-        participant = @participants.find(:experiment=>experiment, :identity=>identity).limit(1).projection(:seen=>1).first
+        participant = @participants.find(experiment: experiment, identity: identity).limit(1).projection(seen: 1).first
         participant && participant["seen"].first
       end
 
       def ab_add_conversion(experiment, alternative, identity, count = 1, implicit = false)
         if implicit
-          @participants.find(:experiment=>experiment, :identity=>identity).find_one_and_replace(
+          @participants.find(experiment: experiment, identity: identity).find_one_and_replace(
             {
-              "$push"=>{ :seen=>alternative }
+              "$push" => { seen: alternative },
             },
-            :upsert=>true
+            upsert: true
           )
         else
-          participating = @participants.find(:experiment=>experiment, :identity=>identity, :seen=>alternative).limit(1).first
+          participating = @participants.find(experiment: experiment, identity: identity, seen: alternative).limit(1).first
         end
 
         if implicit || participating
-          @participants.find(:experiment=>experiment, :identity=>identity).find_one_and_replace(
+          @participants.find(experiment: experiment, identity: identity).find_one_and_replace(
             {
-              "$push"=>{ :converted=>alternative }
+              "$push" => { converted: alternative },
             },
-            :upsert=>true
+            upsert: true
           )
         end
 
-        @experiments.find(:_id=>experiment).find_one_and_replace(
+        @experiments.find(_id: experiment).find_one_and_replace(
           {
-            "$inc"=>{ "conversions.#{alternative}"=>count }
+            "$inc" => { "conversions.#{alternative}" => count },
           },
-          :upsert=>true
+          upsert: true
         )
       end
 
       def ab_get_outcome(experiment)
-        experiment = @experiments.find(:_id=>experiment).limit(1).projection(:outcome=>1).first
+        experiment = @experiments.find(_id: experiment).limit(1).projection(outcome: 1).first
         experiment && experiment["outcome"]
       end
 
       def ab_set_outcome(experiment, alternative = 0)
-        @experiments.find(:_id=>experiment).find_one_and_replace(
+        @experiments.find(_id: experiment).find_one_and_replace(
           {
-            "$set"=>{ :outcome=>alternative }
+            "$set" => { outcome: alternative },
           },
-          :upsert=>true
+          upsert: true
         )
       end
 
       def destroy_experiment(experiment)
-        @experiments.find(:_id=>experiment).delete_one
-        @participants.find(:experiment=>experiment).delete_many
+        @experiments.find(_id: experiment).delete_one
+        @participants.find(experiment: experiment).delete_many
       end
 
       private