quonfig 0.0.11 → 0.0.13

data/lib/quonfig/evaluator.rb

@@ -51,6 +51,8 @@ module Quonfig
     OP_PROP_SEMVER_GREATER_THAN        = 'PROP_SEMVER_GREATER_THAN'
     OP_IN_SEG                          = 'IN_SEG'
     OP_NOT_IN_SEG                      = 'NOT_IN_SEG'
+    OP_IS_PRESENT                      = 'IS_PRESENT'
+    OP_IS_NOT_PRESENT                  = 'IS_NOT_PRESENT'
 
     MAGIC_CURRENT_TIME_PROPS = %w[quonfig.current-time prefab.current-time reforge.current-time].freeze
 
@@ -99,8 +101,10 @@ module Quonfig
 
       keys.each do |k|
         return hash[k] if hash.key?(k)
+
         sk = k.to_s
         return hash[sk] if hash.key?(sk)
+
         sym = k.to_sym
         return hash[sym] if hash.key?(sym)
       end
@@ -147,7 +151,7 @@ module Quonfig
     # Faithful port of sdk-node/src/operators.ts evaluateCriterion. Matches
     # context-exists / missing-context semantics (e.g. PROP_IS_NOT_ONE_OF is
     # true when context is missing).
-    def evaluate_criterion(criterion, context, config)
+    def evaluate_criterion(criterion, context, _config)
       property_name = hget(criterion, :propertyName) || ''
       operator = hget(criterion, :operator)
       match_value = hget(criterion, :valueToMatch)
@@ -156,10 +160,10 @@ module Quonfig
 
       case operator
       when OP_NOT_SET, nil
-        return false
+        false
 
       when OP_ALWAYS_TRUE
-        return true
+        true
 
       when OP_PROP_IS_ONE_OF, OP_PROP_IS_NOT_ONE_OF
         if context_exists && match_value
@@ -170,7 +174,7 @@ module Quonfig
             return match_found == (operator == OP_PROP_IS_ONE_OF)
           end
         end
-        return operator == OP_PROP_IS_NOT_ONE_OF
+        operator == OP_PROP_IS_NOT_ONE_OF
 
       when OP_PROP_STARTS_WITH_ONE_OF, OP_PROP_DOES_NOT_START_WITH_ONE_OF
         if context_exists && match_value
@@ -181,7 +185,7 @@ module Quonfig
             return match_found == (operator == OP_PROP_STARTS_WITH_ONE_OF)
           end
         end
-        return operator == OP_PROP_DOES_NOT_START_WITH_ONE_OF
+        operator == OP_PROP_DOES_NOT_START_WITH_ONE_OF
 
       when OP_PROP_ENDS_WITH_ONE_OF, OP_PROP_DOES_NOT_END_WITH_ONE_OF
         if context_exists && match_value
@@ -192,7 +196,7 @@ module Quonfig
             return match_found == (operator == OP_PROP_ENDS_WITH_ONE_OF)
           end
         end
-        return operator == OP_PROP_DOES_NOT_END_WITH_ONE_OF
+        operator == OP_PROP_DOES_NOT_END_WITH_ONE_OF
 
       when OP_PROP_CONTAINS_ONE_OF, OP_PROP_DOES_NOT_CONTAIN_ONE_OF
         if context_exists && match_value
@@ -203,7 +207,7 @@ module Quonfig
             return match_found == (operator == OP_PROP_CONTAINS_ONE_OF)
           end
         end
-        return operator == OP_PROP_DOES_NOT_CONTAIN_ONE_OF
+        operator == OP_PROP_DOES_NOT_CONTAIN_ONE_OF
 
       when OP_PROP_MATCHES, OP_PROP_DOES_NOT_MATCH
         mv = hget(match_value, :value)
@@ -216,7 +220,7 @@ module Quonfig
             return false
           end
         end
-        return false
+        false
 
       when OP_HIERARCHICAL_MATCH
         if context_exists && match_value
@@ -224,7 +228,7 @@ module Quonfig
           mv = to_s_nil(hget(match_value, :value))
           return cv.start_with?(mv)
         end
