vwo-sdk 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e24789df43b6c0c71d71f8211c44ffe12c113e91943b91f8de581214353ccce
-  data.tar.gz: 95ec02ba3df3e88f91bf3f49eb5ab3ab64302b2c664d4d3caa6f569f2e618952
+  metadata.gz: 88beb4ef415731a07ac86d4d3ce19b9e3ea077d79d00e3e35e84f2b669c802eb
+  data.tar.gz: 2748de038b879ca5c27e237455bcbd6a62178101eae5c9fe1b2c87f64d5b25d7
 SHA512:
-  metadata.gz: 1dcc6b57a5fd35867d58d71f3f4b73b0da3ca73f01d009493f76b8981562e6d315f004a9095bcd20f230de1bf19559ac0a2ffefaa5befb72abae0e61de8fce6d
-  data.tar.gz: a7b154c4d9ae6c5b681c6cb27b231f3183a21c496e3eb5d33eecf81df0ca1d55922db127db37debe175aa060575f56dfe42ddbff29c0843e69839bcb57e4fc8c
+  metadata.gz: 38889e01c758f1336042deda0c39e2a678860eff7431bb465885bf72e9032f2277f0ef52ed5837593fd49b9b76ca1d74a673eb7774ee970422f9588b3698e0c6
+  data.tar.gz: 481f64eb7ff87622f12ff3122dcb57618d56add48ebe99524a8557930dd4e2bea85ee7c875024a45134d4948be47fa5da54e8c6e64463dae4f11d732fd00e2dd

data/lib/vwo.rb

@@ -143,9 +143,11 @@ class VWO
   def activate(campaign_key, user_id, options = {})
     # Retrieve custom variables
     custom_variables = options['custom_variables'] || options[:custom_variables]
+    variation_targeting_variables = options['variation_targeting_variables'] || options[:variation_targeting_variables]
 
     # Validate input parameters
