quonfig-openfeature 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54cc3d133c6809723ef8a1e51ae646dcd889ce4792ce3cbf9acb4f1d394639d4
+  data.tar.gz: 63001d3f0a98e3ae2e7cdf7b9e5787bc6fc6da0c08a10c71a73d1d9e54724d6b
+SHA512:
+  metadata.gz: 3210f73b87dd87f839f25cbbe134917ab0ccb8eea921fab1c382e3be149c538947e8dc06a8a1962b53296dff4002fe2d3fa88948b0f472302a791a368a5ef75b
+  data.tar.gz: c9195438b21b65c3ed46e27790180a4b9692d06d2dec364af8f14baa30b5bdc202b0e00668cd1200127164d8f688dc239f51a5931ee0d657484742f6039fab0c

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Quonfig
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,138 @@
+# quonfig-openfeature
+
+OpenFeature provider for [Quonfig](https://quonfig.com) -- Ruby server-side SDK.
+
+This gem wraps the `quonfig` native Ruby SDK and implements the
+[OpenFeature](https://openfeature.dev) `OpenFeature::SDK::Provider` contract.
+
+## Install
+
+```bash
+gem install quonfig-openfeature openfeature-sdk quonfig
+```
+
+Or with Bundler:
+
+```ruby
+gem 'quonfig-openfeature'
+gem 'openfeature-sdk'
+gem 'quonfig'
+```
+
+## Usage
+
+```ruby
+require 'quonfig/openfeature'
+require 'open_feature/sdk'
+
+provider = Quonfig::OpenFeature::Provider.new(
+  sdk_key: 'qf_sk_production_...'
+  # targeting_key_mapping: 'user.id', # default
+)
+
+OpenFeature::SDK.set_provider_and_wait(provider)
+
+client = OpenFeature::SDK.build_client
+
+# Boolean flag
+enabled = client.fetch_boolean_value(flag_key: 'my-feature', default_value: false)
+
+# String config
+welcome = client.fetch_string_value(flag_key: 'welcome-message', default_value: 'Hello!')
+
+# Number config (Integer or Float)
+timeout = client.fetch_number_value(flag_key: 'request-timeout-ms', default_value: 5000)
+
+# Object config (JSON or string_list)
+allowed_plans = client.fetch_object_value(flag_key: 'allowed-plans', default_value: [])
+
+# With evaluation context (per-request)
+ctx = OpenFeature::SDK::EvaluationContext.new(
+  targeting_key: 'user-123',  # maps to user.id by default
+  'user.plan'   => 'pro',
+  'org.tier'    => 'enterprise'
+)
+is_pro = client.fetch_boolean_value(flag_key: 'pro-feature', default_value: false,
+                                     evaluation_context: ctx)
+```
+
+## Context mapping
+
+OpenFeature context is flat; Quonfig context is nested by namespace. This provider
+maps between them using dot-notation:
+
+| OpenFeature context key | Quonfig namespace | Quonfig property |
+|-------------------------|-------------------|------------------|
+| `targeting_key`         | `user`            | `id` (configurable via `targeting_key_mapping`) |
+| `"user.email"`          | `user`            | `email`          |
+| `"org.tier"`            | `org`             | `tier`           |
+| `"country"` (no dot)    | `""` (default)    | `country`        |
+| `"user.ip.address"`     | `user`            | `ip.address` (first dot only) |
+
+### Customising `targeting_key` mapping
+
+```ruby
+provider = Quonfig::OpenFeature::Provider.new(
+  sdk_key: 'qf_sk_...',
+  targeting_key_mapping: 'account.id' # maps targeting_key to { account: { id: ... } }
+)
+```
+
+## Accessing native SDK features
+
+The `client` reader returns the underlying `Quonfig::Client` for features not
+available through the OpenFeature API:
+
+```ruby
+native = provider.client
+
+# Log level integration
+native.should_log?(logger_path: 'auth', desired_level: :debug,
+                   contexts: { 'user' => { 'id' => 'user-123' } })
+
+# List all config keys
+keys = native.keys
+
+# Per-request bound client
+native.with_context('user' => { 'plan' => 'pro' }) do |bound|
+  bound.get_bool('pro-feature')
+end
+```
+
+## What you lose vs. the native SDK
+
+OpenFeature is designed for feature flags, not general configuration. Some
+Quonfig features require the native `quonfig` SDK:
+
+1. **Log levels** -- `should_log?` and the `semantic_logger_filter` are native-only.
+2. **`string_list` configs** -- accessed via `fetch_object_value` and used as `Array<String>`.
+3. **`duration` configs** -- exposed only via the native `get_duration` (returns milliseconds).
+4. **`bytes` configs** -- not accessible via OpenFeature (no binary type in OF).
+5. **`keys` / raw config inspection** -- native-only via `provider.client`.
+6. **Context keys use dot-notation** -- `"user.email"`, not nested hashes.
+7. **`targeting_key` maps to `user.id` by default** -- configure
+   `targeting_key_mapping` if you target a different namespace.
+
+## Offline / test mode
+
+Pass `datadir:` to evaluate against a Quonfig workspace on disk -- the same
+layout the integration test suite uses. No network or SDK key is required.
+
+```ruby
+provider = Quonfig::OpenFeature::Provider.new(
+  datadir:     '/path/to/workspace',
+  environment: 'Production',
+  enable_sse:  false
+)
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+The development `Gemfile` references the sibling `../sdk-ruby/` checkout via a
+`path:` reference; downstream consumers depend on the `quonfig` gem from
+RubyGems.

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/quonfig/openfeature/context.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module OpenFeature
+    # Maps an OpenFeature flat EvaluationContext to Quonfig's nested contexts hash.
+    #
+    # Mapping rules (mirror @quonfig/openfeature-node and openfeature-go):
+    #   - +targeting_key+ maps to namespace+property specified by +targeting_key_mapping+
+    #     (default "user.id"). The mapping is split on the FIRST dot — namespace before,
+    #     property after.
+    #   - Keys with a dot are split on the first dot: "user.email" -> { "user" => { "email" => v } }
+    #   - Keys without a dot go to the default empty-string namespace:
+    #     "country" -> { "" => { "country" => v } }
+    #   - Multi-dot keys split on the first dot only:
+    #     "user.ip.address" -> { "user" => { "ip.address" => v } }
+    #   - Nil values are skipped.
+    #   - An empty / nil context returns +{}+.
+    module Context
+      module_function
+
+      DEFAULT_TARGETING_KEY_MAPPING = 'user.id'
+      TARGETING_KEY_FIELDS = %w[targeting_key targetingKey].freeze
+
+      # @param of_context [::OpenFeature::SDK::EvaluationContext, Hash, nil]
+      # @param targeting_key_mapping [String]
+      # @return [Hash{String=>Hash{String=>Object}}]
+      def map_context(of_context, targeting_key_mapping = DEFAULT_TARGETING_KEY_MAPPING)
+        return {} if of_context.nil?
+
+        fields, targeting_key = extract_fields_and_targeting_key(of_context)
+        return {} if fields.empty? && (targeting_key.nil? || targeting_key.to_s.empty?)
+
+        result = {}
+
+        unless targeting_key.nil? || targeting_key.to_s.empty?
+          ns, prop = split_first(targeting_key_mapping)
+          assign(result, ns, prop, targeting_key)
+        end
+
+        fields.each do |key, value|
+          next if value.nil?
+          # The targeting_key is handled above; do not also write it under its raw name.
+          next if TARGETING_KEY_FIELDS.include?(key.to_s)
+
+          ns, prop = split_first(key.to_s)
+          assign(result, ns, prop, value)
+        end
+
+        result
+      end
+
+      # Returns [fields_hash_with_string_keys, targeting_key_or_nil]. Accepts an
+      # OpenFeature::SDK::EvaluationContext (preferred) or a plain Hash.
+      def extract_fields_and_targeting_key(ctx)
+        if ctx.respond_to?(:fields) && ctx.respond_to?(:targeting_key)
+          [(ctx.fields || {}).transform_keys(&:to_s), ctx.targeting_key]
+        elsif ctx.is_a?(Hash)
+          stringified = ctx.transform_keys(&:to_s)
+          tk = stringified['targeting_key'] || stringified['targetingKey']
+          [stringified, tk]
+        else
+          [{}, nil]
+        end
+      end
+
+      def split_first(key)
+        idx = key.index('.')
+        return ['', key] if idx.nil?
+
+        [key[0...idx], key[(idx + 1)..]]
+      end
+
+      def assign(result, namespace, property, value)
+        result[namespace] ||= {}
+        result[namespace][property] = value
+      end
+    end
+  end
+end

data/lib/quonfig/openfeature/errors.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'open_feature/sdk'
+
+module Quonfig
+  module OpenFeature
+    # Maps native Quonfig SDK errors to OpenFeature ErrorCode constants.
+    module Errors
+      module_function
+
+      ErrorCode = ::OpenFeature::SDK::Provider::ErrorCode
+
+      # @param err [Exception, String, nil]
+      # @return [String] one of the ErrorCode constants
+      def to_error_code(err)
+        return ErrorCode::GENERAL if err.nil?
+
+        # Class-based mapping is the most reliable signal.
+        if defined?(::Quonfig::Errors::MissingDefaultError) && err.is_a?(::Quonfig::Errors::MissingDefaultError)
+          return ErrorCode::FLAG_NOT_FOUND
+        end
+
+        if defined?(::Quonfig::Errors::TypeMismatchError) && err.is_a?(::Quonfig::Errors::TypeMismatchError)
+          return ErrorCode::TYPE_MISMATCH
+        end
+
+        if (defined?(::Quonfig::Errors::UninitializedError) && err.is_a?(::Quonfig::Errors::UninitializedError)) ||
+           (defined?(::Quonfig::Errors::InitializationTimeoutError) && err.is_a?(::Quonfig::Errors::InitializationTimeoutError))
+          return ErrorCode::PROVIDER_NOT_READY
+        end
+
+        # Fallback: inspect the message text for keywords, matching the Node provider.
+        msg = (err.respond_to?(:message) ? err.message : err.to_s).to_s.downcase
+        return ErrorCode::FLAG_NOT_FOUND if msg.include?('not found') ||
+                                            msg.include?('no value found') ||
+                                            msg.include?('value found for key')
+        return ErrorCode::TYPE_MISMATCH if msg.include?('type mismatch') ||
+                                           msg.include?('expected ') && msg.include?('got ')
+        return ErrorCode::PROVIDER_NOT_READY if msg.include?('not initialized') ||
+                                                msg.include?('provider not ready') ||
+                                                msg.include?("couldn't initialize") ||
+                                                msg.include?('initialization timeout')
+
+        ErrorCode::GENERAL
+      end
+    end
+  end
+end

data/lib/quonfig/openfeature/provider.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require 'open_feature/sdk'
+require 'quonfig'
+
+require 'quonfig/openfeature/context'
+require 'quonfig/openfeature/errors'
+
+module Quonfig
+  module OpenFeature
+    # OpenFeature provider that wraps the +quonfig+ Ruby SDK and implements the
+    # OpenFeature server-side provider contract:
+    #
+    #   * +metadata+
+    #   * +init(evaluation_context = nil)+
+    #   * +shutdown+
+    #   * +fetch_boolean_value(flag_key:, default_value:, evaluation_context:)+
+    #   * +fetch_string_value(flag_key:, default_value:, evaluation_context:)+
+    #   * +fetch_number_value(flag_key:, default_value:, evaluation_context:)+
+    #   * +fetch_integer_value(flag_key:, default_value:, evaluation_context:)+
+    #   * +fetch_float_value(flag_key:, default_value:, evaluation_context:)+
+    #   * +fetch_object_value(flag_key:, default_value:, evaluation_context:)+
+    #
+    # Usage:
+    #
+    #   require 'quonfig/openfeature'
+    #   require 'open_feature/sdk'
+    #
+    #   provider = Quonfig::OpenFeature::Provider.new(sdk_key: 'qf_sk_...')
+    #   OpenFeature::SDK.set_provider_and_wait(provider)
+    #
+    #   client = OpenFeature::SDK.build_client
+    #   client.fetch_boolean_value(flag_key: 'my-flag', default_value: false)
+    class Provider
+      NAME = 'quonfig'
+
+      ResolutionDetails = ::OpenFeature::SDK::Provider::ResolutionDetails
+      Reason            = ::OpenFeature::SDK::Provider::Reason
+      ErrorCode         = ::OpenFeature::SDK::Provider::ErrorCode
+      ProviderMetadata  = ::OpenFeature::SDK::Provider::ProviderMetadata
+
+      attr_reader :metadata, :targeting_key_mapping
+
+      # @param sdk_key [String, nil] SDK key for the live delivery service.
+      # @param datadir [String, nil] path to a Quonfig workspace for offline mode.
+      # @param environment [String, nil] which environment to evaluate.
+      # @param targeting_key_mapping [String] dot-notation path the OpenFeature
+      #   targeting_key is rewritten to (default "user.id").
+      # @param client [Quonfig::Client, nil] inject a pre-built Quonfig client
+      #   (primarily for tests). When supplied, the other +sdk_key+/+datadir+/etc.
+      #   options are ignored.
+      # @param quonfig_options [Hash] any other keyword arguments are forwarded
+      #   verbatim to +Quonfig::Client.new+.
+      def initialize(sdk_key: nil, datadir: nil, environment: nil,
+                     targeting_key_mapping: Context::DEFAULT_TARGETING_KEY_MAPPING,
+                     client: nil, **quonfig_options)
+        @metadata = ProviderMetadata.new(name: NAME).freeze
+        @targeting_key_mapping = targeting_key_mapping
+        @client = client
+        @quonfig_options = build_quonfig_options(
+          sdk_key: sdk_key,
+          datadir: datadir,
+          environment: environment,
+          extra: quonfig_options
+        )
+        @initialized = !@client.nil?
+      end
+
+      # Initialize the underlying Quonfig client. Called by
+      # +OpenFeature::SDK.set_provider_and_wait+.
+      def init(_evaluation_context = nil)
+        return if @initialized
+
+        @client = ::Quonfig::Client.new(@quonfig_options)
+        @initialized = true
+        nil
+      end
+
+      # Shut the provider down. Mirrors the OpenFeature InMemoryProvider
+      # contract — silently no-ops if the client was never built.
+      def shutdown
+        client = @client
+        @client = nil
+        @initialized = false
+        client&.stop
+        nil
+      end
+
+      # Escape hatch: returns the underlying +Quonfig::Client+ for native-only
+      # features (keys, raw config, durations, log levels). Returns +nil+ until
+      # +init+ has run.
+      def client
+        @client
+      end
+
+      # ---- fetch_*_value -----------------------------------------------------
+
+      def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
+          value = client.get_bool(flag_key, default: nil, context: mapped_ctx)
+          if value.nil?
+            ResolutionDetails.new(value: default_value, reason: Reason::ERROR,
+                                  error_code: ErrorCode::FLAG_NOT_FOUND,
+                                  error_message: "flag not found: #{flag_key}")
+          else
+            ResolutionDetails.new(value: value, reason: Reason::TARGETING_MATCH)
+          end
+        end
+      end
+
+      def fetch_string_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
+          value = client.get_string(flag_key, default: nil, context: mapped_ctx)
+          if value.nil?
+            ResolutionDetails.new(value: default_value, reason: Reason::ERROR,
+                                  error_code: ErrorCode::FLAG_NOT_FOUND,
+                                  error_message: "flag not found: #{flag_key}")
+          else
+            ResolutionDetails.new(value: value, reason: Reason::TARGETING_MATCH)
+          end
+        end
+      end
+
+      def fetch_number_value(flag_key:, default_value:, evaluation_context: nil)
+        # OpenFeature's "number" is Ruby Numeric (Integer or Float). Try integer
+        # first, fall back to float so we transparently handle both Quonfig
+        # int and double configs.
+        evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
+          value = nil
+          begin
+            value = client.get_int(flag_key, default: nil, context: mapped_ctx)
+          rescue ::Quonfig::Errors::TypeMismatchError
+            value = client.get_float(flag_key, default: nil, context: mapped_ctx)
+          end
+
+          if value.nil?
+            ResolutionDetails.new(value: default_value, reason: Reason::ERROR,
+                                  error_code: ErrorCode::FLAG_NOT_FOUND,
+                                  error_message: "flag not found: #{flag_key}")
+          else
+            ResolutionDetails.new(value: value, reason: Reason::TARGETING_MATCH)
+          end
+        end
+      end
+
+      def fetch_integer_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
+          value = client.get_int(flag_key, default: nil, context: mapped_ctx)
+          if value.nil?
+            ResolutionDetails.new(value: default_value, reason: Reason::ERROR,
+                                  error_code: ErrorCode::FLAG_NOT_FOUND,
+                                  error_message: "flag not found: #{flag_key}")
+          else
+            ResolutionDetails.new(value: value, reason: Reason::TARGETING_MATCH)
+          end
+        end
+      end
+
+      def fetch_float_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
+          value = client.get_float(flag_key, default: nil, context: mapped_ctx)
+          if value.nil?
+            ResolutionDetails.new(value: default_value, reason: Reason::ERROR,
+                                  error_code: ErrorCode::FLAG_NOT_FOUND,
+                                  error_message: "flag not found: #{flag_key}")
+          else
+            ResolutionDetails.new(value: value, reason: Reason::TARGETING_MATCH)
+          end
+        end
+      end
+
+      # Object resolution tries +get_string_list+ first (so Quonfig
+      # +string_list+ configs surface as native arrays), then falls back to
+      # +get_json+ for any other JSON-shaped config.
+      def fetch_object_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value, evaluation_context) do |client, mapped_ctx|
+          value = nil
+          begin
+            value = client.get_string_list(flag_key, default: nil, context: mapped_ctx)
+          rescue ::Quonfig::Errors::TypeMismatchError
+            value = nil
+          end
+          if value.nil?
+            value = client.get_json(flag_key, default: nil, context: mapped_ctx)
+          end
+
+          if value.nil?
+            ResolutionDetails.new(value: default_value, reason: Reason::ERROR,
+                                  error_code: ErrorCode::FLAG_NOT_FOUND,
+                                  error_message: "flag not found: #{flag_key}")
+          else
+            ResolutionDetails.new(value: value, reason: Reason::TARGETING_MATCH)
+          end
+        end
+      end
+
+      private
+
+      def evaluate(flag_key, default_value, evaluation_context)
+        client = @client
+        if client.nil?
+          return ResolutionDetails.new(
+            value: default_value,
+            reason: Reason::ERROR,
+            error_code: ErrorCode::PROVIDER_NOT_READY,
+            error_message: 'Quonfig provider has not been initialized'
+          )
+        end
+
+        mapped_ctx = Context.map_context(evaluation_context, @targeting_key_mapping)
+        yield(client, mapped_ctx)
+      rescue ::Quonfig::Errors::MissingDefaultError => e
+        ResolutionDetails.new(value: default_value, reason: Reason::ERROR,
+                              error_code: ErrorCode::FLAG_NOT_FOUND,
+                              error_message: e.message)
+      rescue ::Quonfig::Errors::TypeMismatchError => e
+        ResolutionDetails.new(value: default_value, reason: Reason::ERROR,
+                              error_code: ErrorCode::TYPE_MISMATCH,
+                              error_message: e.message)
+      rescue ::Quonfig::Errors::UninitializedError, ::Quonfig::Errors::InitializationTimeoutError => e
+        ResolutionDetails.new(value: default_value, reason: Reason::ERROR,
+                              error_code: ErrorCode::PROVIDER_NOT_READY,
+                              error_message: e.message)
+      rescue StandardError => e
+        ResolutionDetails.new(value: default_value, reason: Reason::ERROR,
+                              error_code: Errors.to_error_code(e),
+                              error_message: e.message)
+      end
+
+      def build_quonfig_options(sdk_key:, datadir:, environment:, extra:)
+        opts = {}
+        opts[:sdk_key] = sdk_key unless sdk_key.nil?
+        opts[:datadir] = datadir unless datadir.nil?
+        opts[:environment] = environment unless environment.nil?
+        opts.merge(extra)
+      end
+    end
+  end
+end

data/lib/quonfig/openfeature/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module OpenFeature
+    VERSION = File.read(File.expand_path('../../../VERSION', __dir__)).strip
+  end
+end

data/lib/quonfig/openfeature.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'open_feature/sdk'
+require 'quonfig'
+
+require 'quonfig/openfeature/version'
+require 'quonfig/openfeature/errors'
+require 'quonfig/openfeature/context'
+require 'quonfig/openfeature/provider'

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: quonfig-openfeature
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jeff Dwyer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: openfeature-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: quonfig
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: OpenFeature provider that wraps the quonfig Ruby SDK and implements the
+  OpenFeature Ruby provider contract.
+email:
+- jeff@quonfig.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- VERSION
+- lib/quonfig/openfeature.rb
+- lib/quonfig/openfeature/context.rb
+- lib/quonfig/openfeature/errors.rb
+- lib/quonfig/openfeature/provider.rb
+- lib/quonfig/openfeature/version.rb
+homepage: https://github.com/quonfig/openfeature-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: OpenFeature provider for Quonfig (Ruby)
+test_files: []