quonfig 0.0.12 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ae93c1a78be83e339ff86bf9eaa58efa3376602c363ddd1d4c6e326fe102865
-  data.tar.gz: 38debe8196e6a9ae1f5281b810d0193a4d8a821a45bb18afeaf103732f1d92d7
+  metadata.gz: b25ea20d7f44acff4ed82e17522a9fb6055791c4f1e0c861075974e5ae37421f
+  data.tar.gz: e0c260d2d13926e21f2525c7686a24f8dec2f1fa998efa039db59baf4447cd60
 SHA512:
-  metadata.gz: de28a9ffb64be4d7a5c3c4982a13713cfd44ba0abcef4bbbcf3a385de9ddd881fe814e319d6770ec572f7b9655e8cc6f466d887040fa300e4d9513dce54e045e
-  data.tar.gz: 0c1ac8d2e32d95534f0f903d0fa6df1a2a627a4d7f5f68a27e14448230e67804b3c859e0e1d551cde7c7ce6e2a7c453ebfb67aee7f30e1834753130328344663
+  metadata.gz: da91dbd4f9cc300f2dab9e8f39a73033e642d94272288cbcacf4358eb28f4f9b064f8fbe8301c5c26e1b342cd3cd76179d362029e06379bcac39685c3a050cb2
+  data.tar.gz: ac77088e6a6e0256d947f40b26abb9527bb55cff8a3fa39eaaebf91c43746379d5fa2325bd06e049922b2cbc8521f78252bdd79106c6f1ae7f1a0264f4033ab6

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.0.14 - 2026-05-10
+
+- **Feat: expose `variant` and `flag_metadata` on `EvaluationDetails` (qfg-9dbl).** OpenFeature's `EvaluationDetails` Ruby return type now carries the variant name and the flag-level metadata hash alongside the resolved value/reason. Brings sdk-ruby to parity with the other SDKs' detail surfaces and lets host apps (incl. the Ruby OpenFeature provider) read variant/metadata without re-fetching the config.
+- **Test: regenerate integration tests from rubocop-clean templates (qfg-vrck).** The integration suite under `test/integration/` is now generated from templates that pass `bundle exec rubocop` on first emit, so future regenerations don't trigger a follow-up autofix commit.
+
+## 0.0.13 - 2026-05-07
+
+- **Feat: `IS_PRESENT` and `IS_NOT_PRESENT` targeting operators (qfg-7jnb.6).** Both take only `propertyName` (no `valueToMatch`). `IS_PRESENT` resolves the dotted path against the merged context and returns true iff the value is non-nil. Type-agnostic — empty string `""`, `0`, and `false` all count as **present**; only `nil` / missing keys (including missing nested paths) are absent. `IS_NOT_PRESENT` is the negation. Implemented explicitly without ActiveSupport's `present?` / `blank?`, which would have given the wrong semantics on `""` and `false`. Matches sdk-node, sdk-go, sdk-python, sdk-ruby, sdk-javascript wire behaviour. Closes the integration-test parity gap that left 7 RSpec/Minitest cases red since the operators landed in `integration-test-data`.
+
 ## 0.0.12 - 2026-05-03
 
 - **Feat: pluggable `logger:` kwarg on `Quonfig::Client.new`.** Host apps can now pass `Rails.logger` (or any stdlib `Logger`-compatible instance) and have all SDK warnings/errors flow through it instead of bare stderr / SemanticLogger. Implemented as a class-level `Quonfig::InternalLogger.user_logger` override that all `LOG` constants respect at log-call time, so existing per-class `LOG` constants pick it up automatically. Duck-typed (responds to `debug`/`info`/`warn`/`error`); missing levels degrade gracefully. SemanticLogger auto-detection is unchanged when no logger is supplied. Also routes the two outlier `dev_context.rb` warns (file read / JSON parse failures) through `InternalLogger` so they pick up the host-supplied logger too. (qfg-mol-1qw.3)

data/lib/quonfig/client.rb

@@ -547,19 +547,25 @@ module Quonfig
             value: nil,
             reason: Quonfig::EvaluationDetails::REASON_ERROR,
             error_code: Quonfig::EvaluationDetails::ERROR_FLAG_NOT_FOUND,
-            error_message: e.message
+            error_message: e.message,
+            variant: build_variant(Quonfig::EvaluationDetails::REASON_ERROR, nil, nil),
+            flag_metadata: build_flag_metadata(nil, nil, nil, nil, nil)
           )
         end
 
       if result.nil?
         return Quonfig::EvaluationDetails.new(
           value: nil,
-          reason: Quonfig::EvaluationDetails::REASON_DEFAULT
+          reason: Quonfig::EvaluationDetails::REASON_DEFAULT,
+          variant: build_variant(Quonfig::EvaluationDetails::REASON_DEFAULT, nil, nil),
+          flag_metadata: build_flag_metadata(nil, nil, nil, nil, nil)
         )
       end
 
       record_evaluation_for_telemetry(result)
 
+      config_id = result.config&.dig('id') || result.config&.dig(:id)
+      config_type = result.config&.dig('type') || result.config&.dig(:type)
       raw_value = result.unwrapped_value
 
       begin
