quonfig 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 875b035905394220e72fec4fc1afc3bc62ad6e2975b745098fa4482e1dc348d0
-  data.tar.gz: bd957d0ec077f3a49daf719deb3ea4db64d1b23a69f6264c91385ad21ff06720
+  metadata.gz: 18707780a8ad33c299973f4de01bc0b76d10161902f977b9771c10c2d4a23fde
+  data.tar.gz: 6980b904632659b97f16636e9a317bc8b3e8cbf02cc0b8f75ecf51325b8ba472
 SHA512:
-  metadata.gz: 9a592d367c361e42e57c42b0ca0929927808e834b5f876545e17436403b11eb5abe08d2996317e5ec5360a1df2228b48a247e22304d6fcda809c3ffee0e3f772
-  data.tar.gz: f3f9b9b1135ab775861164fb89701e6a3cf6b5cb23078d55de89604b13081ce71b7fe00bed192cd9d9134d64fd406fec954efa793e62a2fb558a8ca3cddbec4f
+  metadata.gz: 74c6a59b81fd222ddd522e52301ea74a1f9bc76b18ecbfe50c01a46e21539bdc5cea6a38a927938fb497f6003a64a2e796d177f2ed3ee527d5891f6cd9ca63a4
+  data.tar.gz: 94b1c109e6db3df2ea115e62f80f099430752779faa9655ee6f53c20c614fa42ccdc8e350342985cb09861e286bd91b857381508849a81fada865927c98f7f22

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 0.0.8 - 2026-04-26
+
+- **Fix (gemspec): drop deleted `scripts/` entry from manifest** — regenerated
+  juwelier gemspec so `gem build` no longer fails on the missing
+  `scripts/generate_integration_tests.rb` file. Also untracked stray
+  `.DS_Store`. v0.0.7 was tagged but never published due to this bug.
+
+## 0.0.7 - 2026-04-26
+
+- **New: `client.enabled?` / `client.default` / `client.client_construction` integration helpers** —
+  Adds aggregator helpers used by the cross-SDK post + telemetry integration suites.
+- **New: telemetry eval-summaries aggregator + `at_exit` drain (qfg-9x7)** —
+  Periodically batches evaluation summaries and drains them on process exit so
+  short-lived scripts still report telemetry.
+- **New: context telemetry aggregators ported from sdk-node** — context shapes
+  and example-contexts ship through the same aggregator path as sdk-node and
+  sdk-go.
+- **New errors: `DecryptionError`, `MissingEnvironmentError`,
+  `InvalidEnvironmentError`** — explicit error classes raised from the resolver
+  and datadir loaders.
+- **Resolver: provided ENV_VAR resolution + coercion (qfg-08q)** — config values
+  marked `provided` now resolve from the environment at evaluation time and are
+  coerced to the declared value type.
+- **Fix (resolver): raise on missing key, decode weighted/duration/decryption** —
+  `get_or_raise` now raises `MissingDefaultError` for unknown keys, and weighted /
+  duration / decryption value types decode correctly through the JSON resolver.
+- **Fix (context): `grouped_key` drops anonymous contexts** — anonymous contexts
+  are no longer mixed into the grouped-context key, matching sdk-node and sdk-go.
+
 ## 0.0.6 - 2026-04-22
 
 - **New: `Quonfig::StdlibFormatter` + `client.stdlib_formatter(logger_name:)`** —

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.8

data/lib/quonfig/client.rb

@@ -21,7 +21,7 @@ module Quonfig
     LOG = Quonfig::InternalLogger.new(self)
 
     attr_reader :options, :resolver, :store, :evaluator, :instance_hash,
-                :config_loader
+                :config_loader, :telemetry_reporter
 
     def initialize(options = nil, store: nil, **option_kwargs)
       @options =
@@ -41,6 +41,7 @@ module Quonfig
       @sse_client = nil
       @poll_thread = nil
       @stopped = false
+      @telemetry_reporter = nil
 
       # If the caller injected a store, we're in test/bootstrap mode; skip I/O.
       return if store
