quonfig 1.7.2 → 1.9.0

data/lib/quonfig/evaluator.rb

@@ -54,6 +54,16 @@ module Quonfig
     OP_IS_PRESENT                      = 'IS_PRESENT'
     OP_IS_NOT_PRESENT                  = 'IS_NOT_PRESENT'
 
+    MAX_SAFE_INTEGER = (2**53) - 1
+
+    # Timestamp grammar for PROP_BEFORE / PROP_AFTER; see #date_to_millis.
+    INTEGER_STRING = /\A-?[0-9]+\z/
+    RFC3339_TIMESTAMP = /
+      \A(?<y>[0-9]{4})-(?<mo>[0-9]{2})-(?<d>[0-9]{2})
+      T(?<h>[0-9]{2}):(?<mi>[0-9]{2}):(?<s>[0-9]{2})(?:\.(?<frac>[0-9]+))?
+      (?:Z|(?<sign>[+-])(?<oh>[0-9]{2}):(?<om>[0-9]{2}))\z
+    /x
+
     MAGIC_CURRENT_TIME_PROPS = %w[quonfig.current-time prefab.current-time reforge.current-time].freeze
 
     # PROP_MATCHES / PROP_DOES_NOT_MATCH match timeout (qfg-goi1.2.11). Ruby
@@ -282,8 +292,8 @@ module Quonfig
       when OP_PROP_SEMVER_LESS_THAN, OP_PROP_SEMVER_EQUAL, OP_PROP_SEMVER_GREATER_THAN
         mv = hget(match_value, :value)
         if context_exists && context_value.is_a?(String) && mv.is_a?(String)
-          sv_ctx = SemanticVersion.parse_quietly(context_value)
-          sv_mv  = SemanticVersion.parse_quietly(mv)
+          sv_ctx = SemanticVersion.parse_quietly(context_value, allow_abbreviated: true)
+          sv_mv  = SemanticVersion.parse_quietly(mv, allow_abbreviated: true)
           if sv_ctx && sv_mv
             cmp = (sv_ctx <=> sv_mv)
             case operator
@@ -356,12 +366,27 @@ module Quonfig
 
     # --- Type coercion helpers ----------------------------------------
 
+    # Canonical string form (qfg-goi1.5 R1) for *_ONE_OF, the string
+    # operators and HIERARCHICAL_MATCH: strings as-is, booleans as
+    # "true"/"false", and an integral number below 2^53 as plain digits
+    # whatever its runtime type, so 1.0 is "1" and 5e9 is "5000000000"
+    # (Float#to_s would give "1.0" and "5.0e9").
     def to_s_nil(v)
       return '' if v.nil?
+      return v if v.is_a?(String)
+      return canonical_number(v) if v.is_a?(Numeric) && !v.is_a?(Integer)
 
       v.to_s
     end
 
+    def canonical_number(v)
+      return v.to_s unless v.real?
+      return v.to_s if v.respond_to?(:finite?) && !v.finite?
+      return v.to_s unless v == v.truncate && v.abs <= MAX_SAFE_INTEGER
+
+      v.to_i.to_s
+    end
+
     def to_string_slice(v)
       return [] if v.nil?
       return v.map { |i| to_s_nil(i) } if v.is_a?(Array)
@@ -414,21 +439,43 @@ module Quonfig
       [start_v || min, end_v || max]
     end
 
+    # The ONE timestamp grammar for PROP_BEFORE / PROP_AFTER (qfg-goi1.5 R5),
+    # applied to both the context value and the criterion: a number (epoch
+    # ms, truncated), an all-digit string (epoch ms), or RFC3339 with an
+    # uppercase T and a Z or numeric offset (fractional seconds allowed,
+    # truncated to ms). Date-only, offset-less and free-form strings are not
+    # timestamps and never match. This replaces DateTime.parse, which read
+    # any of those (offset-less as UTC).
     def date_to_millis(val)
       case val
-      when Integer, Float
-        val.to_i
+      when Integer
+        val
+      when Float
+        val.finite? ? val.to_i : nil
       when String