@@ -569,23 +575,64 @@ module Quonfig
           value: nil,
           reason: Quonfig::EvaluationDetails::REASON_ERROR,
           error_code: Quonfig::EvaluationDetails::ERROR_TYPE_MISMATCH,
-          error_message: e.message
+          error_message: e.message,
+          variant: build_variant(Quonfig::EvaluationDetails::REASON_ERROR, nil, nil),
+          flag_metadata: build_flag_metadata(config_id, config_type, nil, nil, nil)
         )
       end
 
+      reason = result.of_reason
       Quonfig::EvaluationDetails.new(
         value: coerced,
-        reason: result.of_reason
+        reason: reason,
+        variant: build_variant(reason, result.rule_index, result.weighted_value_index),
+        flag_metadata: build_flag_metadata(
+          config_id, config_type, result.rule_index, result.weighted_value_index, reason
+        )
       )
     rescue StandardError => e
       Quonfig::EvaluationDetails.new(
         value: nil,
         reason: Quonfig::EvaluationDetails::REASON_ERROR,
         error_code: Quonfig::EvaluationDetails::ERROR_GENERAL,
-        error_message: e.message
+        error_message: e.message,
+        variant: build_variant(Quonfig::EvaluationDetails::REASON_ERROR, nil, nil),
+        flag_metadata: build_flag_metadata(nil, nil, nil, nil, nil)
       )
     end
 
+    # Build the variant string per the cross-SDK spec
+    # (project/plans/openfeature-resolution-details.md §2).
+    def build_variant(reason, rule_index, weighted_value_index)
+      case reason
+      when Quonfig::EvaluationDetails::REASON_STATIC
+        'static'
+      when Quonfig::EvaluationDetails::REASON_TARGETING_MATCH
+        "targeting:#{rule_index || 0}"
+      when Quonfig::EvaluationDetails::REASON_SPLIT
+        "split:#{weighted_value_index || 0}"
+      else
+        'default'
+      end
+    end
+
+    # Build the flag_metadata hash per the cross-SDK spec
+    # (project/plans/openfeature-resolution-details.md §3) using Ruby's
+    # snake_case keys and the wire's snake_case config_type values.
+    def build_flag_metadata(config_id, config_type, rule_index, weighted_value_index, reason)
+      md = {}
+      md['config_id'] = config_id if config_id
+      md['config_type'] = config_type if config_type
+      env = @options.environment
+      md['environment'] = env if env && !env.empty?
+      if rule_index && rule_index >= 0 &&
+         [Quonfig::EvaluationDetails::REASON_TARGETING_MATCH, Quonfig::EvaluationDetails::REASON_SPLIT].include?(reason)
+        md['rule_index'] = rule_index
+      end
+      md['weighted_value_index'] = weighted_value_index if weighted_value_index && reason == Quonfig::EvaluationDetails::REASON_SPLIT
+      md
+    end
+
     def typed_get(key, expected_type, default:, context:)
       jit = context == NO_DEFAULT_PROVIDED ? NO_DEFAULT_PROVIDED : context
       value = get(key, default, jit)

data/lib/quonfig/evaluation_details.rb

@@ -28,13 +28,16 @@ module Quonfig
     ERROR_TYPE_MISMATCH  = 'TYPE_MISMATCH'
     ERROR_GENERAL        = 'GENERAL'
 
-    attr_reader :value, :reason, :error_code, :error_message
+    attr_reader :value, :reason, :error_code, :error_message, :variant, :flag_metadata
 
-    def initialize(value:, reason:, error_code: nil, error_message: nil)
+    def initialize(value:, reason:, error_code: nil, error_message: nil,
+                   variant: nil, flag_metadata: nil)
       @value         = value
       @reason        = reason
       @error_code    = error_code
       @error_message = error_message
+      @variant       = variant
+      @flag_metadata = flag_metadata
     end
 
     def ==(other)
@@ -42,18 +45,22 @@ module Quonfig
         other.value == @value &&
         other.reason == @reason &&
         other.error_code == @error_code &&
-        other.error_message == @error_message
+        other.error_message == @error_message &&
+        other.variant == @variant &&
+        other.flag_metadata == @flag_metadata
     end
     alias eql? ==
 
     def hash
-      [@value, @reason, @error_code, @error_message].hash
+      [@value, @reason, @error_code, @error_message, @variant, @flag_metadata].hash
     end
 
     def inspect
       parts = ["value=#{@value.inspect}", "reason=#{@reason.inspect}"]
       parts << "error_code=#{@error_code.inspect}" if @error_code
       parts << "error_message=#{@error_message.inspect}" if @error_message
+      parts << "variant=#{@variant.inspect}" if @variant
+      parts << "flag_metadata=#{@flag_metadata.inspect}" if @flag_metadata
       "#<Quonfig::EvaluationDetails #{parts.join(' ')}>"
     end
   end

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
 
@@ -280,6 +282,17 @@ module Quonfig
         end
         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
           segment_key = to_s_nil(hget(match_value, :value))

data/lib/quonfig/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quonfig
-  VERSION = '0.0.12'
+  VERSION = '0.0.14'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quonfig
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.14
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-03 00:00:00.000000000 Z
+date: 2026-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport