wingify-fme-ruby-sdk 1.55.0 → 1.60.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a073ce2ab36cb95b76047665658a4d4bb4e894f9f4bca5f909b3ae449479c48
-  data.tar.gz: 63e231332dda090e3df7ec30a2823678215eb6ca6a310340497a6aa32c868c86
+  metadata.gz: edbf0906fddff5a86daaf76539bfb4c221f688f236c426a55ead7b225603d3db
+  data.tar.gz: a95ba0f7c1ac4dd31471ffd6b0a781a6e278baa9a5c1d7c512f7e00f4dd2f669
 SHA512:
-  metadata.gz: 3b5dc171ebbaf2166e009debef850ef92bc6b705f1953fcf38102c90f1dbf5b2b4d2576c61f1eee9f13896aa81fae03e71f51367065c158090ba947364a2f2b9
-  data.tar.gz: 4494ffd33b81c50c4c907797f436f86a3bbadff4f5c7648c358d3b33e56153cb40188709f11c0ae272f8357329725bd853d68d4e1313cfae90b54720c7a4cdc5
+  metadata.gz: 3f0883eba6a6e467812169f70ec2f3c9d1f49fef233f423462c4d975948c15a54680aeb83b2e6c27c427beb89a36fef7475ce274f54a91c231f75733201a01b6
+  data.tar.gz: a9f6718ce695f063215f29176554e3ba3447e3d94f0cf8e2befdfd514e87fd25575b0103eae529a7d51d58aae3b4e9d728a36e9c1eef773adf813b522c744831

data/lib/resources/error_messages.json

@@ -59,5 +59,9 @@
 
     "ERROR_EVALUATING_RULE": "Error occurred while evaluating rule. Error: {err}",
     "BATCH_FLUSH_FAILED": "Failed to send batch events. Re-enqueuing events for retry.",
-    "ERROR_PARSING_GATEWAY_URL": "Error occurred while parsing gateway service URL: {err}"
+    "ERROR_PARSING_GATEWAY_URL": "Error occurred while parsing gateway service URL: {err}",
+    
+    "INVALID_WEB_TESTING_CAMPAIGNS_DUPLICATE_KEY": "Duplicate campaignId found in webTestingCampaigns",
+    "INVALID_WEB_TESTING_CAMPAIGNS_JSON": "webTestingCampaigns provided in context is not a valid JSON string",
+    "INVALID_WEB_TESTING_CAMPAIGNS_TYPE": "webTestingCampaigns provided in context is of type {kind}, but must be of type string or object"
   }

data/lib/wingify/constants/constants.rb

@@ -17,7 +17,7 @@
 # Define the Constants module
 module Constants
   SDK_NAME = 'vwo-fme-ruby-sdk'.freeze
-  SDK_VERSION = '1.55.0'.freeze
+  SDK_VERSION = '1.60.0'.freeze
 
   # --- Brand-specific constants ---
 

data/lib/wingify/models/user/context_model.rb

@@ -17,15 +17,16 @@ require_relative '../../utils/uuid_util'
 require_relative '../../services/settings_service'
 
 class ContextModel
-  attr_accessor :id, :user_agent, :ip_address, :custom_variables, :variation_targeting_variables, :post_segmentation_variables, :vwo, :session_id, :uuid, :bucketing_seed
+  attr_accessor :id, :user_agent, :ip_address, :custom_variables, :variation_targeting_variables, :post_segmentation_variables, :platform_variables, :vwo, :session_id, :uuid, :bucketing_seed
 
-  def initialize(id = nil, user_agent = nil, ip_address = nil, custom_variables = {}, variation_targeting_variables = {}, post_segmentation_variables = {}, vwo = nil, session_id = nil, uuid = nil, bucketing_seed = nil)
+  def initialize(id = nil, user_agent = nil, ip_address = nil, custom_variables = {}, variation_targeting_variables = {}, post_segmentation_variables = {}, platform_variables = {}, vwo = nil, session_id = nil, uuid = nil, bucketing_seed = nil)
     @id = id
     @user_agent = user_agent
     @ip_address = ip_address
     @custom_variables = custom_variables || {}
     @variation_targeting_variables = variation_targeting_variables || {}
     @post_segmentation_variables = post_segmentation_variables || {}
+    @platform_variables = platform_variables || {}
     @vwo = vwo
     @session_id = session_id
     @uuid = uuid