-        # Try ISO-8601 / RFC3339 first, fall back to integer-string.
-        begin
-          t = DateTime.parse(val)
-          return (t.to_time.to_f * 1000).to_i
-        rescue ArgumentError, TypeError
-          # not a date; try integer
-        end
-        Integer(val, exception: false)
+        return Integer(val, 10) if INTEGER_STRING.match?(val)
+
+        rfc3339_to_millis(val)
+      end
+    end
+
+    def rfc3339_to_millis(str)
+      m = RFC3339_TIMESTAMP.match(str)
+      return nil if m.nil?
+
+      y, mo, d, h, mi, s = %i[y mo d h mi s].map { |k| m[k].to_i }
+      return nil unless Date.valid_date?(y, mo, d) && h <= 23 && mi <= 59 && s <= 59
+
+      offset_seconds = 0
+      if m[:sign]
+        oh = m[:oh].to_i
+        om = m[:om].to_i
+        return nil if oh > 23 || om > 59
 
+        offset_seconds = ((oh * 3600) + (om * 60)) * (m[:sign] == '-' ? -1 : 1)
       end
+      epoch_seconds = Time.utc(y, mo, d, h, mi, s).to_i - offset_seconds
+      (epoch_seconds * 1000) + (m[:frac] || '').ljust(3, '0')[0, 3].to_i
     end
   end
 
@@ -540,8 +587,11 @@ module Quonfig
       when 'log_level'   then raw.is_a?(Numeric) ? raw : raw.to_s
       when 'duration'    then duration_to_millis(raw)
       when 'json'
-        # JSON values must be native JS/Ruby types on the wire.
-        raw
+        # JSON values must be native JS/Ruby types on the wire. Hashes and
+        # Arrays are copied so a caller mutating the result cannot rewrite
+        # the cached config for every later read (qfg-goi1.10.3, sdk-go
+        # qfg-9dxb.6). Leaf values (strings included) are not copied.
+        copy_json_containers(raw)
       else
         raw
       end
@@ -555,6 +605,14 @@ module Quonfig
 
     private
 
+    def copy_json_containers(value)
+      case value
+      when Hash then value.to_h { |k, v| [k, copy_json_containers(v)] }
+      when Array then value.map { |v| copy_json_containers(v) }
+      else value
+      end
+    end
+
     # Coerce an ISO 8601 duration value (e.g. "PT0.2S", "P1DT6H2M1.5S")
     # to integer milliseconds. The wire format may either be a bare ISO
     # string in `value` or the structured `{ seconds, nanos }` proto-style

data/lib/quonfig/resolver.rb

@@ -47,26 +47,13 @@ module Quonfig
     # the legacy "return nil if absent" shape can rescue and recover (see
     # IntegrationTestHelpers.assert_resolved, which folds a missing-key
     # raise into the test's expected default).
+    # The whole lookup reads one store snapshot (qfg-i86q): the flag, the
+    # segments it references and any decryptWith key all come from the same
+    # envelope even if an install lands mid-evaluation.
     def get(key, context = nil)
-      config = raw(key)
-      raise Quonfig::Errors::MissingDefaultError, key if config.nil?
-
-      eval_result = @evaluator.evaluate_config(config, context, resolver: self)
-      return nil if eval_result.nil?
+      return get_unpinned(key, context) unless @store.respond_to?(:pinned)
 
-      weighted_index = nil
-      hash_missing = []
-      resolved_value = resolve_value_on_path(eval_result.value, config, context, [], hash_missing) do |idx|
-        weighted_index = idx
-      end
-      EvalResult.new(
-        value: resolved_value,
-        rule_index: eval_result.rule_index,
-        config: config,
-        weighted_value_index: weighted_index,
-        reportable_value: redacted_reportable_value(eval_result.value),
-        hash_property_missing: !hash_missing.empty?
-      )
+      @store.pinned { get_unpinned(key, context) }
     end
 
     # Post-evaluation value resolution. Mirrors sdk-node Resolver#resolveValue
@@ -86,20 +73,54 @@ module Quonfig
 
     private
 