-        return false
+        false
 
       when OP_IN_INT_RANGE
         if context_exists && match_value
@@ -232,7 +236,7 @@ module Quonfig
           num_val = to_float(context_value)
           return num_val >= start_v && num_val < end_v unless num_val.nil?
         end
-        return false
+        false
 
       when OP_PROP_GREATER_THAN, OP_PROP_GREATER_THAN_OR_EQUAL,
            OP_PROP_LESS_THAN, OP_PROP_LESS_THAN_OR_EQUAL
@@ -244,13 +248,13 @@ module Quonfig
           return false if cmp.nil?
 
           case operator
-          when OP_PROP_GREATER_THAN          then return cmp > 0
+          when OP_PROP_GREATER_THAN          then return cmp.positive?
           when OP_PROP_GREATER_THAN_OR_EQUAL then return cmp >= 0
-          when OP_PROP_LESS_THAN             then return cmp < 0
+          when OP_PROP_LESS_THAN             then return cmp.negative?
           when OP_PROP_LESS_THAN_OR_EQUAL    then return cmp <= 0
           end
         end
-        return false
+        false
 
       when OP_PROP_BEFORE, OP_PROP_AFTER
         if context_exists && match_value
@@ -260,7 +264,7 @@ module Quonfig
             return operator == OP_PROP_BEFORE ? context_millis < match_millis : context_millis > match_millis
           end
         end
-        return false
+        false
 
       when OP_PROP_SEMVER_LESS_THAN, OP_PROP_SEMVER_EQUAL, OP_PROP_SEMVER_GREATER_THAN
         mv = hget(match_value, :value)
@@ -270,13 +274,24 @@ module Quonfig
           if sv_ctx && sv_mv
             cmp = (sv_ctx <=> sv_mv)
             case operator
-            when OP_PROP_SEMVER_LESS_THAN    then return cmp < 0
-            when OP_PROP_SEMVER_EQUAL        then return cmp == 0
-            when OP_PROP_SEMVER_GREATER_THAN then return cmp > 0
+            when OP_PROP_SEMVER_LESS_THAN    then return cmp.negative?
+            when OP_PROP_SEMVER_EQUAL        then return cmp.zero?
+            when OP_PROP_SEMVER_GREATER_THAN then return cmp.positive?
             end
           end
         end
-        return false
+        false
+
+      when OP_IS_PRESENT, OP_IS_NOT_PRESENT
+        # Presence is type-agnostic: empty string "", 0, and false are all
+        # PRESENT. Only nil / missing key (incl. nested) is NOT present.
+        # `lookup_context` already returns context_exists=true iff the
+        # resolved value is non-nil — exactly the semantic we need. Do not
+        # use ActiveSupport's #present? / #blank? here: they treat "" and
+        # false as blank, which is the wrong behaviour for this operator.
+        return context_exists if operator == OP_IS_PRESENT
+
+        !context_exists
 
       when OP_IN_SEG, OP_NOT_IN_SEG
         if match_value
@@ -286,21 +301,17 @@ module Quonfig
 
           return result == (operator == OP_IN_SEG)
         end
-        return operator == OP_NOT_IN_SEG
+        operator == OP_NOT_IN_SEG
 
       else
-        return false
+        false
       end
     end
 
     def lookup_context(context, property_name)
-      if MAGIC_CURRENT_TIME_PROPS.include?(property_name)
-        return [(Time.now.utc.to_f * 1000).to_i, true]
-      end
+      return [(Time.now.utc.to_f * 1000).to_i, true] if MAGIC_CURRENT_TIME_PROPS.include?(property_name)
 
-      if property_name.nil? || property_name.empty?
-        return [nil, false]
-      end
+      return [nil, false] if property_name.nil? || property_name.empty?
 
       value = context.get(property_name)
       [value, !value.nil?]
@@ -362,8 +373,7 @@ module Quonfig
       return v.to_f if v.is_a?(Numeric)
       return nil unless v.is_a?(String)
 
-      f = Float(v, exception: false)
-      f
+      Float(v, exception: false)
     end
 
     def compare_numbers(a, b)