@@ -50,15 +51,27 @@ module Quonfig
       else
         initialize_network_mode
       end
+
+      initialize_telemetry
     end
 
     # ---- Lookup --------------------------------------------------------
 
     def get(key, default = NO_DEFAULT_PROVIDED, jit_context = NO_DEFAULT_PROVIDED)
       ctx = build_context(jit_context)
-      result = @resolver.get(key, ctx)
+      record_context_for_telemetry(ctx)
+      result =
+        begin
+          @resolver.get(key, ctx)
+        rescue Quonfig::Errors::MissingDefaultError
+          # The Resolver raises (matching Quonfig.get_or_raise semantics).
+          # The Client's get applies the caller-provided default *or* the
+          # configured on_no_default policy via handle_missing.
+          nil
+        end
       return handle_missing(key, default) if result.nil?
 
+      record_evaluation_for_telemetry(result)
       result.unwrapped_value
     end
 
@@ -223,6 +236,13 @@ module Quonfig
       thread = @poll_thread
       @poll_thread = nil
       thread&.kill
+
+      begin
+        @telemetry_reporter&.stop
+      rescue StandardError => e
+        LOG.debug "Error stopping telemetry reporter: #{e.message}"
+      end
+      @telemetry_reporter = nil
     end
 
     def fork
@@ -235,6 +255,93 @@ module Quonfig
 
     private
 
+    # Construct and start the telemetry reporter if the options permit it.
+    # The reporter runs on a background thread and periodically POSTs
+    # context-shape and example-context batches to +telemetry_destination+.
+    def initialize_telemetry
+      shape_aggregator = nil
+      example_aggregator = nil
+      summaries_aggregator = nil
+
+      if @options.collect_max_shapes.to_i > 0
+        shape_aggregator = Quonfig::Telemetry::ContextShapeAggregator.new(
+          max_shapes: @options.collect_max_shapes
+        )
+      end
+
+      if @options.collect_max_example_contexts.to_i > 0
+        example_aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(
+          max_contexts: @options.collect_max_example_contexts
+        )
+      end
+
+      if @options.collect_max_evaluation_summaries.to_i > 0
+        summaries_aggregator = Quonfig::Telemetry::EvaluationSummariesAggregator.new(
+          max_keys: @options.collect_max_evaluation_summaries
+        )
+      end
+
+      return if shape_aggregator.nil? && example_aggregator.nil? && summaries_aggregator.nil?
+
+      @telemetry_reporter = Quonfig::Telemetry::TelemetryReporter.new(
+        options: @options,
+        instance_hash: @instance_hash,
+        context_shape_aggregator: shape_aggregator,
+        example_contexts_aggregator: example_aggregator,
+        evaluation_summaries_aggregator: summaries_aggregator,
+        sync_interval: @options.collect_sync_interval
+      )
+
+      return unless @telemetry_reporter.enabled?
+
+      @telemetry_reporter.start
+    rescue StandardError => e
+      LOG.warn "[quonfig] Telemetry init failed: #{e.class}: #{e.message}"
+      @telemetry_reporter = nil
+    end
+
+    # Feed a matched EvalResult into the evaluation_summaries aggregator.
+    # A no-op when telemetry is disabled or eval-summaries collection is off.
+    def record_evaluation_for_telemetry(result)
+      return if @telemetry_reporter.nil?
+      return if result.nil?
+
+      config = result.config
+      return if config.nil?
+
+      @telemetry_reporter.record_evaluation(
+        config_id: config_field(config, :id),
+        config_key: config_field(config, :key),
+        config_type: config_field(config, :type),
+        conditional_value_index: result.rule_index,
+        weighted_value_index: nil,
+        selected_value: result.unwrapped_value,
+        reason: result.wire_reason
+      )
+    rescue StandardError => e
+      LOG.debug "[quonfig] Telemetry record_evaluation error: #{e.class}: #{e.message}"
+    end
+
+    def config_field(config, key)
+      return nil if config.nil?
+
+      config[key.to_s] || config[key.to_sym]
+    end
+
+    # Feed every evaluated context into the telemetry aggregators. A no-op
+    # when telemetry is disabled or no aggregators are active.
+    def record_context_for_telemetry(context)
+      return if @telemetry_reporter.nil?
+      return if context.nil?
+
+      context_obj = context.is_a?(Quonfig::Context) ? context : Quonfig::Context.new(context)
+      return if context_obj.blank?
+
+      @telemetry_reporter.record(context_obj)
+    rescue StandardError => e
+      LOG.debug "[quonfig] Telemetry record error: #{e.class}: #{e.message}"
+    end
+
     def load_datadir_into_store
       envelope = Quonfig::Datadir.load_envelope(@options.datadir, @options.environment)
       envelope.configs.each { |cfg| @store.set(cfg['key'], cfg) }

