openfeature-sdk-sorbet 0.1.0

data/lib/open_feature/configuration.rb

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "singleton"
+
+module OpenFeature
+  # Singleton class that supports global configuration for OpenFeature.
+  # Should not be interacted with directly; rather, favor interacting
+  # with methods defined on the `OpenFeature` module.
+  class Configuration
+    extend T::Sig
+
+    include Singleton
+
+    sig { returns(Provider) }
+    attr_reader :provider
+
+    sig { returns(T::Array[Hook]) }
+    attr_reader :hooks
+
+    sig { void }
+    def initialize
+      @provider = T.let(NoOpProvider.new, Provider)
+      @hooks = T.let([], T::Array[Hook])
+    end
+
+    sig { returns(ProviderMetadata) }
+    def provider_metadata
+      provider.metadata
+    end
+
+    sig { params(provider: Provider).void }
+    def set_provider(provider) # rubocop:disable Naming/AccessorMethodName
+      @provider = provider
+    end
+
+    sig { params(hooks: T.any(Hook, T::Array[Hook])).void }
+    def add_hooks(hooks)
+      @hooks.concat(Array(hooks))
+    end
+
+    sig { void }
+    def clear_hooks!
+      @hooks = []
+    end
+  end
+end

data/lib/open_feature/error_code.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  # Possible error codes
+  class ErrorCode < T::Enum
+    enums do
+      ProviderNotReady = new("PROVIDER_NOT_READY")
+      FlagNotFound = new("FLAG_NOT_FOUND")
+      ParseError = new("PARSE_ERROR")
+      TypeMismatch = new("TYPE_MISMATCH")
+      TargetingKeyMissing = new("TARGETING_KEY_MISSING")
+      InvalidContext = new("INVALID_CONTEXT")
+      General = new("GENERAL")
+    end
+  end
+end

data/lib/open_feature/evaluation_context.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  # Provides ambient information for the purposes of flag evaluation.
+  # Currently does not meet specification!
+  class EvaluationContext < T::Struct
+    const :targeting_key, T.nilable(String)
+  end
+end

data/lib/open_feature/evaluation_details.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  # Information about resolved value, created by a Provider.
+  class EvaluationDetails < T::Struct
+    extend T::Generic
+
+    include T::Struct::ActsAsComparable
+
+    Value = type_member
+    SelfValue = type_template
+
+    const :flag_key, String
+    const :value, Value
+    const :error_code, T.nilable(ErrorCode)
+    const :error_message, T.nilable(String)
+    const :reason, T.nilable(String)
+    const :variant, T.nilable(String)
+    const :flag_metadata, T.nilable(FlagMetadata)
+
+    class << self
+      extend T::Sig
+
+      sig { params(details: ResolutionDetails[SelfValue], flag_key: String).returns(EvaluationDetails[SelfValue]) }
+      def from_resolution_details(details, flag_key:)
+        EvaluationDetails.new(
+          flag_key: flag_key,
+          value: details.value,
+          error_code: details.error_code,
+          error_message: details.error_message,
+          variant: details.variant,
+          reason: details.reason,
+          flag_metadata: details.flag_metadata
+        )
+      end
+
+      sig do
+        params(
+          error_message: String,
+          flag_key: String,
+          default_value: SelfValue
+        ).returns(EvaluationDetails[SelfValue])
+      end
+      def from_error(error_message, flag_key:, default_value:)
+        EvaluationDetails.new(
+          flag_key: flag_key,
+          value: default_value,
+          error_code: ErrorCode::General,
+          error_message: "Provider raised error: #{error_message}",
+          reason: "ERROR"
+        )
+      end
+    end
+  end
+end

data/lib/open_feature/evaluation_options.rb

@@ -0,0 +1,9 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  # Additional options to be supplied to client during flag evaluation.
+  class EvaluationOptions < T::Struct
+    const :hooks, T::Array[Hook], default: []
+  end
+end

data/lib/open_feature/flag_metadata.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  FlagMetadata = T.type_alias { T::Hash[String, T.any(T::Boolean, String, Numeric)] }
+end

data/lib/open_feature/hook.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  class Hook < T::Struct; end
+end