-    unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables))
+    unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables)) &&
+           (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables))
       @logger.log(
         LogLevelEnum::ERROR,
         format(
@@ -208,11 +210,14 @@ class VWO
 
     # Once the matching RUNNING campaign is found, assign the
     # deterministic variation to the user_id provided
+
     variation = @variation_decider.get_variation(
       user_id,
       campaign,
+      ApiMethods::ACTIVATE,
       campaign_key,
-      custom_variables
+      custom_variables,
+      variation_targeting_variables
     )
 
     # Check if variation_name has been assigned
@@ -271,9 +276,11 @@ class VWO
   def get_variation_name(campaign_key, user_id, options = {})
     # Retrieve custom variables
     custom_variables = options['custom_variables'] || options[:custom_variables]
+    variation_targeting_variables = options['variation_targeting_variables'] || options[:variation_targeting_variables]
 
     # Validate input parameters
-    unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables))
+    unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables)) &&
+           (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables))
       @logger.log(
         LogLevelEnum::ERROR,
         format(
@@ -330,7 +337,7 @@ class VWO
       return
     end
 
-    variation = @variation_decider.get_variation(user_id, campaign, campaign_key, custom_variables)
+    variation = @variation_decider.get_variation(user_id, campaign, ApiMethods::GET_VARIATION_NAME, campaign_key, custom_variables, variation_targeting_variables)
 
     # Check if variation_name has been assigned
     unless valid_value?(variation)
@@ -379,14 +386,15 @@ class VWO
     if args[0].is_a?(Hash)
       revenue_value = args[0]['revenue_value'] || args[0][:revenue_value]
       custom_variables = args[0]['custom_variables'] || args[0][:custom_variables]
+      variation_targeting_variables = args[0]['variation_targeting_variables'] || args[0][:variation_targeting_variables]
     elsif args.is_a?(Array)
       revenue_value = args[0]
       custom_variables = nil
     end
 
     # Check for valid args
-    unless valid_string?(campaign_key) && valid_string?(user_id) && valid_string?(goal_identifier) &&
-           (custom_variables.nil? || valid_hash?(custom_variables)) || (revenue_value.nil? || valid_basic_data_type?(revenue_value))
+    unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables)) &&
+           (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables))
       # log invalid params
       @logger.log(
         LogLevelEnum::ERROR,
@@ -446,7 +454,7 @@ class VWO
       return false
     end
 
-    variation = @variation_decider.get_variation(user_id, campaign, campaign_key, custom_variables)
+    variation = @variation_decider.get_variation(user_id, campaign, ApiMethods::TRACK, campaign_key, custom_variables, variation_targeting_variables)
 
     if variation
       goal = get_campaign_goal(campaign, goal_identifier)
@@ -532,9 +540,11 @@ class VWO
   def feature_enabled?(campaign_key, user_id, options = {})
     # Retrieve custom variables
     custom_variables = options['custom_variables'] || options[:custom_variables]
+    variation_targeting_variables = options['variation_targeting_variables'] || options[:variation_targeting_variables]
 
     # Validate input parameters
-    unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables))
+    unless valid_string?(campaign_key) && valid_string?(user_id) && (custom_variables.nil? || valid_hash?(custom_variables)) &&
+           (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables))
       @logger.log(
         LogLevelEnum::ERROR,
         format(
@@ -594,7 +604,7 @@ class VWO
     end
 
     # Get variation
-    variation = @variation_decider.get_variation(user_id, campaign, campaign_key, custom_variables)
+    variation = @variation_decider.get_variation(user_id, campaign, ApiMethods::IS_FEATURE_ENABLED, campaign_key, custom_variables, variation_targeting_variables)
 
     # If no variation, did not become part of feature_test/rollout
     return false unless variation
@@ -682,9 +692,10 @@ class VWO
   def get_feature_variable_value(campaign_key, variable_key, user_id, options = {})
     # Retrieve custom variables
     custom_variables = options['custom_variables'] || options[:custom_variables]
+    variation_targeting_variables = options['variation_targeting_variables'] || options[:variation_targeting_variables]
 
     unless valid_string?(campaign_key) && valid_string?(variable_key) && valid_string?(user_id) &&
-           (custom_variables.nil? || valid_hash?(custom_variables))
+           (custom_variables.nil? || valid_hash?(custom_variables)) && (variation_targeting_variables.nil? || valid_hash?(variation_targeting_variables))
       @logger.log(
         LogLevelEnum::ERROR,
         format(
@@ -743,7 +754,7 @@ class VWO
       return
     end
 
-    variation = @variation_decider.get_variation(user_id, campaign, campaign_key, custom_variables)
+    variation = @variation_decider.get_variation(user_id, campaign, ApiMethods::GET_FEATURE_VARIABLE_VALUE, campaign_key, custom_variables, variation_targeting_variables)
 
     # Check if variation has been assigned to user
     return unless variation

data/lib/vwo/constants.rb

@@ -26,7 +26,7 @@ class VWO
     HTTP_PROTOCOL = 'http://'
     HTTPS_PROTOCOL = 'https://'
     URL_NAMESPACE = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'
-    SDK_VERSION = '1.5.0'
+    SDK_VERSION = '1.6.0'
     SDK_NAME = 'ruby'
 
     module ENDPOINTS

data/lib/vwo/core/bucketer.rb

@@ -116,11 +116,9 @@ class VWO
           )
         )
 
-        get_variation(campaign, bucket_value)
+        get_variation(campaign['variations'], bucket_value)
       end
 
-      private
-
       # Returns the Variation by checking the Start and End
       # Bucket Allocations of each Variation
       #
@@ -128,8 +126,8 @@ class VWO
       # @param[Integer]     :bucket_value   The bucket Value of the user
       # @return[Hash|nil]                   Variation data allotted to the user or None if not
       #
-      def get_variation(campaign, bucket_value)
-        campaign['variations'].find do |variation|
+      def get_variation(variations, bucket_value)
+        variations.find do |variation|
           (variation['start_variation_allocation']..variation['end_variation_allocation']).cover?(bucket_value)
         end
       end

data/lib/vwo/core/variation_decider.rb

@@ -43,6 +43,7 @@ class VWO
       end
 
       # Returns variation for the user for the passed campaign-key
+      # Check if Whitelisting is applicable, evaluate it, if any eligible variation is found,return, otherwise skip it
       # Check in User Storage, if user found, validate variation and return
       # Otherwise, proceed with variation assignment logic
       #
@@ -53,9 +54,54 @@ class VWO
       # @return[String,String]                       ({variation_id, variation_name}|Nil): Tuple of
       #                                              variation_id and variation_name if variation allotted, else nil
 
-      def get_variation(user_id, campaign, campaign_key, custom_variables = {})
+      def get_variation(user_id, campaign, api_name, campaign_key, custom_variables = {}, variation_targeting_variables = {})
         campaign_key ||= campaign['key']
 
+        return unless campaign
+
+        if campaign['isForcedVariationEnabled']
+          variation = evaluate_whitelisting(
+            user_id,
+            campaign,
+            api_name,
+            campaign_key,
+            variation_targeting_variables
+          )
+          status = if variation
+                     StatusEnum::PASSED
+                   else
+                     StatusEnum::FAILED
+                   end
+
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::SEGMENTATION_STATUS,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              status: status,
+              custom_variables: variation_targeting_variables,
+              variation_name: status == StatusEnum::PASSED ? "and #{variation['name']} is Assigned" : ' ',
+              segmentation_type: SegmentationTypeEnum::WHITELISTING,
+              api_name: api_name
+            )
+          )
+
+          return variation if variation && variation['name']
+        else
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::WHITELISTING_SKIPPED,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              api_name: api_name
+            )
+          )
+        end
+
         user_campaign_map = get_user_storage(user_id, campaign_key)
         variation = get_stored_variation(user_id, campaign_key, user_campaign_map) if valid_hash?(user_campaign_map)
 
