vwo-fme-ruby-sdk 1.0.0 → 1.1.0

data/lib/vwo/packages/network_layer/models/global_request_model.rb

@@ -0,0 +1,105 @@
+# Copyright 2025 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.
+
+class GlobalRequestModel
+    attr_accessor :url, :timeout, :query, :body, :headers, :is_development_mode
+  
+    # Constructs an instance of the GlobalRequestModel.
+    # @param url [String] The base URL of the HTTP request.
+    # @param query [Hash] Query parameters as a record of key-value pairs.
+    # @param body [Hash] Body of the request as a record of key-value pairs.
+    # @param headers [Hash] HTTP headers as a record of key-value pairs.
+    def initialize(url, query, body, headers)
+      @url = url
+      @query = query
+      @body = body
+      @headers = headers
+      @timeout = 3000 # Default timeout in milliseconds
+      @is_development_mode = nil # Flag to indicate if the request is in development mode
+    end
+  
+    # Sets the query parameters for the HTTP request.
+    # @param query [Hash] A record of key-value pairs representing the query parameters.
+    def set_query(query)
+      @query = query
+    end
+  
+    # Retrieves the query parameters of the HTTP request.
+    # @returns [Hash] A record of key-value pairs representing the query parameters.
+    def get_query
+      @query
+    end
+  
+    # Sets the body of the HTTP request.
+    # @param body [Hash] A record of key-value pairs representing the body content.
+    def set_body(body)
+      @body = body
+    end
+  
+    # Retrieves the body of the HTTP request.
+    # @returns [Hash] A record of key-value pairs representing the body content.
+    def get_body
+      @body
+    end
+  
+    # Sets the base URL of the HTTP request.
+    # @param url [String] The base URL as a string.
+    def set_base_url(url)
+      @url = url
+    end
+  
+    # Retrieves the base URL of the HTTP request.
+    # @returns [String] The base URL as a string.
+    def get_base_url
+      @url
+    end
+  
+    # Sets the timeout duration for the HTTP request.
+    # @param timeout [Integer] Timeout in milliseconds.
+    def set_timeout(timeout)
+      @timeout = timeout
+    end
+  
+    # Retrieves the timeout duration of the HTTP request.
+    # @returns [Integer] Timeout in milliseconds.
+    def get_timeout
+      @timeout
+    end
+  
+    # Sets the HTTP headers for the request.
+    # @param headers [Hash] A record of key-value pairs representing the HTTP headers.
+    def set_headers(headers)
+      @headers = headers
+    end
+  
+    # Retrieves the HTTP headers of the request.
+    # @returns [Hash] A record of key-value pairs representing the HTTP headers.
+    def get_headers
+      @headers
+    end
+  
+    # Sets the development mode status for the request.
+    # @param is_development_mode [Boolean] Boolean flag indicating if the request is in development mode.
+    def set_development_mode(is_development_mode)
+      @is_development_mode = is_development_mode
+    end
+  
+    # Retrieves the development mode status of the request.
+    # @returns [Boolean] Boolean indicating if the request is in development mode.
+    def get_development_mode
+      @is_development_mode
+    end
+  end
+  
+  

data/lib/vwo/packages/network_layer/models/request_model.rb