+    def get_unpinned(key, context)
+      config = raw(key)
+      raise Quonfig::Errors::MissingDefaultError, key if config.nil?
+
+      eval_result = @evaluator.evaluate_config(config, context, resolver: self)
+      return nil if eval_result.nil?
+
+      weighted_index = nil
+      hash_missing = []
+      selected_variants = []
+      resolved_value = resolve_value_on_path(eval_result.value, config, context, [], hash_missing,
+                                             selected_variants) do |idx|
+        weighted_index = idx
+      end
+      # Redact from the selected rollout variant, not only the outer
+      # weighted_values wrapper (which is never flagged), so a confidential or
+      # decryptWith variant never reaches telemetry in plaintext (qfg-goi1.2.39).
+      reportable = redacted_reportable_value(eval_result.value) || redacted_reportable_value(selected_variants.last)
+      EvalResult.new(
+        value: resolved_value,
+        rule_index: eval_result.rule_index,
+        config: config,
+        weighted_value_index: weighted_index,
+        reportable_value: reportable,
+        hash_property_missing: !hash_missing.empty?
+      )
+    end
+
     # resolve_value plus +key_path+: the config keys already being resolved
     # above this one through decryptWith, so a decryptWith cycle raises a
     # DecryptionError instead of recursing until SystemStackError
     # (qfg-9dxb.7, matching sdk-go qfg-9dxb.4). +hash_missing+, when given,
     # gets an entry for each weighted rollout whose hash property was missing
-    # from the context (qfg-9dxb.8).
-    def resolve_value_on_path(value, config, context, key_path, hash_missing = nil, &on_weighted_index)
+    # from the context (qfg-9dxb.8). +selected_variants+, when given, gets the
+    # stored (pre-resolution) Value of each weighted variant picked, so get()
+    # can redact a confidential/decryptWith variant (qfg-goi1.2.39).
+    def resolve_value_on_path(value, config, context, key_path, hash_missing = nil, selected_variants = nil,
+                              &on_weighted_index)
       return nil if value.nil?
 
       type = vget(value, :type, 'type')
 
       return resolve_provided(value, config) if type == 'provided'
 
-      return resolve_weighted(value, config, context, key_path, hash_missing, &on_weighted_index) if type == 'weighted_values'
+      if type == 'weighted_values'
+        return resolve_weighted(value, config, context, key_path, hash_missing, selected_variants,
+                                &on_weighted_index)
+      end
 
       confidential = vget(value, :confidential, 'confidential')
       decrypt_with = vget(value, :decryptWith, 'decryptWith', :decrypt_with, 'decrypt_with')
@@ -184,7 +205,8 @@ module Quonfig
     # nil) hashes an empty value, the same bucket as a present "", and warns
     # once per config key (qfg-9dxb.8). With no hash property configured the
     # pick stays random per call.
-    def resolve_weighted(value, config, context, key_path, hash_missing = nil, &on_weighted_index)
+    def resolve_weighted(value, config, context, key_path, hash_missing = nil, selected_variants = nil,
+                         &on_weighted_index)
       payload = vget(value, :value, 'value') || {}
       weighted = vget(payload, :weightedValues, 'weightedValues', :weighted_values, 'weighted_values')
       return value unless weighted.is_a?(Array) && !weighted.empty?
@@ -213,7 +235,9 @@ module Quonfig
       variant, index = picker.resolve
       on_weighted_index&.call(index)
       variant_value = vget(variant, :value, 'value')
-      resolve_value_on_path(variant_value, config, context, key_path, hash_missing, &on_weighted_index)
+      selected_variants&.push(variant_value)
+      resolve_value_on_path(variant_value, config, context, key_path, hash_missing, selected_variants,
+                            &on_weighted_index)
     end
 
     def warn_hash_property_missing(cfg_key, hash_property)

data/lib/quonfig/semver.rb

@@ -18,6 +18,11 @@ class SemanticVersion
     $
   /x
 
+  # Abbreviated "x" and "x.y" (qfg-goi1.5 Q5), read as x.0.0 and x.y.0 by
+  # the PROP_SEMVER_* operators, matching LaunchDarkly. A prerelease or build
+  # suffix needs the full x.y.z.
+  ABBREVIATED_PATTERN = /\A(?<major>0|[1-9]\d*)(?:\.(?<minor>0|[1-9]\d*))?\z/
+
   attr_reader :major, :minor, :patch, :prerelease, :build_metadata
 
   def self.parse(version_string)
@@ -36,7 +41,12 @@ class SemanticVersion
     )
   end
 
-  def self.parse_quietly(version_string)
+  def self.parse_quietly(version_string, allow_abbreviated: false)
+    if allow_abbreviated && version_string.is_a?(String)
+      match = ABBREVIATED_PATTERN.match(version_string)
+      return new(major: match[:major].to_i, minor: match[:minor].to_i, patch: 0) if match
+    end
+
     parse(version_string)
   rescue ArgumentError
     nil