optify-config 0.3.1-aarch64-linux → 0.4.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ca08576e6486f44d10f34b164024a7b1827d9821b45e73a33eb6ff80689cc90
-  data.tar.gz: 00403717bb667efee520dc03a1a169d0592fc34216802083d2f71fca1158ba72
+  metadata.gz: 611e7281161b4cbfb2eda37e7c32426e250e1a87887abc45e816d0de1b813436
+  data.tar.gz: 67106b7a8c6a8d60d012bd47e759e3ddf8ee5a1b59ac88884a467cdcf6b9263e
 SHA512:
-  metadata.gz: 56f54eb5bcf62da381d6c1397b1858c48228cd270a48a3c33a6c9882fc5f168d3afdbcad163f7069b7a911dbf403188910ce38eaebdf8140e26d5a046f14dd1a
-  data.tar.gz: 8dfb6107be09d5b942a208be82d9c95bcecd561d41413a722845a939e54bbecde3194dac9803a0542b90e71c1e398e6e8afbbefe7172ea920945cf43ede3fe8d
+  metadata.gz: 24b8f1fce24e36953973e0629130413295b41426c686185d03f1e49446eb0fc9679d81ba1e21d07e98870ad2a3930ef5941d9d97ab50fb4b4a10c1ff05523a11
+  data.tar.gz: c5fdeb41e5f2fc5aa42dec4fe479c8fec2b9669b46b8851e16bf0b0cd0a4d10046dbf6954bc4d3b215f88485ebed953a91be4ebd093080642f7979e8495b349a

data/lib/optify_ruby/base_config.rb

@@ -18,6 +18,7 @@ module Optify
 
     # Create a new instance of the class from a hash.
     #
+    # This is a class method that so that it can set members with private setters.
     # @param hash [Hash] The hash to create the instance from.
     # @return The new instance.
     sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T.attached_class) }
@@ -25,24 +26,66 @@ module Optify
       result = new
 
       hash.each do |key, value|
-        # TODO: Might need some error handling here, but it should be fine if type signatures are used.
-        # TODO Handle nilable types.
-        case value
-        when Array
-          sig_return_type = T::Utils.signature_for_method(instance_method(key)).return_type
-          inner_type = sig_return_type.type.raw_type
-          value = value.map { |v| inner_type.from_hash(v) } if inner_type.respond_to?(:from_hash)
-        when Hash
-          sig_return_type = T::Utils.signature_for_method(instance_method(key)).return_type
-          if sig_return_type.respond_to?(:raw_type)
-            type_for_key = sig_return_type.raw_type
-            value = type_for_key.from_hash(value) if type_for_key.respond_to?(:from_hash)
+        sig_return_type = T::Utils.signature_for_method(instance_method(key)).return_type
+        value = _convert_value(value, sig_return_type)
+        result.instance_variable_set("@#{key}", value)
+      end
+      result
+    end
+
+    sig { params(value: T.untyped, type: T.untyped).returns(T.untyped) }
+    def self._convert_value(value, type)
+      case value
+      when Array
+        type = if type.type.respond_to?(:unwrap_nilable)
+                 # Handle nilable array.
+                 type.type.unwrap_nilable
+               else
+                 # Handle array of 1 type.
+                 type.type
+               end
+        return value.map { |v| _convert_value(v, type) }
+      when Hash
+        # Handle nilable hash.
+        type = type.unwrap_nilable if type.respond_to?(:unwrap_nilable)
+        return _convert_hash(value, type)
+      end
+
+      value
+    end
+
+    sig do
+      params(
+        hash: T::Hash[T.untyped, T.untyped],
+        type: T.untyped
+      ).returns(T.untyped)
+    end
+    def self._convert_hash(hash, type) # rubocop:disable Metrics/PerceivedComplexity
+      if type.respond_to?(:raw_type)
+        # There is an object for the hash.
+        type_for_hash = type.raw_type
+        return type_for_hash.from_hash(hash) if type_for_hash.respond_to?(:from_hash)
+      elsif type.instance_of?(T::Types::TypedHash)
+        # The hash should be a hash, but the values might be objects to convert.
+        type_for_values = type.values
+
+        if type_for_values.respond_to?(:raw_type)
+          raw_type_for_values = type_for_values.raw_type
+          if raw_type_for_values.respond_to?(:from_hash)
+            # Use proper types.
+            return hash.transform_values { |v| raw_type_for_values.from_hash(v) }
           end
         end
 
-        result.instance_variable_set("@#{key}", value)
+        # The values are not recognized objects.
+        return hash.transform_values { |v| _convert_value(v, type_for_values) }
       end
-      result
+
+      # Fallback to doing nothing.
+      # This can happen if there are is no type information for a key in the hash.
+      hash
     end
+
+    private_class_method :_convert_hash, :_convert_value
   end
 end

data/lib/optify_ruby/implementation.rb

@@ -2,12 +2,18 @@
 # typed: strict
 
 require 'json'
-require 'ostruct'
 
 require 'sorbet-runtime'
 