@@ -0,0 +1,145 @@
+# Copyright 2025 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.
+
+class RequestModel
+    attr_accessor :url, :method, :path, :query, :timeout, :body, :headers, :scheme, :port
+  
+    def initialize(url, method = 'GET', path = '', query = {}, body = {}, headers = {}, scheme = 'https', port = nil)
+      @url = scheme + '://' + url
+      @method = method
+      @path = path
+      @query = query
+      @timeout = 5000
+      @body = body
+      @headers = headers
+      @scheme = scheme
+      @port = port
+      if !@port.nil?
+        @url = @url + ':' + @port.to_s
+      end
+      parse_options
+      self
+    end
+  
+    def parse_options
+      hostname, collection_prefix = @url.split('/')
+      
+      # Process body if present
+      if !@body.nil?
+        @headers['Content-Type'] = 'application/json'
+        @headers['Content-Length'] = @body.to_json.bytesize.to_s
+      end
+
+      # Process path and query parameters
+      if !@path.nil?
+        query_string = @query.map { |k,v| "#{k}=#{v}" }.join('&')
+        @path = query_string.empty? ? @path : "#{@path}?#{query_string}"
+      end
+
+      # Add collection prefix if present
+      @path = "#{collection_prefix}#{@path}" if collection_prefix
+      
+      # Add timeout
+      @timeout = @timeout if @timeout
+    end
+
+    def set_timeout(timeout)
+      @timeout = timeout
+    end
+
+    def get_timeout
+      @timeout
+    end
+
+    def set_body(body)
+      @body = body
+    end
+
+    def get_body
+      @body
+    end
+
+    def set_headers(headers)
+      @headers = headers
+    end
+
+    def get_headers
+      @headers
+    end
+
+    def set_scheme(scheme)
+      @scheme = scheme
+    end
+
+    def get_scheme
+      @scheme
+    end
+
+    def set_port(port)
+      @port = port
+    end
+
+    def get_port
+      @port
+    end
+
+    def set_path(path)
+      @path = path
+    end
+
+    def get_path
+      @path
+    end
+
+    def set_query(query)
+      @query = query
+    end
+
+    def get_query
+      @query
+    end
+
+    def set_url(url)
+      @url = url
+    end
+
+    def get_url
+      @url
+    end
+
+    def set_method(method)
+      @method = method
+    end
+
+    def get_method
+      @method
+    end
+
+    def set_query(query)
+      @query = query
+    end
+
+    def get_query
+      @query
+    end
+
+    def set_url(url)
+      @url = url
+    end
+
+    def get_url
+      @url
+    end 
+  end
+  

data/lib/vwo/packages/network_layer/models/response_model.rb

@@ -0,0 +1,45 @@
+# Copyright 2025 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.
+
+class ResponseModel
+    attr_accessor :status_code, :error, :headers, :data
+  
+    def initialize
+      @status_code = nil
+      @error = nil
+      @headers = {}
+      @data = nil
+    end
+  
+    def set_status_code(code)
+      @status_code = code
+    end
+  
+    def set_headers(headers)
+      @headers = headers
+    end
+  
+    def set_data(data)
+      @data = data
+    end
+
+    def get_data
+      @data
+    end
+  
+    def set_error(error)
+      @error = error
+    end
+  end
+  

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

@@ -0,0 +1,76 @@
+# Copyright 2025 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_relative '../evaluators/segment_evaluator'
+require_relative '../../../models/settings/settings_model'
+require_relative '../../../utils/gateway_service_util'
+require_relative '../../../enums/url_enum'
+require_relative '../../../services/logger_service'
+require_relative '../../../models/user/context_model'
+require_relative '../../../models/campaign/feature_model'
+require_relative '../../../models/user/context_vwo_model'
+require_relative '../../../services/settings_service'
+require_relative '../../../utils/data_type_util'
+require_relative '../../../enums/log_level_enum'
+class SegmentationManager
+  @@instance = nil # Singleton instance
+
+  attr_accessor :evaluator
+
+  def self.instance
+    @@instance ||= SegmentationManager.new
+  end
+
+  def initialize
+    @evaluator = SegmentEvaluator.new
+  end
+
+  def attach_evaluator(evaluator = nil)
+    @evaluator = evaluator || SegmentEvaluator.new
+  end
+
+  # Set the context for the segmentation evaluator
+  # @param settings [SettingsModel] The settings model
+  # @param feature [FeatureModel] The feature model
+  # @param context [ContextModel] The context model
+  def set_contextual_data(settings, feature, context)
+    attach_evaluator
+    @evaluator.settings = settings
+    @evaluator.context = context
+    @evaluator.feature = feature
+
+    # If both user agent and IP address are null, avoid making a gateway service call
+    return if context&.get_user_agent.nil? && context&.get_ip_address.nil?
+
+    if feature.get_is_gateway_service_required
+      if SettingsService.instance.is_gateway_service_provided && (context.get_vwo.nil?)
+        query_params = {}
+        query_params['userAgent'] = context.get_user_agent if context&.get_user_agent
+        query_params['ipAddress'] = context.get_ip_address if context&.get_ip_address
+
+        begin
+          params = get_query_params(query_params)
+          vwo_data = get_from_gateway_service(params, UrlEnum::GET_USER_DATA)
+          context.set_vwo(ContextVWOModel.new.model_from_dictionary(vwo_data))
+        rescue StandardError => e
+          LoggerService.log(LogLevelEnum::ERROR, "Error in setting contextual data for segmentation. Got error: #{e.message}", nil)
+        end
+      end
+    end
+  end
+
+  def validate_segmentation(dsl, properties)
+    @evaluator.is_segmentation_valid(dsl, properties)
+  end
+end