@@ -74,7 +120,6 @@ class VWO
         end
 
         # Pre-segmentation
-        return unless campaign
 
         segments = get_segments(campaign)
         is_valid_segments = valid_value?(segments)
@@ -88,21 +133,44 @@ class VWO
                 file: FILE,
                 campaign_key: campaign_key,
                 user_id: user_id,
-                api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE
+                api_name: api_name
               )
             )
             custom_variables = {}
           end
-          return unless @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables)
+          unless @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables)
+            @logger.log(
+              LogLevelEnum::INFO,
+              format(
+                LogMessageEnum::InfoMessages::USER_FAILED_SEGMENTATION,
+                file: FileNameEnum::SegmentEvaluator,
+                user_id: user_id,
+                campaign_key: campaign_key,
+                custom_variables: custom_variables
+              )
+            )
+            return
+          end
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::USER_PASSED_SEGMENTATION,
+              file: FileNameEnum::SegmentEvaluator,
+              user_id: user_id,
+              campaign_key: campaign_key,
+              custom_variables: custom_variables
+            )
+          )
         else
           @logger.log(
             LogLevelEnum::INFO,
             format(
-              LogMessageEnum::InfoMessages::SKIPPING_PRE_SEGMENTATION,
+              LogMessageEnum::InfoMessages::SKIPPING_SEGMENTATION,
               file: FILE,
               campaign_key: campaign_key,
               user_id: user_id,
-              api_name: ApiMethods::GET_FEATURE_VARIABLE_VALUE
+              api_name: api_name,
+              variation: ''
             )
           )
         end
@@ -183,6 +251,7 @@ class VWO
       # @param[String]              :user_id      The unique ID assigned to a user
       # @param[Hash]                :campaign     The Campaign of which user is to be made a part of
       # @return[Hash]                         Variation allotted to User