+require_relative './base_config'
+
 # 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
     extend T::Sig
@@ -29,24 +35,62 @@ module Optify
     # @param feature_names [Array<String>] The enabled feature names to use to build the options.
     # @param config_class [ConfigType] The class of the configuration to return.
     # It is recommended to use a class that extends `Optify::BaseConfig` because it implements `from_hash`.
+    # @param cache_options Set this if caching is desired. Only very simple caching is supported for now.
     # @return [ConfigType] The options.
     sig do
       type_parameters(:Config)
         .params(
           key: String,
           feature_names: T::Array[String],
-          config_class: T::Class[T.type_parameter(:Config)]
+          config_class: T::Class[T.type_parameter(:Config)],
+          cache_options: T.nilable(CacheOptions)
         )
         .returns(T.type_parameter(:Config))
     end
-    def get_options(key, feature_names, config_class)
-      options_json = get_options_json(key, feature_names)
-      h = JSON.parse(options_json, object_class: Hash)
+    def get_options(key, feature_names, config_class, cache_options = nil)
+      return get_options_with_cache(key, feature_names, config_class, cache_options) if cache_options
+
       unless config_class.respond_to?(:from_hash)
-        raise NotImplementedError, 'The provided config class does not implement to `from_hash`.'
+        raise NotImplementedError,
+              "The provided config class must implement `from_hash` as a class method
+              in order to be converted.
+              Recommended: extend `Optify::BaseConfig`."
       end
 
-      T.unsafe(config_class).from_hash(h)
+      options_json = get_options_json(key, feature_names)
+      hash = JSON.parse(options_json)
+      T.unsafe(config_class).from_hash(hash)
+    end
+
+    private
+
+    NOT_FOUND_IN_CACHE_SENTINEL = Object.new
+
+    sig do
+      type_parameters(:Config)
+        .params(
+          key: String,
+          feature_names: T::Array[String],
+          config_class: T::Class[T.type_parameter(:Config)],
+          _cache_options: CacheOptions
+        )
+        .returns(T.type_parameter(:Config))
+    end
+    def get_options_with_cache(key, feature_names, config_class, _cache_options)
+      # Cache directly in Ruby instead of Rust because:
+      # * Avoid any possible conversion overhead.
+      # * Memory management: probably better to do it in Ruby for a Ruby app and avoid memory in Rust.
+      # TODO: Consider aliases when caching. Right now, they are only visible in Rust
+      # and we don't want the cache in Rust because we won't to avoid any conversion overhead.
+      @cache ||= T.let({}, T.nilable(T::Hash[T.untyped, T.untyped]))
+      cache_key = [key, feature_names, config_class]
+      result = @cache.fetch(cache_key, NOT_FOUND_IN_CACHE_SENTINEL)
+      return result unless result.equal?(NOT_FOUND_IN_CACHE_SENTINEL)
+
+      result = get_options(key, feature_names, config_class)
+      T.unsafe(result).freeze if T.unsafe(result).respond_to?(:freeze)
+
+      @cache[cache_key] = result
     end
   end
 

data/rbi/optify.rbi

@@ -14,12 +14,18 @@ module Optify
 
     # Create a new instance of the class from a hash.
     #
+    # This is a class method that so that it can set members with private setters.
     # @param hash [Hash] The hash to create the instance from.
     # @return The new instance.
     sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T.attached_class) }
     def self.from_hash(hash); end
   end
 
+  # 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
     # Fetches options based on the provided key and feature names.
@@ -28,17 +34,19 @@ module Optify
     # @param feature_names [Array<String>] The enabled feature names to use to build the options.
     # @param config_class [ConfigType] The class of the configuration to return.
     # It is recommended to use a class that extends `Optify::BaseConfig` because it implements `from_hash`.
+    # @param cache_options Set this if caching is desired. Only very simple caching is supported for now.
     # @return [ConfigType] The options.
     sig do
       type_parameters(:Config)
         .params(
           key: String,
           feature_names: T::Array[String],
-          config_class: T::Class[T.type_parameter(:Config)]
+          config_class: T::Class[T.type_parameter(:Config)],
+          cache_options: T.nilable(CacheOptions)
         )
         .returns(T.type_parameter(:Config))
     end
-    def get_options(key, feature_names, config_class); end
+    def get_options(key, feature_names, config_class, cache_options = nil); end
 
     # Fetches options in JSON format based on the provided key and feature names.
     #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optify-config
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.1
 platform: aarch64-linux
 authors:
 - Justin D. Harris
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-02-07 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -89,9 +89,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/optify.rb
+- lib/optify_ruby/3.0/optify_ruby.so
 - lib/optify_ruby/base_config.rb
 - lib/optify_ruby/implementation.rb
-- lib/optify_ruby/optify_ruby.so
 - rbi/optify.rbi
 homepage: https://github.com/juharris/optify
 licenses:
@@ -107,10 +107,10 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.4'
+      version: '3.0'
   - - "<"
     - !ruby/object:Gem::Version
-      version: 3.5.dev
+      version: 3.1.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="