data/lib/open_feature/no_op_provider.rb

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  # Default provider when initializing OpenFeature.
+  # Always returns the default value given.
+  # This will result in a TypeError if the given default value does not have the correct type.
+  class NoOpProvider
+    extend T::Sig
+
+    include Provider
+
+    sig { override.returns(ProviderMetadata) }
+    attr_reader :metadata
+
+    sig { override.returns(T::Array[Hook]) }
+    attr_reader :hooks
+
+    sig { void }
+    def initialize
+      @metadata = T.let(ProviderMetadata.new(name: "No Op Provider"), ProviderMetadata)
+      @hooks = T.let([], T::Array[Hook])
+    end
+
+    sig do
+      override
+        .params(
+          flag_key: String,
+          default_value: T::Boolean,
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[T::Boolean])
+    end
+    def resolve_boolean_value(flag_key:, default_value:, context: nil)
+      ResolutionDetails.new(value: default_value, reason: "DEFAULT")
+    end
+
+    sig do
+      override
+        .params(
+          flag_key: String,
+          default_value: String,
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[String])
+    end
+    def resolve_string_value(flag_key:, default_value:, context: nil)
+      ResolutionDetails.new(value: default_value, reason: "DEFAULT")
+    end
+
+    sig do
+      override
+        .params(
+          flag_key: String,
+          default_value: Numeric,
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[Numeric])
+    end
+    def resolve_number_value(flag_key:, default_value:, context: nil)
+      ResolutionDetails.new(value: default_value, reason: "DEFAULT")
+    end
+
+    sig do
+      override
+        .params(
+          flag_key: String,
+          default_value: T::Hash[T.untyped, T.untyped],
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[T::Hash[T.untyped, T.untyped]])
+    end
+    def resolve_structure_value(flag_key:, default_value:, context: nil)
+      ResolutionDetails.new(value: default_value, reason: "DEFAULT")
+    end
+  end
+end

data/lib/open_feature/provider.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  # Interface that providers must implement.
+  module Provider
+    extend T::Sig
+    extend T::Helpers
+    interface!
+
+    sig { abstract.returns(ProviderMetadata) }
+    def metadata; end
+
+    sig { abstract.returns(T::Array[Hook]) }
+    def hooks; end
+
+    sig do
+      abstract
+        .params(
+          flag_key: String,
+          default_value: T::Boolean,
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[T::Boolean])
+    end
+    def resolve_boolean_value(flag_key:, default_value:, context: nil); end
+
+    sig do
+      abstract
+        .params(
+          flag_key: String,
+          default_value: String,
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[String])
+    end
+    def resolve_string_value(flag_key:, default_value:, context: nil); end
+
+    sig do
+      abstract
+        .params(
+          flag_key: String,
+          default_value: Numeric,
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[Numeric])
+    end
+    def resolve_number_value(flag_key:, default_value:, context: nil); end
+
+    sig do
+      abstract
+        .params(
+          flag_key: String,
+          default_value: T::Hash[T.untyped, T.untyped],
+          context: T.nilable(EvaluationContext)
+        )
+        .returns(ResolutionDetails[T::Hash[T.untyped, T.untyped]])
+    end
+    def resolve_structure_value(flag_key:, default_value:, context: nil); end
+  end
+end

data/lib/open_feature/provider_metadata.rb

@@ -0,0 +1,11 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  # Defines information about a Provider.
+  class ProviderMetadata < T::Struct
+    include T::Struct::ActsAsComparable
+
+    const :name, String
+  end
+end

data/lib/open_feature/resolution_details.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenFeature
+  # Information about resolved value, created by a Provider.
+  class ResolutionDetails < T::Struct
+    extend T::Generic
+
+    include T::Struct::ActsAsComparable
+
+    Value = type_member
+
+    const :value, Value
+    const :error_code, T.nilable(ErrorCode)
+    const :error_message, T.nilable(String)
+    const :reason, T.nilable(String)
+    const :variant, T.nilable(String)
+    const :flag_metadata, T.nilable(FlagMetadata)
+  end
+end

data/lib/open_feature.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require "sorbet-struct-comparable"
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+# Sorbet-aware implementation of the OpenFeature specification
+module OpenFeature
+  class << self
+    extend T::Sig
+
+    sig { returns(ProviderMetadata) }
+    def provider_metadata
+      configuration.provider_metadata
+    end
+
+    sig { params(provider: Provider).void }
+    def set_provider(provider) # rubocop:disable Naming/AccessorMethodName
+      configuration.set_provider(provider)
+    end
+
+    sig { params(hooks: T.any(Hook, T::Array[Hook])).void }
+    def add_hooks(hooks)
+      configuration.add_hooks(hooks)
+    end
+
+    sig { params(name: T.nilable(String)).returns(Client) }
+    def create_client(name: nil)
+      Client.new(provider: configuration.provider, name: name)
+    end
+
+    sig { returns(Configuration) }
+    def configuration
+      Configuration.instance
+    end
+  end
+end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end