data/lib/quonfig/context.rb

@@ -85,8 +85,17 @@ module Quonfig
       @contexts[name.to_s] || NamedContext.new(name, {})
     end
 
+    # Concatenate each named context's `key` (or `trackingId`) value into
+    # a stable identifier used for example-contexts dedupe. Mirrors
+    # sdk-node's groupedKey: contexts that don't have a `key` property
+    # contribute nothing — the resulting string is empty for "anonymous"
+    # contexts so the example aggregator can drop them entirely.
     def grouped_key
-      @contexts.map { |_, ctx| ctx.key }.sort.join('|')
+      @contexts.values.map do |ctx|
+        h = ctx.to_h
+        v = h['key'] || h[:key] || h['trackingId'] || h[:trackingId]
+        v.nil? ? nil : v.to_s
+      end.compact.reject(&:empty?).sort.join('|')
     end
 
     include Comparable

data/lib/quonfig/datadir.rb

@@ -59,8 +59,7 @@ module Quonfig
       environment ||= ENV['QUONFIG_ENVIRONMENT']
 
       if environment.nil? || environment.empty?
-        raise ArgumentError,
-              '[quonfig] Environment required for datadir mode; set the `environment` option or QUONFIG_ENVIRONMENT env var'
+        raise Quonfig::Errors::MissingEnvironmentError
       end
 
       unless File.exist?(quonfig_path)
@@ -70,8 +69,7 @@ module Quonfig
       environments = JSON.parse(File.read(quonfig_path)).fetch('environments', [])
 
       if !environments.empty? && !environments.include?(environment)
-        raise ArgumentError,
-              "[quonfig] Environment \"#{environment}\" not found in workspace; available environments: #{environments.join(', ')}"
+        raise Quonfig::Errors::InvalidEnvironmentError.new(environment, environments)
       end
 
       environment

data/lib/quonfig/errors/decryption_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    # Raised when a confidential config's ciphertext cannot be decrypted —
+    # either the configured `decryptWith` key is missing/empty, or the
+    # AES-GCM payload itself is malformed/tampered.
+    #
+    # Mirrors sdk-python's QuonfigDecryptionError. Sdk-node currently
+    # raises plain `Error` for the same path; this class is the Ruby
+    # equivalent of the dedicated exception type.
+    class DecryptionError < Quonfig::Error
+      def initialize(key, cause = nil)
+        message = "Decryption failed for config '#{key}'"
+        message += ": #{cause}" if cause && !cause.to_s.empty?
+        super(message)
+      end
+    end
+  end
+end

data/lib/quonfig/errors/env_var_parse_error.rb

@@ -4,7 +4,14 @@ module Quonfig
   module Errors
     class EnvVarParseError < Quonfig::Error
       def initialize(env_var, config, env_var_name)
-        super("Evaluating #{config.key} couldn't coerce #{env_var_name} of #{env_var} to #{config.value_type}")
+        key, value_type =
+          if config.is_a?(Hash)
+            [config[:key] || config['key'],
+             config[:value_type] || config['value_type'] || config['valueType']]
+          else
+            [config.key, config.value_type]
+          end
+        super("Evaluating #{key} couldn't coerce #{env_var_name} of #{env_var} to #{value_type}")
       end
     end
   end