@@ -52,6 +53,7 @@ class ContextModel
     @custom_variables = context[:customVariables] if context.key?(:customVariables)
     @variation_targeting_variables = context[:variationTargetingVariables] if context.key?(:variationTargetingVariables)
     @post_segmentation_variables = context[:postSegmentationVariables] if context.key?(:postSegmentationVariables)
+    @platform_variables = context[:platformVariables] if context.key?(:platformVariables)
     @vwo = ContextVWOModel.new.model_from_dictionary(context[:_vwo]) if context.key?(:_vwo)
     @bucketing_seed = context[:bucketingSeed].to_s if context.key?(:bucketingSeed)
 
@@ -120,6 +122,14 @@ class ContextModel
     @post_segmentation_variables = post_segmentation_variables
   end
 
+  def get_platform_variables
+    @platform_variables
+  end
+
+  def set_platform_variables(platform_variables)
+    @platform_variables = platform_variables
+  end
+
   def get_vwo
     @vwo
   end

data/lib/wingify/packages/segmentation_evaluator/core/segmentation_manager.rb

@@ -24,6 +24,8 @@ require_relative '../../../services/settings_service'
 require_relative '../../../utils/data_type_util'
 require_relative '../../../enums/log_level_enum'
 require_relative '../../../enums/api_enum'
+require_relative '../enums/segment_operator_value_enum'
+
 class SegmentationManager
   @@instance = nil # Singleton instance
 
@@ -72,6 +74,43 @@ class SegmentationManager
   end
 
   def validate_segmentation(dsl, properties)
+    if has_campaign_variation_node?(dsl)
+      platform_vars = @evaluator.context&.get_platform_variables
+      web_testing_campaigns = platform_vars && (platform_vars[:webTestingCampaigns] || platform_vars['webTestingCampaigns'])
+      return false unless web_testing_campaigns
+    end
+
     @evaluator.is_segmentation_valid(dsl, properties)
   end
+
+  private
+
+  # Checks if the provided DSL contains a campaign variation node.
+  # This is used to determine if web testing pre-segmentation should be evaluated.
+  #
+  # @param dsl [Hash] The DSL (Domain Specific Language) representing the segmentation rules.
+  # @return [Boolean] Returns true if a web campaign variation node is found, false otherwise.
+  def has_campaign_variation_node?(dsl)
+    # Return false immediately if the DSL is not a hash
+    return false unless dsl.is_a?(Hash)
+
+    # Iterate through each operator and operand in the DSL
+    dsl.each do |operator, operand|
+      # Check if the current operator matches the web campaign variation operator
+      return true if operator.to_s == SegmentOperatorValueEnum::WEB_CAMPAIGN_VARIATION
+
+      # If the operand is an array, recursively check each sub-DSL within it
+      if operand.is_a?(Array)
+        operand.each do |sub_dsl|
+          return true if has_campaign_variation_node?(sub_dsl)
+        end
+      # If the operand is a hash, recursively check the hash itself
+      elsif operand.is_a?(Hash)
+        return true if has_campaign_variation_node?(operand)
+      end
+    end
+    
+    # Return false if no campaign variation node is found in the entire DSL structure
+    false
+  end
 end

data/lib/wingify/packages/segmentation_evaluator/enums/segment_operator_value_enum.rb

@@ -30,4 +30,5 @@ module SegmentOperatorValueEnum
     IP = 'ip_address'
     BROWSER_VERSION = 'browser_version'
     OS_VERSION = 'os_version'
+    WEB_CAMPAIGN_VARIATION = 'campaignVariation'
   end

data/lib/wingify/packages/segmentation_evaluator/evaluators/segment_evaluator.rb

@@ -57,6 +57,8 @@ class SegmentEvaluator
       SegmentOperandEvaluator.new.evaluate_custom_variable_dsl(sub_dsl, properties)
     when SegmentOperatorValueEnum::USER
       SegmentOperandEvaluator.new.evaluate_user_dsl(sub_dsl, properties)
+    when SegmentOperatorValueEnum::WEB_CAMPAIGN_VARIATION
+      SegmentOperandEvaluator.new.evaluate_web_testing_campaign_variation_dsl(sub_dsl, @context)
     when SegmentOperatorValueEnum::UA
       SegmentOperandEvaluator.new.evaluate_user_agent_dsl(sub_dsl, @context)
     when SegmentOperatorValueEnum::IP