data/lib/vwo/packages/segmentation_evaluator/enums/segment_operand_regex_enum.rb

@@ -0,0 +1,29 @@
+# Copyright 2025 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.
+
+module SegmentOperandRegexEnum
+    LOWER = '^lower'
+    LOWER_MATCH = '^lower\\((.*)\\)'
+    WILDCARD = '^wildcard'
+    WILDCARD_MATCH = '^wildcard\\((.*)\\)'
+    REGEX = '^regex'
+    REGEX_MATCH = '^regex\\((.*)\\)'
+    STARTING_STAR = '^\\*'
+    ENDING_STAR = '\\*$'
+    GREATER_THAN_MATCH = '^gt\\((\\d+\\.?\\d*|\\.\\d+)\\)'
+    GREATER_THAN_EQUAL_TO_MATCH = '^gte\\((\\d+\\.?\\d*|\\.\\d+)\\)'
+    LESS_THAN_MATCH = '^lt\\((\\d+\\.?\\d*|\\.\\d+)\\)'
+    LESS_THAN_EQUAL_TO_MATCH = '^lte\\((\\d+\\.?\\d*|\\.\\d+)\\)'
+  end
+  

data/lib/vwo/packages/segmentation_evaluator/enums/segment_operand_value_enum.rb

@@ -0,0 +1,26 @@
+# Copyright 2025 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.
+
+module SegmentOperandValueEnum
+    LOWER_VALUE = 1
+    STARTING_ENDING_STAR_VALUE = 2
+    STARTING_STAR_VALUE = 3
+    ENDING_STAR_VALUE = 4
+    REGEX_VALUE = 5
+    EQUAL_VALUE = 6
+    GREATER_THAN_VALUE = 7
+    GREATER_THAN_EQUAL_TO_VALUE = 8
+    LESS_THAN_VALUE = 9
+    LESS_THAN_EQUAL_TO_VALUE = 10
+  end

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

@@ -0,0 +1,30 @@
+# Copyright 2025 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.
+
+module SegmentOperatorValueEnum
+    AND = 'and'
+    NOT = 'not'
+    OR = 'or'
+    CUSTOM_VARIABLE = 'custom_variable'
+    USER = 'user'
+    COUNTRY = 'country'
+    REGION = 'region'
+    CITY = 'city'
+    OPERATING_SYSTEM = 'os'
+    DEVICE_TYPE = 'device_type'
+    DEVICE = 'device'
+    BROWSER_AGENT = 'browser_string'
+    UA = 'ua'
+    FEATURE_ID = 'featureId'
+  end

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