data/lib/quonfig/errors/invalid_environment_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    # Raised when the requested environment (via `environment:` option or
+    # QUONFIG_ENVIRONMENT) isn't listed in the workspace's `quonfig.json`.
+    # Catches typos like `"prdoduction"` early instead of silently
+    # evaluating against default rules.
+    class InvalidEnvironmentError < Quonfig::Error
+      def initialize(environment, available = nil)
+        message = "[quonfig] Environment \"#{environment}\" not found in workspace"
+        if available && !Array(available).empty?
+          message += "; available environments: #{Array(available).join(', ')}"
+        end
+        super(message)
+      end
+    end
+  end
+end

data/lib/quonfig/errors/missing_environment_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    # Raised when datadir mode is engaged but no environment was supplied
+    # (neither the `environment:` option nor the QUONFIG_ENVIRONMENT env
+    # var is set). Datadir mode requires an explicit environment; without
+    # one the loader cannot pick the right environment row from each
+    # config's `environments` array.
+    class MissingEnvironmentError < Quonfig::Error
+      def initialize(message = nil)
+        message ||= '[quonfig] Environment required for datadir mode; ' \
+                    'set the `environment` option or QUONFIG_ENVIRONMENT env var'
+        super(message)
+      end
+    end
+  end
+end

data/lib/quonfig/evaluator.rb

@@ -409,14 +409,54 @@ module Quonfig
   # raw JSON Value hash (#value) and a coerced Ruby value (#unwrapped_value).
   # The test suite and integration helpers consume both shapes.
   class EvalResult
+    # Integer reason codes for the api-telemetry EvalSummaries wire
+    # format. Match sdk-node/src/reason.ts.
+    REASON_UNKNOWN          = 0
+    REASON_STATIC           = 1
+    REASON_TARGETING_MATCH  = 2
+    REASON_SPLIT            = 3
+
     attr_reader :value, :rule_index, :config
+    attr_accessor :weighted_value_index
 
-    def initialize(value:, rule_index:, config:)
+    def initialize(value:, rule_index:, config:, weighted_value_index: nil)
       @value = value
       @rule_index = rule_index
       @config = config
+      @weighted_value_index = weighted_value_index
     end
 
+    # Integer reason code for telemetry. Mirrors sdk-node's computeReason:
+    # SPLIT when a weighted variant is picked, STATIC when the first rule
+    # 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)
+
+      REASON_TARGETING_MATCH
+    end
+
+    # True if any rule on the config (default or environment) has a
+    # non-ALWAYS_TRUE criterion. Used to decide STATIC vs TARGETING_MATCH.
+    def self.targeting_rules?(config)
+      return false if config.nil?
+
+      rules = []
+      %i[default environment].each do |section_key|
+        section = config[section_key.to_s] || config[section_key]
+        next if section.nil?
+
+        section_rules = section['rules'] || section[:rules] || []
+        rules.concat(section_rules)
+      end
+
+      rules.any? do |rule|
+        criteria = rule['criteria'] || rule[:criteria] || []
+        criteria.any? { |c| (c['operator'] || c[:operator]) != 'ALWAYS_TRUE' }
+      end
+    end
+    private_class_method :targeting_rules?
+
     # Raw underlying value without type coercion.
     def raw_value
       return nil if @value.nil?
@@ -446,7 +486,7 @@ module Quonfig
       when 'string'      then raw.to_s
       when 'string_list' then raw.is_a?(Array) ? raw.map(&:to_s) : []
       when 'log_level'   then raw.is_a?(Numeric) ? raw : raw.to_s
-      when 'duration'    then raw.to_s
+      when 'duration'    then duration_to_millis(raw)
       when 'json'
         # JSON values must be native JS/Ruby types on the wire.
         raw
@@ -460,5 +500,27 @@ module Quonfig
     def value_type
       type
     end