@@ -375,7 +385,7 @@ module Quonfig
     end
 
     def extract_int_range(value_hash)
-      min = -(2**53) + 1  # approx Number.MIN_SAFE_INTEGER
+      min = -(2**53) + 1 # approx Number.MIN_SAFE_INTEGER
       max = (2**53) - 1
       raw = hget(value_hash, :value)
       return [min, max] unless raw.is_a?(Hash)
@@ -397,10 +407,8 @@ module Quonfig
         rescue ArgumentError, TypeError
           # not a date; try integer
         end
-        n = Integer(val, exception: false)
-        n
-      else
-        nil
+        Integer(val, exception: false)
+
       end
     end
   end
@@ -437,7 +445,7 @@ module Quonfig
     # of a config with no targeting rules matched, otherwise TARGETING_MATCH.
     def wire_reason
       return REASON_SPLIT unless @weighted_value_index.nil?
-      return REASON_STATIC if @rule_index == 0 && !EvalResult.send(:targeting_rules?, @config)
+      return REASON_STATIC if @rule_index.zero? && !EvalResult.send(:targeting_rules?, @config)
 
       REASON_TARGETING_MATCH
     end
@@ -494,13 +502,15 @@ module Quonfig
     def unwrapped_value
       raw = raw_value
       case type
-      when 'bool'        then !!raw
+      when 'bool' then !!raw
       when 'int'
         return raw if raw.is_a?(Integer)
         return raw.to_i if raw.is_a?(Numeric)
+
         Integer(raw.to_s, 10)
       when 'double'
         return raw.to_f if raw.is_a?(Numeric)
+
         Float(raw.to_s)
       when 'string'      then raw.to_s
       when 'string_list' then raw.is_a?(Array) ? raw.map(&:to_s) : []
@@ -535,8 +545,8 @@ module Quonfig
         (seconds * 1000).round
       when Hash
         secs = (raw['seconds'] || raw[:seconds] || 0).to_f
-        nanos = (raw['nanos']   || raw[:nanos]   || 0).to_f
-        (secs * 1000 + nanos / 1_000_000.0).round
+        nanos = (raw['nanos'] || raw[:nanos] || 0).to_f
+        ((secs * 1000) + (nanos / 1_000_000.0)).round
       else
         raw
       end

data/lib/quonfig/fixed_size_hash.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Quonfig
   class FixedSizeHash < Hash
     def initialize(max_size)

data/lib/quonfig/http_connection.rb

@@ -18,9 +18,7 @@ module Quonfig
       @sdk_key = sdk_key
     end
 
-    def uri
-      @uri
-    end
+    attr_reader :uri
 
     def get(path, headers = {})
       connection(headers).get(path)
@@ -40,7 +38,7 @@ module Quonfig
     private
 
     def auth_header
-      'Basic ' + Base64.strict_encode64("1:#{@sdk_key}")
+      "Basic #{Base64.strict_encode64("1:#{@sdk_key}")}"
     end
   end
 end

data/lib/quonfig/internal_logger.rb

@@ -4,11 +4,24 @@ module Quonfig
   # Internal logger for the Quonfig SDK
   # Uses SemanticLogger if available, falls back to stdlib Logger
   class InternalLogger
-    def initialize(klass)
+    # Optional, host-app-supplied logger. When set (typically via
+    # Quonfig::Client.new(logger:)), all InternalLogger instances route
+    # writes to it instead of their default backend. Must duck-type as a
+    # stdlib Logger (responds to debug/info/warn/error). Missing levels
+    # are silently dropped.
+    class << self
+      attr_accessor :user_logger
+    end
+
+    def initialize(klass, logger: nil)
       @klass = klass
       @level_sym = nil # Track the symbol level for consistency
+      @injected_logger = logger
 
-      if defined?(SemanticLogger)
+      if @injected_logger
+        @logger = @injected_logger
+        @using_semantic = false
+      elsif defined?(SemanticLogger)
         @logger = create_semantic_logger
         @using_semantic = true
       else
@@ -51,13 +64,13 @@ module Quonfig
       else
         # Return the symbol level we tracked, or map from Logger constant
         @level_sym || case @logger.level
