optify-config 1.4.2

data/ext/optify_ruby/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "optify_ruby"
+version = "0.9.0"
+edition = "2021"
+
+description = "optify bindings for Ruby"
+homepage = "https://github.com/juharris/optify/tree/main/ruby"
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/juharris/optify"
+
+categories = ["config"]
+keywords = ["configuration", "options", "ruby"]
+
+exclude = [
+    "tests/*",
+]
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = "0.7.1"
+optify = { path = "../../../../rust/optify", version = "0.9.0" }
+rb-sys = { version = "*", default-features = false, features = ["ruby-static"] }
+serde_json = "1.0.140"

data/ext/optify_ruby/extconf.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+# typed: false
+
+require 'mkmf'
+require 'rb_sys/mkmf'
+
+create_rust_makefile('optify_ruby/optify_ruby') do |r|
+  r.profile = ENV.fetch('RB_SYS_CARGO_PROFILE', :dev).to_sym
+  puts "RB_SYS_CARGO_PROFILE: #{r.profile}"
+end

data/ext/optify_ruby/src/lib.rs

@@ -0,0 +1,445 @@
+use magnus::{function, method, prelude::*, wrap, Object, Ruby};
+use optify::builder::OptionsProviderBuilder;
+use optify::builder::OptionsRegistryBuilder;
+use optify::builder::OptionsWatcherBuilder;
+use optify::convert_to_str_slice;
+use optify::provider::GetOptionsPreferences;
+use optify::provider::OptionsProvider;
+use optify::provider::OptionsRegistry;
+use optify::provider::OptionsWatcher;
+use optify::schema::metadata::OptionsMetadata;
+use std::cell::RefCell;
+
+#[derive(Clone)]
+#[wrap(class = "Optify::GetOptionsPreferences")]
+struct MutGetOptionsPreferences(RefCell<GetOptionsPreferences>);
+
+impl MutGetOptionsPreferences {
+    fn new() -> Self {
+        Self(RefCell::new(GetOptionsPreferences {
+            overrides_json: None,
+            skip_feature_name_conversion: false,
+        }))
+    }
+
+    // Overrides Section
+    fn has_overrides(&self) -> bool {
+        self.0.borrow().overrides_json.is_some()
+    }
+
+    fn set_overrides_json(&self, overrides: Option<String>) {
+        self.0.borrow_mut().overrides_json = overrides;
+    }
+
+    fn get_overrides_json(&self) -> Option<String> {
+        self.0.borrow().overrides_json.clone()
+    }
+
+    // Skip Feature Name Conversion Section
+    fn set_skip_feature_name_conversion(&self, value: bool) {
+        self.0.borrow_mut().skip_feature_name_conversion = value;
+    }
+
+    fn skip_feature_name_conversion(&self) -> bool {
+        self.0.borrow().skip_feature_name_conversion
+    }
+}
+
+#[wrap(class = "Optify::OptionsProvider")]
+struct WrappedOptionsProvider(RefCell<OptionsProvider>);
+
+fn convert_metadata(metadata: &OptionsMetadata) -> String {
+    serde_json::to_string(metadata).unwrap()
+}
+
+impl WrappedOptionsProvider {
+    // These methods cannot accept `str`s because of how magnus works.
+    // Return the JSON as a string so that it can be deserialized easily into a specific immutable class in Ruby.
+    fn get_all_options_json(
+        ruby: &Ruby,
+        rb_self: &Self,
+        feature_names: Vec<String>,
+        preferences: &MutGetOptionsPreferences,
+    ) -> Result<String, magnus::Error> {
+        let _preferences = convert_preferences(preferences);
+        let features = convert_to_str_slice!(feature_names);
+        match rb_self
+            .0
+            .borrow()
+            .get_all_options(&features, &None, &_preferences)
+        {
+            Ok(options) => Ok(options.to_string()),
+            Err(e) => Err(magnus::Error::new(ruby.exception_exception(), e)),
+        }
+    }
+
+    fn get_canonical_feature_name(
+        ruby: &Ruby,
+        rb_self: &Self,
+        feature_name: String,
+    ) -> Result<String, magnus::Error> {
+        rb_self
+            .0
+            .borrow()
+            .get_canonical_feature_name(&feature_name)
+            .map_err(|e| magnus::Error::new(ruby.exception_exception(), e))
+    }
+
+    fn get_canonical_feature_names(
+        ruby: &Ruby,
+        rb_self: &Self,
+        feature_names: Vec<String>,
+    ) -> Result<Vec<String>, magnus::Error> {
+        let features = convert_to_str_slice!(feature_names);
+        rb_self
+            .0
+            .borrow()
+            .get_canonical_feature_names(&features)
+            .map_err(|e| magnus::Error::new(ruby.exception_exception(), e))
+    }
+
+    fn get_feature_metadata_json(&self, canonical_feature_name: String) -> Option<String> {
+        self.0
+            .borrow()
+            .get_feature_metadata(&canonical_feature_name)
+            .map(|metadata| convert_metadata(&metadata))
+    }
+
+    fn get_features(&self) -> Vec<String> {
+        self.0.borrow().get_features()
+    }
+
+    // Return a string because it wasn't clear how to return a type defined in Rust despite looking at docs and trying a few examples.
+    fn get_features_with_metadata_json(&self) -> String {
+        serde_json::to_string(&self.0.borrow().get_features_with_metadata()).unwrap()
+    }
+
+    // Return a string because it wasn't clear how to return a type defined in Rust despite looking at docs and trying a few examples.
+    fn get_options_json(
+        ruby: &Ruby,
+        rb_self: &Self,
+        key: String,
+        feature_names: Vec<String>,
+    ) -> Result<String, magnus::Error> {
+        let features = convert_to_str_slice!(feature_names);
+        match rb_self
+            .0
+            .borrow()
+            .get_options_with_preferences(&key, &features, &None, &None)
+        {
+            Ok(options) => Ok(options.to_string()),
+            Err(e) => Err(magnus::Error::new(ruby.exception_exception(), e)),
+        }
+    }
+
+    fn get_options_json_with_preferences(
+        ruby: &Ruby,
+        rb_self: &Self,
+        key: String,
+        feature_names: Vec<String>,
+        preferences: &MutGetOptionsPreferences,
+    ) -> Result<String, magnus::Error> {
+        let _preferences = convert_preferences(preferences);
+        let features = convert_to_str_slice!(feature_names);
+        match rb_self
+            .0
+            .borrow()
+            .get_options_with_preferences(&key, &features, &None, &_preferences)
+        {
+            Ok(options) => Ok(options.to_string()),
+            Err(e) => Err(magnus::Error::new(ruby.exception_exception(), e)),
+        }
+    }
+}
+
+fn convert_preferences(preferences: &MutGetOptionsPreferences) -> Option<GetOptionsPreferences> {
+    Some(optify::provider::GetOptionsPreferences {
+        overrides_json: preferences.get_overrides_json(),
+        skip_feature_name_conversion: preferences.skip_feature_name_conversion(),
+    })
+}
+
+#[derive(Clone)]
+#[wrap(class = "Optify::OptionsProviderBuilder")]
+struct WrappedOptionsProviderBuilder(RefCell<OptionsProviderBuilder>);
+
+impl WrappedOptionsProviderBuilder {
+    fn new() -> Self {
+        Self(RefCell::new(OptionsProviderBuilder::new()))
+    }
+
+    fn add_directory(
+        ruby: &Ruby,
+        rb_self: &Self,
+        directory: String,
+    ) -> Result<WrappedOptionsProviderBuilder, magnus::Error> {
+        let path = std::path::Path::new(&directory);
+        match rb_self.0.borrow_mut().add_directory(path) {
+            Ok(builder) => Ok(WrappedOptionsProviderBuilder(RefCell::new(builder.clone()))),
+            Err(e) => Err(magnus::Error::new(ruby.exception_exception(), e)),
+        }
+    }
+
+    fn build(ruby: &Ruby, rb_self: &Self) -> Result<WrappedOptionsProvider, magnus::Error> {
+        match rb_self.0.borrow_mut().build() {
+            Ok(provider) => Ok(WrappedOptionsProvider(RefCell::new(provider))),
+            Err(e) => Err(magnus::Error::new(ruby.exception_exception(), e)),
+        }
+    }
+}
+
+#[wrap(class = "Optify::OptionsWatcher")]
+struct WrappedOptionsWatcher(RefCell<OptionsWatcher>);
+
+impl WrappedOptionsWatcher {
+    fn get_all_options_json(
+        ruby: &Ruby,
+        rb_self: &Self,
+        feature_names: Vec<String>,
+        preferences: &MutGetOptionsPreferences,
+    ) -> Result<String, magnus::Error> {
+        let _preferences = convert_preferences(preferences);
+        let features = convert_to_str_slice!(feature_names);
+        match rb_self
+            .0
+            .borrow()
+            .get_all_options(&features, &None, &_preferences)
+        {
+            Ok(options) => Ok(options.to_string()),
+            Err(e) => Err(magnus::Error::new(ruby.exception_exception(), e)),
+        }
+    }
+
+    fn get_canonical_feature_name(
+        ruby: &Ruby,
+        rb_self: &Self,
+        feature_name: String,
+    ) -> Result<String, magnus::Error> {
+        rb_self
+            .0
+            .borrow()
+            .get_canonical_feature_name(&feature_name)
+            .map_err(|e| magnus::Error::new(ruby.exception_exception(), e))
+    }
+
+    fn get_canonical_feature_names(
+        ruby: &Ruby,
+        rb_self: &Self,
+        feature_names: Vec<String>,
+    ) -> Result<Vec<String>, magnus::Error> {
+        let features = convert_to_str_slice!(feature_names);
+        rb_self
+            .0
+            .borrow()
+            .get_canonical_feature_names(&features)
+            .map_err(|e| magnus::Error::new(ruby.exception_exception(), e))
+    }
+
+    fn get_feature_metadata_json(&self, canonical_feature_name: String) -> Option<String> {
+        self.0
+            .borrow()
+            .get_feature_metadata(&canonical_feature_name)
+            .map(|metadata| convert_metadata(&metadata))
+    }
+
+    fn get_features(&self) -> Vec<String> {
+        self.0.borrow().get_features()
+    }
+
+    fn get_features_with_metadata_json(&self) -> String {
+        serde_json::to_string(&self.0.borrow().get_features_with_metadata()).unwrap()
+    }
+
+    fn get_options_json(
+        ruby: &Ruby,
+        rb_self: &Self,
+        key: String,
+        feature_names: Vec<String>,
+    ) -> Result<String, magnus::Error> {
+        let features = convert_to_str_slice!(feature_names);
+        match rb_self
+            .0
+            .borrow()
+            .get_options_with_preferences(&key, &features, &None, &None)
+        {
+            Ok(options) => Ok(options.to_string()),
+            Err(e) => Err(magnus::Error::new(ruby.exception_exception(), e)),
+        }
+    }
+
+    fn get_options_json_with_preferences(
+        ruby: &Ruby,
+        rb_self: &Self,
+        key: String,
+        feature_names: Vec<String>,
+        preferences: &MutGetOptionsPreferences,
+    ) -> Result<String, magnus::Error> {
+        let _preferences = convert_preferences(preferences);
+        let features = convert_to_str_slice!(feature_names);
+        match rb_self
+            .0
+            .borrow()
+            .get_options_with_preferences(&key, &features, &None, &_preferences)
+        {
+            Ok(options) => Ok(options.to_string()),
+            Err(e) => Err(magnus::Error::new(ruby.exception_exception(), e)),
+        }
+    }
+
+    fn last_modified(&self) -> std::time::SystemTime {
+        self.0.borrow().last_modified()
+    }
+}
+
+#[derive(Clone)]
+#[wrap(class = "Optify::OptionsWatcherBuilder")]
+struct WrappedOptionsWatcherBuilder(RefCell<OptionsWatcherBuilder>);
+
+impl WrappedOptionsWatcherBuilder {
+    fn new() -> Self {
+        Self(RefCell::new(OptionsWatcherBuilder::new()))
+    }
+
+    fn add_directory(
+        ruby: &Ruby,
+        rb_self: &Self,
+        directory: String,
+    ) -> Result<WrappedOptionsWatcherBuilder, magnus::Error> {
+        let path = std::path::Path::new(&directory);
+        match rb_self.0.borrow_mut().add_directory(path) {
+            Ok(builder) => Ok(WrappedOptionsWatcherBuilder(RefCell::new(builder.clone()))),
+            Err(e) => Err(magnus::Error::new(ruby.exception_exception(), e)),
+        }
+    }
+
+    fn build(ruby: &Ruby, rb_self: &Self) -> Result<WrappedOptionsWatcher, magnus::Error> {
+        match rb_self.0.borrow_mut().build() {
+            Ok(provider) => Ok(WrappedOptionsWatcher(RefCell::new(provider))),
+            Err(e) => Err(magnus::Error::new(ruby.exception_exception(), e)),
+        }
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
+    let module = ruby.define_module("Optify")?;
+
+    let builder_class = module.define_class("OptionsProviderBuilder", ruby.class_object())?;
+
+    builder_class
+        .define_singleton_method("new", function!(WrappedOptionsProviderBuilder::new, 0))?;
+    builder_class.define_method(
+        "add_directory",
+        method!(WrappedOptionsProviderBuilder::add_directory, 1),
+    )?;
+    builder_class.define_method("build", method!(WrappedOptionsProviderBuilder::build, 0))?;
+
+    let provider_class = module.define_class("OptionsProvider", ruby.class_object())?;
+    provider_class.define_method("features", method!(WrappedOptionsProvider::get_features, 0))?;
+    provider_class.define_method(
+        "get_all_options_json",
+        method!(WrappedOptionsProvider::get_all_options_json, 2),
+    )?;
+    provider_class.define_method(
+        "get_canonical_feature_name",
+        method!(WrappedOptionsProvider::get_canonical_feature_name, 1),
+    )?;
+    provider_class.define_method(
+        "get_options_json",
+        method!(WrappedOptionsProvider::get_options_json, 2),
+    )?;
+    provider_class.define_method(
+        "get_options_json_with_preferences",
+        method!(WrappedOptionsProvider::get_options_json_with_preferences, 3),
+    )?;
+
+    // Private methods for internal use.
+    provider_class.define_private_method(
+        "_get_canonical_feature_names",
+        method!(WrappedOptionsProvider::get_canonical_feature_names, 1),
+    )?;
+    provider_class.define_private_method(
+        "features_with_metadata_json",
+        method!(WrappedOptionsProvider::get_features_with_metadata_json, 0),
+    )?;
+    provider_class.define_private_method(
+        "get_feature_metadata_json",
+        method!(WrappedOptionsProvider::get_feature_metadata_json, 1),
+    )?;
+
+    let get_options_preferences_class =
+        module.define_class("GetOptionsPreferences", ruby.class_object())?;
+    get_options_preferences_class
+        .define_singleton_method("new", function!(MutGetOptionsPreferences::new, 0))?;
+    get_options_preferences_class
+        .define_method("dup", method!(MutGetOptionsPreferences::clone, 0))?;
+    get_options_preferences_class.define_method(
+        "overrides?",
+        method!(MutGetOptionsPreferences::has_overrides, 0),
+    )?;
+    get_options_preferences_class.define_method(
+        "overrides_json=",
+        method!(MutGetOptionsPreferences::set_overrides_json, 1),
+    )?;
+    get_options_preferences_class.define_method(
+        "skip_feature_name_conversion=",
+        method!(
+            MutGetOptionsPreferences::set_skip_feature_name_conversion,
+            1
+        ),
+    )?;
+    get_options_preferences_class.define_method(
+        "skip_feature_name_conversion",
+        method!(MutGetOptionsPreferences::skip_feature_name_conversion, 0),
+    )?;
+
+    let watcher_builder_class =
+        module.define_class("OptionsWatcherBuilder", ruby.class_object())?;
+    watcher_builder_class
+        .define_singleton_method("new", function!(WrappedOptionsWatcherBuilder::new, 0))?;
+    watcher_builder_class.define_method(
+        "add_directory",
+        method!(WrappedOptionsWatcherBuilder::add_directory, 1),
+    )?;
+    watcher_builder_class
+        .define_method("build", method!(WrappedOptionsWatcherBuilder::build, 0))?;
+
+    let watcher_class = module.define_class("OptionsWatcher", ruby.class_object())?;
+    watcher_class.define_method("features", method!(WrappedOptionsWatcher::get_features, 0))?;
+    watcher_class.define_method(
+        "get_all_options_json",
+        method!(WrappedOptionsWatcher::get_all_options_json, 2),
+    )?;
+    watcher_class.define_method(
+        "get_canonical_feature_name",
+        method!(WrappedOptionsWatcher::get_canonical_feature_name, 1),
+    )?;
+    watcher_class.define_method(
+        "get_options_json",
+        method!(WrappedOptionsWatcher::get_options_json, 2),
+    )?;
+    watcher_class.define_method(
+        "get_options_json_with_preferences",
+        method!(WrappedOptionsWatcher::get_options_json_with_preferences, 3),
+    )?;
+    watcher_class.define_method(
+        "last_modified",
+        method!(WrappedOptionsWatcher::last_modified, 0),
+    )?;
+
+    // Private methods for internal use.
+    watcher_class.define_private_method(
+        "features_with_metadata_json",
+        method!(WrappedOptionsWatcher::get_features_with_metadata_json, 0),
+    )?;
+    watcher_class.define_private_method(
+        "_get_canonical_feature_names",
+        method!(WrappedOptionsWatcher::get_canonical_feature_names, 1),
+    )?;
+    watcher_class.define_private_method(
+        "get_feature_metadata_json",
+        method!(WrappedOptionsWatcher::get_feature_metadata_json, 1),
+    )?;
+
+    Ok(())
+}

data/lib/optify.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# typed: strict
+
+# The implementation to use directly Ruby and with types declared.
+require_relative 'optify_ruby/get_options_preferences'
+require_relative 'optify_ruby/implementation'
+require_relative 'optify_ruby/watcher_implementation'
+
+# The implementation in Rust which redefines some methods.
+# This yields some warnings, but we should redeclare the methods in Ruby to help with type checking anyway.
+# Warnings about redefining methods are normal and can be ignored
+# because the implementations in Ruby are not implemented and only exist to help with type checking.
+# Ideally we do:
+# `require_relative 'optify_ruby/optify_ruby'`
+# but that doesn't work when building for multiple versions of Ruby.
+# So we have to do this which is similar to something from 'https://github.com/matsadler/halton-rb/blob/main/lib/halton.rb'.
+begin
+  ruby_version = T.must(RUBY_VERSION.match(/\d+\.\d+/))[0]
+  require_relative "optify_ruby/#{ruby_version}/optify_ruby"
+rescue LoadError
+  begin
+    require_relative 'optify_ruby/optify_ruby'
+  rescue LoadError # Cargo Builder in RubyGems < 3.4.6 doesn't install to dir
+    require_relative 'optify_ruby.so'
+  end
+end
+
+require_relative 'optify_ruby/base_config'

data/lib/optify_ruby/base_config.rb

@@ -0,0 +1,99 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'tapioca'
+
+module Optify
+  # A base class for classes from configuration files.
+  # Classes that derive from this can easily be used with `Optify::OptionsProvider.get_options`
+  # because they will have an implementation of `from_hash` that works recursively.
+  # This class is a work in progress with minimal error handling
+  # and doesn't handle certain cases such as nilable types yet.
+  # It may be moved to another gem in the future.
+  class BaseConfig
+    extend T::Sig
+    extend T::Helpers
+    abstract!
+
+    # Create a new immutable instance of the class from a hash.
+    #
+    # This is a class method that so that it can set members with private setters.
+    # @param hash The hash to create the instance from.
+    # @return The new instance.
+    #: (Hash[untyped, untyped] hash) -> instance
+    def self.from_hash(hash)
+      instance = new
+
+      hash.each do |key, value|
+        sig_return_type = T::Utils.signature_for_method(instance_method(key)).return_type
+        value = _convert_value(value, sig_return_type)
+        instance.instance_variable_set("@#{key}", value)
+      end
+
+      instance.freeze
+    end
+
+    #: (untyped value, untyped type) -> untyped
+    def self._convert_value(value, type)
+      if type.is_a?(T::Types::Untyped)
+        # No preferred type is given, so return the value as is.
+        return value
+      end
+
+      return value.to_sym if type.is_a?(T::Types::Simple) && type.raw_type == Symbol
+
+      case value
+      when Array
+        # Handle `T.nilable(T::Array[...])`
+        type = type.unwrap_nilable if type.respond_to?(:unwrap_nilable)
+        inner_type = type.type
+        return value.map { |v| _convert_value(v, inner_type) }.freeze
+      when Hash
+        # Handle `T.nilable(T::Hash[...])` and `T.any(...)`.
+        # We used to use `type = type.unwrap_nilable if type.respond_to?(:unwrap_nilable)`, but it's not needed now that we handle `T.any(...)`
+        # because using `.types` works for both cases.
+        if type.respond_to?(:types)
+          # Find a type that works for the hash.
+          type.types.each do |t|
+            return _convert_hash(value, t).freeze
+          rescue StandardError
+            # Ignore and try the next type.
+          end
+          raise TypeError, "Could not convert hash: #{value} to #{type}."
+        end
+        return _convert_hash(value, type).freeze
+      end
+
+      # It would be nice to validate that the value is of the correct type here.
+      # For example that a string is a string and an Integer is an Integer.
+      value
+    end
+
+    #: (Hash[untyped, untyped] hash, untyped type) -> untyped
+    def self._convert_hash(hash, type)
+      if type.respond_to?(:raw_type)
+        # There is an object for the hash.
+        # It could be a custom class, a String, or maybe something else.
+        type_for_hash = type.raw_type
+        return type_for_hash.from_hash(hash) if type_for_hash.respond_to?(:from_hash)
+      elsif type.is_a?(T::Types::TypedHash)
+        # The hash should be a hash, but the values might be objects to convert.
+        type_for_keys = type.keys
+
+        convert_key = if type_for_keys.is_a?(T::Types::Simple) && type_for_keys.raw_type == Symbol
+                        lambda(&:to_sym)
+                      else
+                        lambda(&:itself)
+                      end
+
+        type_for_values = type.values
+        return hash.map { |k, v| [convert_key.call(k), _convert_value(v, type_for_values)] }.to_h
+      end
+
+      raise TypeError, "Could not convert hash #{hash} to `#{type}`."
+    end
+
+    private_class_method :_convert_hash, :_convert_value
+  end
+end

data/lib/optify_ruby/get_options_preferences.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Optify
+  # Preferences for `get_options`.
+  class GetOptionsPreferences
+    # @param overrides [Hash]
+    #: (Hash[untyped, untyped] overrides) -> void
+    def overrides=(overrides)
+      self.overrides_json = overrides.to_json
+    end
+  end
+end

data/lib/optify_ruby/implementation.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# typed: strict
+
+require 'json'
+
+require 'sorbet-runtime'
+
+require_relative './base_config'
+require_relative './options_metadata'
+require_relative './provider_module'
+
+# Tools for working with configurations declared in files.
+module Optify
+  # Options for caching.
+  # Only enabling or disabling caching is supported for now.
+  class CacheOptions < BaseConfig
+  end
+
+  # Provides configurations based on keys and enabled feature names.
+  class OptionsProvider
+    include ProviderModule
+
+    # TODO: Find a better way to proxy the methods with copying the parameters.
+
+    #: -> Hash[String, OptionsMetadata]
+    def features_with_metadata
+      _features_with_metadata
+    end
+
+    #: [Config] (String key, Array[String] feature_names, Class[Config] config_class, ?CacheOptions? cache_options, ?Optify::GetOptionsPreferences? preferences) -> Config
+    def get_options(key, feature_names, config_class, cache_options = nil, preferences = nil)
+      _get_options(key, feature_names, config_class, cache_options, preferences)
+    end
+
+    # (Optional) Eagerly initializes the cache.
+    # @return [OptionsProvider] `self`.
+    #: -> OptionsProvider
+    def init
+      _init
+      self
+    end
+  end
+end

data/lib/optify_ruby/options_metadata.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# typed: true
+
+require 'sorbet-runtime'
+
+require_relative './base_config'
+
+module Optify
+  # Information about a feature.
+  class OptionsMetadata < BaseConfig
+    sig { returns(T.nilable(T::Array[String])) }
+    attr_reader :aliases
+
+    sig { returns(T.untyped) }
+    attr_reader :details
+
+    sig { returns(String) }
+    attr_reader :name
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :owners
+  end
+end