+
+    private
+
+    # 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
+    # shape. Mirrors sdk-node Resolver#unwrapValue duration branch.
+    def duration_to_millis(raw)
+      case raw
+      when Numeric
+        raw.to_i
+      when String
+        seconds = Quonfig::Duration.parse(raw)
+        (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
+      else
+        raw
+      end
+    end
   end
 end

data/lib/quonfig/http_connection.rb

@@ -5,7 +5,7 @@ require 'json'
 
 module Quonfig
   class HttpConnection
-    SDK_VERSION = 'ruby-0.1.0'
+    SDK_VERSION = "ruby-#{Quonfig::VERSION}".freeze
 
     JSON_HEADERS = {
       'Content-Type' => 'application/json',

data/lib/quonfig/resolver.rb

@@ -14,6 +14,8 @@ module Quonfig
   # production read path (with config_loader, SSE updates, telemetry), see
   # Quonfig::ConfigResolver — the two coexist during the JSON migration.
   class Resolver
+    TRUE_VALUES = %w[true 1 t yes].freeze
+
     attr_reader :store, :evaluator
     attr_accessor :project_env_id
 
@@ -26,11 +28,55 @@ module Quonfig
       @store.get(key)
     end
 
+    # Look up +key+ and evaluate against +context+. Mirrors Quonfig.get_or_raise
+    # semantics: if the key is unknown to the store, raise
+    # Quonfig::Errors::MissingDefaultError so callers can distinguish "no
+    # such config" from "config matched a nil/false value". Tests that want
+    # 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).
     def get(key, context = nil)
       config = raw(key)
-      return nil unless config
+      raise Quonfig::Errors::MissingDefaultError.new(key) if config.nil?
+
+      eval_result = @evaluator.evaluate_config(config, context, resolver: self)
+      return nil if eval_result.nil?
+
+      weighted_index = nil
+      resolved_value = resolve_value(eval_result.value, config, context) do |idx|
+        weighted_index = idx
+      end
+      EvalResult.new(
+        value: resolved_value,
+        rule_index: eval_result.rule_index,
+        config: config,
+        weighted_value_index: weighted_index
+      )
+    end
+
+    # Post-evaluation value resolution. Mirrors sdk-node Resolver#resolveValue
+    # and sdk-go resolver.Resolve:
+    # - "provided" + ENV_VAR  → read ENV[lookup], coerce to config's valueType
+    # - confidential + decryptWith → look up the key config, decrypt
+    # - everything else passes through unchanged
+    def resolve_value(value, config, context = nil, &on_weighted_index)
+      return nil if value.nil?
 
-      @evaluator.evaluate_config(config, context, resolver: self)
+      type = vget(value, :type, 'type')
+
+      if type == 'provided'
+        return resolve_provided(value, config)
+      end
+
+      if type == 'weighted_values'
+        return resolve_weighted(value, config, context, &on_weighted_index)
+      end
+
+      confidential = vget(value, :confidential, 'confidential')
+      decrypt_with = vget(value, :decryptWith, 'decryptWith', :decrypt_with, 'decrypt_with')
+      return resolve_decryption(value, config, context, decrypt_with) if confidential && decrypt_with && !decrypt_with.to_s.empty?
+
+      value
     end
 
     # Integration shims for code that expects a ConfigResolver. Keep these
@@ -38,5 +84,144 @@ module Quonfig
     def symbolize_json_names?
       false
     end
+
+    private
+
+    def vget(hash, *keys)
+      return nil if hash.nil?
+
+      keys.each do |k|
+        return hash[k] if hash.is_a?(Hash) && hash.key?(k)
+      end
+      nil
+    end
+
+    def config_key(config)
+      return nil if config.nil?
+
+      vget(config, :key, 'key')
+    end
+
+    def config_value_type(config)
+      return nil if config.nil?
+
+      vget(config, :value_type, 'value_type', 'valueType', :valueType)
+    end
+
+    def resolve_provided(value, config)
+      provided = vget(value, :value, 'value')
+      return value if provided.nil?
+
+      source = vget(provided, :source, 'source')
+      lookup = vget(provided, :lookup, 'lookup')
+      return value if source != 'ENV_VAR' || lookup.nil? || lookup.to_s.empty?
+
+      env_value = ENV[lookup.to_s]
+      if env_value.nil?
+        raise Quonfig::Errors::MissingEnvVarError,
+              %(Environment variable "#{lookup}" not set for config "#{config_key(config)}")
+      end
+
+      value_type = config_value_type(config)
+      coerced = coerce_env_value(env_value, value_type, config, lookup)
+      {
+        'type' => coerced_value_type(value_type),
+        'value' => coerced
+      }
+    end
+
+    # Pick a weighted variant. Mirrors sdk-node Resolver#resolveWeightedValues
+    # and sdk-go resolveWeightedValues: hash the configured context property
+    # (or fall back to a per-call random) into [0,1), then walk the variant
+    # weights until cumulative weight >= bucket. Recurses through
+    # resolve_value so nested provided/encrypted variants work too.
+    def resolve_weighted(value, config, context, &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?
+
+      hash_property = vget(payload, :hashByPropertyName, 'hashByPropertyName',
+                           :hash_by_property_name, 'hash_by_property_name')
+      hash_value = nil
+      if hash_property && context
+        ctx_value =
+          if context.respond_to?(:get)
+            context.get(hash_property.to_s)
+          elsif context.is_a?(Hash)
+            ctx_obj = Quonfig::Context.new(context)
+            ctx_obj.get(hash_property.to_s)
+          end
+        hash_value = ctx_value.to_s unless ctx_value.nil?
+      end
+
+      cfg_key = config_key(config)
+      picker = Quonfig::WeightedValueResolver.new(weighted, cfg_key, hash_value)
+      variant, index = picker.resolve
+      on_weighted_index&.call(index)
+      variant_value = vget(variant, :value, 'value')
+      resolve_value(variant_value, config, context, &on_weighted_index)
+    end
+
+    # Recursively resolve the decryption-key config (it may itself be a
+    # provided ENV_VAR), then AES-GCM decrypt the value with that key.
+    def resolve_decryption(value, config, context, decrypt_with)
+      key_cfg = @store.get(decrypt_with)
+      raise Quonfig::Error, %(Decryption key config "#{decrypt_with}" not found) if key_cfg.nil?
+
+      key_match = @evaluator.evaluate_config(key_cfg, context, resolver: self)
+      raise Quonfig::Error, %(Decryption key config "#{decrypt_with}" did not match) if key_match.nil?
+
+      resolved_key = resolve_value(key_match.value, key_cfg, context)
+      secret_key = vget(resolved_key, :value, 'value').to_s
+      raise Quonfig::Error, %(Decryption key from "#{decrypt_with}" is empty) if secret_key.empty?
+
+      ciphertext = vget(value, :value, 'value').to_s
+      begin
+        plaintext = Quonfig::Encryption.new(secret_key).decrypt(ciphertext)
+      rescue StandardError => e
+        raise Quonfig::Errors::DecryptionError.new(config_key(config), e.message)
+      end
+
+      {
+        'type' => 'string',
+        'value' => plaintext,
+        'confidential' => true
+      }
+    end
+
+    # Coerce a raw env var string to the SDK type declared by the config.
+    # Matches sdk-node coerceValue (string/int/double/bool/string_list)
+    # and sdk-go coerceValue (string/int/double/bool). Anything else falls
+    # through as a string.
+    def coerce_env_value(env_value, value_type, config, lookup)
+      case value_type
+      when 'string', nil, ''
+        env_value
+      when 'int'
+        Integer(env_value, 10)
+      when 'double'
+        Float(env_value)
+      when 'bool'
+        TRUE_VALUES.include?(env_value.downcase)
+      when 'string_list'
+        env_value.split(/\s*,\s*/)
+      when 'duration'
+        env_value
+      else
+        env_value
+      end
+    rescue ArgumentError, TypeError
+      raise Quonfig::Errors::EnvVarParseError.new(env_value, config, lookup)
+    end
+
+    def coerced_value_type(value_type)
+      case value_type
+      when 'int'         then 'int'
+      when 'double'      then 'double'
+      when 'bool'        then 'bool'
+      when 'string_list' then 'string_list'
+      else 'string'
+      end
+    end
   end
 end