-                     when Logger::DEBUG then :debug
-                     when Logger::INFO then :info
-                     when Logger::WARN then :warn
-                     when Logger::ERROR then :error
-                     when Logger::FATAL then :fatal
-                     else :warn
-                     end
+                      when Logger::DEBUG then :debug
+                      when Logger::INFO then :info
+                      when Logger::WARN then :warn
+                      when Logger::ERROR then :error
+                      when Logger::FATAL then :fatal
+                      else :warn
+                      end
       end
     end
 
@@ -69,14 +82,16 @@ module Quonfig
         @level_sym = new_level
 
         # Map symbol to Logger constant
-        @logger.level = case new_level
-                       when :trace, :debug then Logger::DEBUG
-                       when :info then Logger::INFO
-                       when :warn then Logger::WARN
-                       when :error then Logger::ERROR
-                       when :fatal then Logger::FATAL
-                       else Logger::WARN
-                       end
+        next_level = case new_level
+                     when :trace, :debug then Logger::DEBUG
+                     when :info then Logger::INFO
+                     when :warn then Logger::WARN
+                     when :error then Logger::ERROR
+                     when :fatal then Logger::FATAL
+                     else Logger::WARN
+                     end
+
+        @logger.level = next_level if @logger.respond_to?(:level=)
       end
     end
 
@@ -99,9 +114,10 @@ module Quonfig
       class << logger
         def log(log, message = nil, progname = nil, &block)
           return if recurse_check[local_log_id]
+
           recurse_check[local_log_id] = true
           begin
-            super(log, message, progname, &block)
+            super
           ensure
             recurse_check[local_log_id] = false
           end
@@ -132,19 +148,19 @@ module Quonfig
       @level_sym = env_log_level || default_level_sym
 
       logger.level = case @level_sym
-                    when :trace, :debug then Logger::DEBUG
-                    when :info then Logger::INFO
-                    when :warn then Logger::WARN
-                    when :error then Logger::ERROR
-                    when :fatal then Logger::FATAL
-                    else Logger::WARN
-                    end
+                     when :trace, :debug then Logger::DEBUG
+                     when :info then Logger::INFO
+                     when :warn then Logger::WARN
+                     when :error then Logger::ERROR
+                     when :fatal then Logger::FATAL
+                     else Logger::WARN
+                     end
       logger.progname = @klass.to_s
 
       # Use a custom formatter that mimics SemanticLogger format
       # SemanticLogger format: "ClassName -- Message"
       # This helps tests that expect SemanticLogger-style output
-      logger.formatter = proc do |severity, datetime, progname, msg|
+      logger.formatter = proc do |_severity, _datetime, progname, msg|
         "#{progname} -- #{msg}\n"
       end
 
@@ -152,20 +168,40 @@ module Quonfig
     end
 
     def env_log_level
-      level_str = ENV['QUONFIG_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL']
+      level_str = ENV.fetch('QUONFIG_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL', nil)
       level_str&.downcase&.to_sym
     end
 
     def log_message(level, message, &block)
+      override = Quonfig::InternalLogger.user_logger
+      if override
+        write_to_user_logger(override, level, message, &block)
+        return
+      end
+
       if @using_semantic
         @logger.send(level, message, &block)
       else
         # stdlib Logger doesn't have trace
         level = :debug if level == :trace
+        return unless @logger.respond_to?(level)
+
         @logger.send(level, message || block&.call)
       end
     end
 
+    # Route a message to a host-app-supplied logger that duck-types as a
+    # stdlib Logger. Missing levels degrade gracefully (trace -> debug;
+    # otherwise a no-op). The class name is prepended to keep parity with
+    # the SemanticLogger / stdlib formatter output.
+    def write_to_user_logger(target, level, message, &block)
+      level = :debug if level == :trace && !target.respond_to?(:trace)
+      return unless target.respond_to?(level)
+
+      msg = message || block&.call
+      target.public_send(level, "#{@klass} -- #{msg}")
+    end
+
     def instances
       @@instances ||= []
     end

data/lib/quonfig/murmer3.rb