+
       def get_variation_of_campaign_for_user(user_id, campaign)
         unless campaign
           @logger.log(
@@ -226,6 +295,111 @@ class VWO
 
       private
 
+      # Evaluate all the variations in the campaign to find
+      #
+      # @param[String]  :user_id                            The unique key assigned to User
+      # @param[Hash]    :campaign                           Campaign hash for Unique campaign key
+      # @param[String]  :api_name                           The key Passed to identify the calling API
+      # @param[String]  :campaign_key                       Unique campaign key
+      # @param[Hash]    :variation_targeting_variables      Key/value pair of Whitelisting Custom Attributes
+      #
+      # @return[Hash]
+
+      def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {})
+        if variation_targeting_variables.nil?
+          variation_targeting_variables = { '_vwo_user_id' => user_id }
+        else
+          variation_targeting_variables['_vwo_user_id'] = user_id
+        end
+        targeted_variations = []
+
+        campaign['variations'].each do |variation|
+          segments = get_segments(variation)
+          is_valid_segments = valid_value?(segments)
+          if is_valid_segments
+            if @segment_evaluator.evaluate(campaign_key, user_id, segments, variation_targeting_variables)
+              targeted_variations.push(variation)
+              status = StatusEnum::PASSED
+            else
+              status = StatusEnum::FAILED
+            end
+            @logger.log(
+              LogLevelEnum::DEBUG,
+              format(
+                LogMessageEnum::DebugMessages::SEGMENTATION_STATUS,
+                file: FILE,
+                campaign_key: campaign_key,
+                user_id: user_id,
+                status: status,
+                custom_variables: variation_targeting_variables,
+                variation_name: variation['name'],
+                segmentation_type: SegmentationTypeEnum::WHITELISTING,
+                api_name: api_name
+              )
+            )
+          else
+            @logger.log(
+              LogLevelEnum::DEBUG,
+              format(
+                LogMessageEnum::InfoMessages::SKIPPING_SEGMENTATION,
+                file: FILE,
+                campaign_key: campaign_key,
+                user_id: user_id,
+                api_name: api_name,
+                variation: variation['name']
+              )
+            )
+          end
+        end
+
+        if targeted_variations.length > 1
+          targeted_variations_deep_clone = Marshal.load(Marshal.dump(targeted_variations))
+          scale_variation_weights(targeted_variations_deep_clone)
+          current_allocation = 0
+          targeted_variations_deep_clone.each do |variation|
+            step_factor = get_variation_bucketing_range(variation['weight'])
+            if step_factor > 0
+              start_range = current_allocation + 1
+              end_range = current_allocation + step_factor
+              variation['start_variation_allocation'] = start_range
+              variation['end_variation_allocation'] = end_range
+              current_allocation += step_factor
+            else
+              variation['start_variation_allocation'] = -1
+              variation['end_variation_allocation'] = -1
+            end
+          end
+          whitelisted_variation = @bucketer.get_variation(
+            targeted_variations_deep_clone,
+            @bucketer.get_bucket_value_for_user(
+              user_id
+            )
+          )
+        else
+          whitelisted_variation = targeted_variations[0]
+        end
+        whitelisted_variation
+      end
+
+      # It extracts the weights from all the variations inside the campaign
+      # and scales them so that the total sum of eligible variations' weights become 100%
+      #
+      # 1. variations
+
+      def scale_variation_weights(variations)
+        total_weight = variations.reduce(0) { |final_weight, variation| final_weight + variation['weight'].to_f }
+        if total_weight == 0
+          weight = 100 / variations.length
+          variations.each do |variation|
+            variation['weight'] = weight
+          end
+        else
+          variations.each do |variation|
+            variation['weight'] = (variation['weight'] / total_weight) * 100
+          end
+        end
+      end
+
       # Get the UserStorageData after looking up into get method
       # Being provided via UserStorageService
       #

data/lib/vwo/enums.rb

@@ -42,6 +42,7 @@ class VWO
 
     module OperandTypes
       CUSTOM_VARIABLE = 'custom_variable'