data/lib/wingify/packages/segmentation_evaluator/evaluators/segment_operand_evaluator.rb

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 require_relative '../utils/segment_util'
+require_relative '../utils/web_testing_segment_util'
 require_relative '../enums/segment_operand_value_enum'
 require_relative '../enums/segment_operand_regex_enum'
 require_relative '../enums/segment_operator_value_enum'
@@ -105,6 +106,22 @@ class SegmentOperandEvaluator
     extract_result(processed_operand[:operand_type], processed_values[:operand_value], tag_value)
   end
 
+  # Evaluates Web Testing pre-segmentation against `context.platform_variables[:webTestingCampaigns]`.
+  # @param dsl_operand_value [String] The operand value to evaluate
+  # @param context [ContextModel] The context to evaluate the operand against
+  # @return [Boolean] True if the operand value matches the tag value, false otherwise
+  def evaluate_web_testing_campaign_variation_dsl(dsl_operand_value, context)
+    operand = dsl_operand_value.to_s.strip
+    assigned_variations_by_campaign_id = WebTestingSegmentUtil.parse_web_testing_campaigns_from_context(context)
+    result_obj = WebTestingSegmentUtil.evaluate_web_testing_campaign_variation(operand, assigned_variations_by_campaign_id)
+    
+    if result_obj[:invalid_format]
+      return false
+    end
+    
+    result_obj[:result]
+  end
+
   # Evaluates a given string tag value against a DSL operand value.
   # @param dsl_operand_value [String] The DSL operand string (e.g., "contains(\"value\")").
   # @param context [ContextModel] The context object containing the value to evaluate.

data/lib/wingify/packages/segmentation_evaluator/utils/web_testing_segment_util.rb