@@ -30,10 +30,10 @@ class Murmur3
     numbers = str.unpack('V*C*')
     tailn = str.length % 4
     tail = numbers.slice!(numbers.size - tailn, tailn)
-    for k1 in numbers
+    numbers.each do |k1|
       h1 ^= murmur3_32__mmix(k1)
       h1 = murmur3_32_rotl(h1, 13)
-      h1 = (h1 * 5 + 0xe6546b64) & MASK32
+      h1 = ((h1 * 5) + 0xe6546b64) & MASK32
     end
 
     unless tail.empty?

data/lib/quonfig/options.rb

@@ -5,23 +5,8 @@ require 'uri'
 module Quonfig
   # Options passed to Quonfig::Client at construction time.
   class Options
-    attr_reader :sdk_key
-    attr_reader :environment
-    attr_reader :api_urls
-    attr_reader :sse_api_urls
-    attr_reader :telemetry_destination
-    attr_reader :config_api_urls
-    attr_reader :on_no_default
-    attr_reader :initialization_timeout_sec
-    attr_reader :on_init_failure
-    attr_reader :collect_sync_interval
-    attr_reader :datadir
-    attr_reader :enable_sse
-    attr_reader :enable_polling
-    attr_reader :poll_interval
-    attr_reader :global_context
-    attr_reader :logger_key
-    attr_reader :enable_quonfig_user_context
+    attr_reader :sdk_key, :environment, :api_urls, :sse_api_urls, :telemetry_destination, :config_api_urls,
+                :on_no_default, :initialization_timeout_sec, :on_init_failure, :collect_sync_interval, :datadir, :enable_sse, :enable_polling, :poll_interval, :global_context, :logger_key, :logger, :enable_quonfig_user_context
     attr_accessor :is_fork
 
     module ON_INITIALIZATION_FAILURE
@@ -46,13 +31,13 @@ module Quonfig
     # and no explicit api_urls are provided). Mirrors derive_api_urls(DEFAULT_DOMAIN).
     DEFAULT_API_URLS = [
       'https://primary.quonfig.com',
-      'https://secondary.quonfig.com',
+      'https://secondary.quonfig.com'
     ].freeze
 
     # Resolve the active domain. Reads QUONFIG_DOMAIN; falls back to
     # DEFAULT_DOMAIN. Mirrors `cli/src/util/domain-urls.ts#getDomain`.
     def self.domain
-      env = ENV['QUONFIG_DOMAIN']
+      env = ENV.fetch('QUONFIG_DOMAIN', nil)
       env && !env.empty? ? env : DEFAULT_DOMAIN
     end
 
@@ -62,7 +47,7 @@ module Quonfig
     def self.derive_api_urls(domain)
       [
         "https://primary.#{domain}",
-        "https://secondary.#{domain}",
+        "https://secondary.#{domain}"
       ]
     end
 
@@ -84,12 +69,62 @@ module Quonfig
       uri.to_s
     end
 