@@ -0,0 +1,210 @@
+# Copyright 2025 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 '../../../decorators/storage_decorator'
+require_relative '../../../models/settings/settings_model'
+require_relative '../../../models/user/context_model'
+require_relative '../../../models/campaign/feature_model'
+require_relative '../../../services/storage_service'
+require_relative '../../../services/logger_service'
+require_relative '../enums/segment_operator_value_enum'
+require_relative '../core/segmentation_manager'
+require_relative '../utils/segment_util'
+require_relative './segment_operand_evaluator'
+require_relative '../../../enums/log_level_enum'
+class SegmentEvaluator
+  attr_accessor :context, :settings, :feature
+
+  def initialize(context = nil, settings = nil, feature = nil)
+    @context = context
+    @settings = settings
+    @feature = feature
+  end
+
+  # Validates if the segmentation defined in the DSL is applicable based on the provided properties.
+  # @param dsl [Hash] The DSL node to evaluate
+  # @param properties [Hash] The properties to evaluate the DSL against
+  # @return [Boolean] True if the segmentation is valid, false otherwise
+  def is_segmentation_valid(dsl, properties)
+    key_value = get_key_value(dsl)
+    return false unless key_value
+
+    operator = key_value[:key]
+    sub_dsl = key_value[:value]
+
+    case operator
+    when SegmentOperatorValueEnum::NOT
+      !is_segmentation_valid(sub_dsl, properties)
+    when SegmentOperatorValueEnum::AND
+      every(sub_dsl, properties)
+    when SegmentOperatorValueEnum::OR
+      some(sub_dsl, properties)
+    when SegmentOperatorValueEnum::CUSTOM_VARIABLE
+      SegmentOperandEvaluator.new.evaluate_custom_variable_dsl(sub_dsl, properties)
+    when SegmentOperatorValueEnum::USER
+      SegmentOperandEvaluator.new.evaluate_user_dsl(sub_dsl, properties)
+    when SegmentOperatorValueEnum::UA
+      SegmentOperandEvaluator.new.evaluate_user_agent_dsl(sub_dsl, @context)
+    else
+      false
+    end
+  end
+
+  # Evaluates if any of the DSL nodes are valid using the OR logic.
+  # @param dsl_nodes [Array<Hash>] The DSL nodes to evaluate
+  # @param custom_variables [Hash] The custom variables
+  # @return [Boolean] True if any of the DSL nodes are valid, false otherwise
+  def some(dsl_nodes, custom_variables)
+    ua_parser_map = {}
+    key_count = 0
+    is_ua_parser = false
+
+    dsl_nodes.each do |dsl|
+      dsl.each do |key, value|
+        if [SegmentOperatorValueEnum::OPERATING_SYSTEM, SegmentOperatorValueEnum::BROWSER_AGENT,
+            SegmentOperatorValueEnum::DEVICE_TYPE, SegmentOperatorValueEnum::DEVICE].include?(key)
+          is_ua_parser = true
+          ua_parser_map[key] ||= []
+          ua_parser_map[key] += Array(value).map(&:to_s)
+          key_count += 1
+        end
+
+        if key == SegmentOperatorValueEnum::FEATURE_ID
+          feature_id_object = dsl[key]
+          feature_id_key = feature_id_object.keys.first
+          feature_id_value = feature_id_object[feature_id_key]
+
+          if %w[on off].include?(feature_id_value)
+            feature = @settings.get_features.find { |f| f.get_id == feature_id_key.to_i }
+            if feature
+              feature_key = feature.get_key
+              result = check_in_user_storage(@settings, feature_key, @context)
+              return !result if feature_id_value == 'off'
+              return result
+            else
+              LoggerService.log(LogLevelEnum::ERROR, "Feature not found with featureIdKey: #{feature_id_key}", nil)
+              return nil
+            end
+          end
+        end
+      end
+
+      return check_user_agent_parser(ua_parser_map) if is_ua_parser && key_count == dsl_nodes.length
+      return true if is_segmentation_valid(dsl, custom_variables)
+    end
+
+    false
+  end
+
+  # Evaluates all DSL nodes using the AND logic.
+  # @param dsl_nodes [Array<Hash>] The DSL nodes to evaluate
+  # @param custom_variables [Hash] The custom variables
+  # @return [Boolean] True if all DSL nodes are valid, false otherwise
+  def every(dsl_nodes, custom_variables)
+    location_map = {}
+    dsl_nodes.each do |dsl|
+      if dsl.keys.any? { |key| [SegmentOperatorValueEnum::COUNTRY, SegmentOperatorValueEnum::REGION,
+                                SegmentOperatorValueEnum::CITY].include?(key) }
+        add_location_values_to_map(dsl, location_map)
+        return check_location_pre_segmentation(location_map) if location_map.keys.length == dsl_nodes.length
+        next
+      end
+      return false unless is_segmentation_valid(dsl, custom_variables)
+    end
+    true
+  end
+
+  # Adds the location values to the map
+  # @param dsl [Hash] The DSL node
+  # @param location_map [Hash] The location map
+  def add_location_values_to_map(dsl, location_map)
+    location_map[SegmentOperatorValueEnum::COUNTRY] = dsl[SegmentOperatorValueEnum::COUNTRY] if dsl.key?(SegmentOperatorValueEnum::COUNTRY)
+    location_map[SegmentOperatorValueEnum::REGION] = dsl[SegmentOperatorValueEnum::REGION] if dsl.key?(SegmentOperatorValueEnum::REGION)
+    location_map[SegmentOperatorValueEnum::CITY] = dsl[SegmentOperatorValueEnum::CITY] if dsl.key?(SegmentOperatorValueEnum::CITY)
+  end
+
+  # Checks if the location pre-segmentation is valid
+  # @param location_map [Hash] The location map
+  # @return [Boolean] True if the location pre-segmentation is valid, false otherwise
+  def check_location_pre_segmentation(location_map)
+    unless @context&.get_ip_address
+      LoggerService.log(LogLevelEnum::ERROR, 'To evaluate location pre Segment, please pass ipAddress in context object', nil)
+      return false
+    end
+    
+    unless @context&.get_vwo&.get_location
+      return false
+    end
+
+    values_match(location_map, @context.get_vwo.get_location)
+  end
+
+  # Checks if the user agent parser is valid
+  # @param ua_parser_map [Hash] The user agent parser map
+  # @return [Boolean] True if the user agent parser is valid, false otherwise
+  def check_user_agent_parser(ua_parser_map)
+    unless @context&.get_user_agent
+      LoggerService.log(LogLevelEnum::ERROR, 'To evaluate user agent related segments, please pass userAgent in context object', nil)
+      return false
+    end
+
+    unless @context&.get_vwo&.get_ua_info
+      return false
+    end
+
+    check_value_present(ua_parser_map, @context.get_vwo.get_ua_info)
+  end
+
+  # Checks if the feature key is present in the user's storage
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param feature_key [String] The key of the feature to check
+  # @param context [ContextModel] The context for the evaluation
+  # @return [Boolean] True if the feature key is present in the user's storage, false otherwise
+  def check_in_user_storage(settings, feature_key, context)
+    storage_service = StorageService.new
+    stored_data = StorageDecorator.new.get_feature_from_storage(feature_key, context, storage_service)
+    stored_data.is_a?(Hash) && !stored_data.empty?
+  end
+
+  # Checks if the expected values are present in the actual values
+  # @param expected_map [Hash] The expected values
+  # @param actual_map [Hash] The actual values
+  # @return [Boolean] True if the expected values are present in the actual values, false otherwise
+  def check_value_present(expected_map, actual_map)
+    actual_map.each do |key, actual_value|
+      next unless expected_map.key?(key)
+
+      expected_values = expected_map[key].map(&:downcase)
+
+      return true if expected_values.any? { |val| val.start_with?('wildcard(') && val.end_with?(')') && actual_value.match?(Regexp.new(val[9..-2].gsub('*', '.*'), Regexp::IGNORECASE)) }
+      return true if expected_values.include?(actual_value.downcase)
+    end
+    false
+  end
+
+  # Checks if the expected location values match the user's location
+  # @param expected_location_map [Hash] The expected location values
+  # @param user_location [Hash] The user's location values
+  # @return [Boolean] True if the expected location values match the user's location, false otherwise
+  def values_match(expected_location_map, user_location)
+    expected_location_map.all? { |key, value| normalize_value(value) == normalize_value(user_location[key]) }
+  end
+
+  def normalize_value(value)
+    return nil if value.nil?
+
+    value.to_s.gsub(/^"|"$/, '').strip
+  end
+end