+      USER = 'user'
     end
 
     module OperandValuesBooleanTypes
@@ -49,6 +50,16 @@ class VWO
       FALSE = 'false'
     end
 
+    module StatusEnum
+      PASSED = 'passed'
+      FAILED = 'failed'
+    end
+
+    module SegmentationTypeEnum
+      WHITELISTING = 'whitelisting'
+      PRE_SEGMENTATION = 'pre-segmentation'
+    end
+
     module FileNameEnum
       VWO_PATH = 'vwo'
       UTIL_PATH = 'vwo/utils'
@@ -93,6 +104,7 @@ class VWO
         IMPRESSION_FOR_TRACK_USER = '(%<file>s): Impression built for track-user - %<properties>s'
         IMPRESSION_FOR_TRACK_GOAL = '(%<file>s): Impression built for track-goal - %<properties>s'
         GOT_VARIATION_FOR_USER = '(%<file>s): userId:%<user_id>s for campaign:%<campaign_key>s got variationName:%<variation_name>s'
+        SEGMENTATION_STATUS = '(%<file>s): In API: %<api_name>s, for UserId:%<user_id>s of campaign:%<campaign_key>s  with variables:%<custom_variables>s %<status>s %<segmentation_type>s for %<variation_name>s'
         PARAMS_FOR_PUSH_CALL = '(%<file>s): Params for push call - %<properties>s'
       end
 
@@ -120,11 +132,14 @@ class VWO
 
         VARIABLE_FOUND = '(%<file>s): In API: %<api_name>s Value for variable:%<variable_key>s of campaign:%<campaign_key>s and campaign type: %<campaign_type>s is:%<variable_value>s for user:%<user_id>s'
 
-        USER_PASSED_PRE_SEGMENTATION = '(%<file>s): UserId:%<user_id>s of campaign:%<campaign_key>s with custom_variables:%<custom_variables>s passed pre segmentation'
-        USER_FAILED_PRE_SEGMENTATION = '(%<file>s): UserId:%<user_id>s of campaign:%<campaign_key>s with custom_variables:%<custom_variables>s failed pre segmentation'
+        USER_PASSED_SEGMENTATION = '(%<file>s): UserId:%<user_id>s of campaign:%<campaign_key>s with custom_variables:%<custom_variables>s passed segmentation'
+        USER_FAILED_SEGMENTATION = '(%<file>s): UserId:%<user_id>s of campaign:%<campaign_key>s with custom_variables:%<custom_variables>s failed segmentation'
 
         NO_CUSTOM_VARIABLES = '(%<file>s): In API: %<api_name>s, for UserId:%<user_id>s preSegments/customVariables are not passed for campaign:%<campaign_key>s and campaign has pre-segmentation'
-        SKIPPING_PRE_SEGMENTATION = '(%<file>s): In API: %<api_name>s, Skipping pre-segmentation for UserId:%<user_id>s as no valid segments found in campaign:%<campaign_key>s'
+        SKIPPING_SEGMENTATION = '(%<file>s): In API: %<api_name>s, Skipping segmentation:%<variation>s for UserId:%<user_id>s as no valid segments found in campaign:%<campaign_key>s'
+
+        SEGMENTATION_STATUS = '(%<file>s): In API: %<api_name>s, for UserId:%<user_id>s of campaign:%<campaign_key>s  with variables:%<custom_variables>s %<status>s %<segmentation_type>s %<variation_name>s'
+        WHITELISTING_SKIPPED = '(%<file>s): In API: %<api_name>s, Skipping whitelisting for UserId:%<user_id>s of campaign:%<campaign_key>s'
       end
 
       # Warning Messages
@@ -159,7 +174,7 @@ class VWO
         USER_NOT_IN_CAMPAIGN = '(%<file>s): userId:%<user_id>s did not become part of campaign:%<campaign_key>s and campaign type:%<campaign_type>s'
         API_NOT_WORKING = '(%<file>s): API: %<api_name>s not working, exception caught: %<exception>s. Please contact VWO Support for help.'
 