@@ -0,0 +1,146 @@
+# Copyright 2024-2026 Wingify Software Pvt. Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'json'
+require_relative '../../../enums/api_enum'
+require_relative '../../../services/logger_service'
+require_relative '../../../enums/log_level_enum'
+require_relative '../../../utils/data_type_util'
+
+module WebTestingSegmentUtil
+  class << self
+    # Normalizes Web Testing campaign map keys and variation values to strings.
+    # @param raw_assignments [Hash] The raw assignments map from the context.
+    # @return [Hash] The normalized assignments map with campaign_id as key and variation_id as value.
+    def normalize_web_testing_campaigns_map(raw_assignments)
+      campaign_id_to_variation_id = {}
+      raw_assignments.each do |campaign_id, assigned_variation_id|
+        unless assigned_variation_id.nil? || campaign_id.to_s.empty?
+          campaign_id_to_variation_id[campaign_id.to_s] = assigned_variation_id.to_s
+        end
+      end
+      campaign_id_to_variation_id
+    end
+
+    # Parses `context.platform_variables[:webTestingCampaigns]` (JSON string or plain object).
+    # @param context [ContextModel]
+    # @return [Hash, nil]
+    def parse_web_testing_campaigns_from_context(context)
+      platform_variables = context.get_platform_variables || {}
+      # support both string and symbol keys
+      web_testing_campaigns_input = platform_variables[:webTestingCampaigns] || platform_variables['webTestingCampaigns']
+
+      if web_testing_campaigns_input.nil?
+        return nil
+      end
+
+      if web_testing_campaigns_input.is_a?(Hash)
+        return normalize_web_testing_campaigns_map(web_testing_campaigns_input)
+      end
+
+      if web_testing_campaigns_input.is_a?(String)
+        trimmed_json = web_testing_campaigns_input.strip
+        if trimmed_json.empty?
+          return nil
+        end
+
+        begin
+          # Check for duplicate keys using regex
+          all_campaign_id_tokens = trimmed_json.scan(/"([^"\\]*)"\s*:/).flatten
+          if all_campaign_id_tokens.any?
+            campaign_ids = all_campaign_id_tokens
+            has_duplicate_campaign_id = campaign_ids.length != campaign_ids.uniq.length
+            if has_duplicate_campaign_id
+              LoggerService.log(
+                LogLevelEnum::ERROR,
+                'INVALID_WEB_TESTING_CAMPAIGNS_DUPLICATE_KEY',
+                { an: ApiEnum::GET_FLAG, uuid: context.get_uuid, sId: context.get_session_id }
+              )
+            end
+          end
+
+          parsed_assignments = JSON.parse(trimmed_json)
+          if parsed_assignments.is_a?(Hash)
+            return normalize_web_testing_campaigns_map(parsed_assignments)
+          end
+
+          LoggerService.log(
+            LogLevelEnum::ERROR,
+            'INVALID_WEB_TESTING_CAMPAIGNS_JSON',
+            { an: ApiEnum::GET_FLAG, uuid: context.get_uuid, sId: context.get_session_id }
+          )
+        rescue JSON::ParserError
+          LoggerService.log(
+            LogLevelEnum::ERROR,
+            'INVALID_WEB_TESTING_CAMPAIGNS_JSON',
+            { an: ApiEnum::GET_FLAG, uuid: context.get_uuid, sId: context.get_session_id }
+          )
+        end
+        return nil
+      end
+
+      # For array, numeric, boolean etc.
+      kind = web_testing_campaigns_input.is_a?(Array) ? 'array' : DataTypeUtil.get_type(web_testing_campaigns_input).downcase
+      LoggerService.log(
+        LogLevelEnum::ERROR,
+        'INVALID_WEB_TESTING_CAMPAIGNS_TYPE',
+        { kind: kind, an: ApiEnum::GET_FLAG, uuid: context.get_uuid, sId: context.get_session_id }
+      )
+      nil
+    end
+
+    # Evaluates campaignVariation operand encoding:
+    # - "!C" — user is not in campaign C (no entry in map)
+    # - "C_!V" — user is in campaign C and assigned variation is not V
+    # - "C_V" — user is in campaign C with variation V
+    # - "C" (digits only) — user is in campaign C (any variation)
+    def evaluate_web_testing_campaign_variation(campaign_variation_operand, assigned_variations_by_campaign_id)
+      assignments = assigned_variations_by_campaign_id || {}
+
+      # match type !C
+      if match = /^!(\d+)$/.match(campaign_variation_operand)
+        campaign_id = match[1]
+        return { result: !assignments.key?(campaign_id), invalid_format: false }
+      end
+
+      # match type C_!V
+      if match = /^(\d+)_!(\d+)$/.match(campaign_variation_operand)
+        campaign_id = match[1]
+        variation_id = match[2]
+        if !assignments.key?(campaign_id)
+          return { result: false, invalid_format: false }
+        end
+        return { result: assignments[campaign_id] != variation_id, invalid_format: false }
+      end
+      
+      # match type C_V
+      if match = /^(\d+)_(\d+)$/.match(campaign_variation_operand)
+        campaign_id = match[1]
+        variation_id = match[2]
+        if !assignments.key?(campaign_id)
+          return { result: false, invalid_format: false }
+        end
+        return { result: assignments[campaign_id] == variation_id, invalid_format: false }
+      end
+      
+      # match type C
+      if match = /^(\d+)$/.match(campaign_variation_operand)
+        campaign_id = match[1]
+        return { result: assignments.key?(campaign_id), invalid_format: false }
+      end
+
+      { result: false, invalid_format: true }
+    end
+  end
+end

data/lib/wingify.rb

@@ -43,6 +43,11 @@ module Wingify
                    .init_batch
 
     if options[:settings]
+      if SettingsSchema.new.is_settings_valid(options[:settings])
+        SettingsService.instance.is_settings_valid = true
+      else
+        LoggerService.log(LogLevelEnum::ERROR, "INVALID_SETTINGS_SCHEMA", { accountId: options[:account_id], sdkKey: options[:sdk_key], settings: options[:settings], an: ApiEnum::INIT}, false)
+      end
       return @@wingify_builder.build(options[:settings])
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wingify-fme-ruby-sdk
 version: !ruby/object:Gem::Version
-  version: 1.55.0
+  version: 1.60.0
 platform: ruby
 authors:
 - Wingify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-29 00:00:00.000000000 Z
+date: 2026-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uuidtools
@@ -269,6 +269,7 @@ files:
 - lib/wingify/packages/segmentation_evaluator/evaluators/segment_evaluator.rb
 - lib/wingify/packages/segmentation_evaluator/evaluators/segment_operand_evaluator.rb
 - lib/wingify/packages/segmentation_evaluator/utils/segment_util.rb
+- lib/wingify/packages/segmentation_evaluator/utils/web_testing_segment_util.rb
 - lib/wingify/packages/storage/connector.rb
 - lib/wingify/packages/storage/storage.rb
 - lib/wingify/services/batch_event_queue.rb