-    private def init(
+    def initialize(options = {})
+      init(**options)
+    end
+
+    # In datadir mode the SDK evaluates config from a local workspace and does
+    # not connect to the delivery service.
+    def local_only?
+      !@datadir.nil?
+    end
+
+    def datadir?
+      !@datadir.nil?
+    end
+
+    def collect_max_paths
+      return 0 unless telemetry_allowed?(true)
+
+      @collect_max_paths
+    end
+
+    def collect_max_shapes
+      return 0 unless telemetry_allowed?(@collect_shapes)
+
+      @collect_max_shapes
+    end
+
+    def collect_max_example_contexts
+      return 0 unless telemetry_allowed?(@collect_example_contexts)
+
+      @collect_max_example_contexts
+    end
+
+    def collect_max_evaluation_summaries
+      return 0 unless telemetry_allowed?(@collect_evaluation_summaries)
+
+      @collect_max_evaluation_summaries
+    end
+
+    def sdk_key_id
+      @sdk_key&.split('-')&.first
+    end
+
+    def for_fork
+      clone = self.clone
+      clone.is_fork = true
+      clone
+    end
+
+    private
+
+    def init(
       api_urls: nil,
       telemetry_url: nil,
-      sdk_key: ENV['QUONFIG_BACKEND_SDK_KEY'],
-      environment: ENV['QUONFIG_ENVIRONMENT'],
-      datadir: ENV['QUONFIG_DIR'],
+      sdk_key: ENV.fetch('QUONFIG_BACKEND_SDK_KEY', nil),
+      environment: ENV.fetch('QUONFIG_ENVIRONMENT', nil),
+      datadir: ENV.fetch('QUONFIG_DIR', nil),
       enable_sse: true,
       enable_polling: true,
       poll_interval: 60,
@@ -105,6 +140,7 @@ module Quonfig
       allow_telemetry_in_local_mode: false,
       global_context: {},
       logger_key: nil,
+      logger: nil,
       enable_quonfig_user_context: false
     )
       @sdk_key = sdk_key
@@ -125,6 +161,7 @@ module Quonfig
       @is_fork = false
       @global_context = global_context
       @logger_key = logger_key
+      @logger = logger
       @enable_quonfig_user_context = enable_quonfig_user_context
 
       # defaults that may be overridden by context_upload_mode
@@ -140,7 +177,7 @@ module Quonfig
       domain = Quonfig::Options.domain
 
       @api_urls = Array(api_urls || Quonfig::Options.derive_api_urls(domain))
-                    .map { |url| remove_trailing_slash(url) }
+                  .map { |url| remove_trailing_slash(url) }
 
       @sse_api_urls = @api_urls.map { |url| Quonfig::Options.derive_stream_url(url) }
       @config_api_urls = @api_urls
@@ -163,56 +200,6 @@ module Quonfig
       end
     end
 
-    def initialize(options = {})
-      init(**options)
-    end
-
-    # In datadir mode the SDK evaluates config from a local workspace and does
-    # not connect to the delivery service.
-    def local_only?
-      !@datadir.nil?
-    end
-
-    def datadir?
-      !@datadir.nil?
-    end
-
-    def collect_max_paths
-      return 0 unless telemetry_allowed?(true)
-
-      @collect_max_paths
-    end
-
-    def collect_max_shapes
-      return 0 unless telemetry_allowed?(@collect_shapes)
-
-      @collect_max_shapes
-    end
-
-    def collect_max_example_contexts
-      return 0 unless telemetry_allowed?(@collect_example_contexts)
-
-      @collect_max_example_contexts
-    end
-
-    def collect_max_evaluation_summaries
-      return 0 unless telemetry_allowed?(@collect_evaluation_summaries)
-
-      @collect_max_evaluation_summaries
-    end
-
-    def sdk_key_id
-      @sdk_key&.split('-')&.first
-    end
-
-    def for_fork
-      clone = self.clone
-      clone.is_fork = true
-      clone
-    end
-
-    private
-
     def telemetry_allowed?(option)
       option && (!local_only? || @allow_telemetry_in_local_mode)
     end

data/lib/quonfig/periodic_sync.rb

@@ -5,7 +5,7 @@ module Quonfig
     LOG = Quonfig::InternalLogger.new(self)
 
     def sync
-      return if @data.size.zero?
+      return if @data.empty?
 
       LOG.debug "Syncing #{@data.size} items"
 

data/lib/quonfig/quonfig.rb

@@ -51,8 +51,8 @@ module Quonfig
   end
 
   def self.ensure_initialized(key = nil)
-    if !defined?(@singleton) || @singleton.nil?
-      raise Quonfig::Errors::UninitializedError.new(key)
-    end
+    return unless !defined?(@singleton) || @singleton.nil?
+
+    raise Quonfig::Errors::UninitializedError, key
   end
 end

data/lib/quonfig/reason.rb

@@ -20,9 +20,10 @@ module Quonfig
     module_function
 
     def compute(config:, conditional_value:, weighted_value_index: nil)
-      return SPLIT if weighted_value_index && weighted_value_index.positive?
+      return SPLIT if weighted_value_index&.positive?
       return RULE_MATCH if targeting_rules?(config)
       return RULE_MATCH if non_always_true_criteria?(conditional_value)
+
       DEFAULT
     end