-        PRE_SEGMENTATION_ERROR = '(%<file>s): Error while segmenting the UserId:%<user_id>s of campaign:%<campaign_key>s with custom_variables:%<custom_variables>s. Error message: %<error_message>s'
+        SEGMENTATION_ERROR = '(%<file>s): Error while segmenting the UserId:%<user_id>s of campaign:%<campaign_key>s with custom_variables:%<custom_variables>s. Error message: %<error_message>s'
 
         PUSH_API_INVALID_PARAMS = '(%<file>s): %<api_name>s API got bad parameters. It expects tag_key(String) as first and tag_value(String) as second argument and user_id(String) as third argument'
         TAG_VALUE_LENGTH_EXCEEDED = '(%<file>s): In API: %<api_name>s, the length of tag_value:%<tag_value>s and userID: %<user_id>s can not be greater than 255'

data/lib/vwo/services/operand_evaluator.rb

@@ -89,7 +89,7 @@ class VWO
       # @param [String] :custom_variables_value   Value from the custom_variables
       #
       # @return [Boolean]
-      def evaluate_operand?(operand, custom_variables)
+      def evaluate_custom_variable?(operand, custom_variables)
         # Extract custom_variable_key and custom_variables_value from operand
 
         operand_key, operand = get_key_value(operand)
@@ -109,6 +109,14 @@ class VWO
         # Call the self method corresponding to operand_type to evaluate the result
         public_send("#{operand_type}?", operand_value, custom_variables_value)
       end
+
+      def evaluate_user?(operand, custom_variables)
+        users = operand.split(',')
+        users.each do |user|
+          return true if user.strip == custom_variables['_vwo_user_id']
+        end
+        false
+      end
     end
   end
 end

data/lib/vwo/services/segment_evaluator.rb

@@ -50,7 +50,9 @@ class VWO
         elsif operator == OperatorTypes::OR
           sub_dsl.any? { |y| evaluate_util(y, custom_variables) }
         elsif operator == OperandTypes::CUSTOM_VARIABLE
-          @operand_evaluator.evaluate_operand?(sub_dsl, custom_variables)
+          @operand_evaluator.evaluate_custom_variable?(sub_dsl, custom_variables)
+        elsif operator == OperandTypes::USER
+          @operand_evaluator.evaluate_user?(sub_dsl, custom_variables)
         end
       end
 
@@ -66,35 +68,12 @@ class VWO
       #
       def evaluate(campaign_key, user_id, dsl, custom_variables)
         result = evaluate_util(dsl, custom_variables) if valid_value?(dsl)
-        if result
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::USER_PASSED_PRE_SEGMENTATION,
-              file: FileNameEnum::SegmentEvaluator,
-              user_id: user_id,
-              campaign_key: campaign_key,
-              custom_variables: custom_variables
-            )
-          )
-        else
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::USER_FAILED_PRE_SEGMENTATION,
-              file: FileNameEnum::SegmentEvaluator,
-              user_id: user_id,
-              campaign_key: campaign_key,
-              custom_variables: custom_variables
-            )
-          )
-        end
         result
       rescue StandardError => e
         @logger.log(
           LogLevelEnum::ERROR,
           format(
-            LogMessageEnum::ErrorMessages::PRE_SEGMENTATION_ERROR,
+            LogMessageEnum::ErrorMessages::SEGMENTATION_ERROR,
             file: FileNameEnum::SegmentEvaluator,
             user_id: user_id,
             campaign_key: campaign_key,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vwo-sdk
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - VWO
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-20 00:00:00.000000000 Z
+date: 2020-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls
@@ -97,7 +97,7 @@ files:
 - lib/vwo/utils/validations.rb
 homepage: https://vwo.com/fullstack/server-side-testing/
 licenses:
-- Apache 2.0
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []