shinsei_config 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6af621e538e6ba8146f4ba7814770563595b1c522baa0010055e6c93d17641f0
+  data.tar.gz: b79735e216a52f3a899b4c395dda017df9da3cd5b829ea329937baf2857ce234
+SHA512:
+  metadata.gz: d0e96f8135a98c3c61781c75a25e6af63d43a7ad67c6e7055b06933181149cbd9db7709f6a74cb305580c24c422003d41840514c81de61a8d4b414519278fc82
+  data.tar.gz: 718a2a75ffc48008cbf3726417a54c90304958f8264952524dab6af375bac0254cc657046417328cebfe459e7d9a09e6b15058183e5ae043be6e594be13c92d8

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,46 @@
+plugins:
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 3.3
+  NewCops: enable
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: single_quotes
+
+Metrics/MethodLength:
+  Max: 20
+  Exclude:
+    - 'spec/**/*.rb'
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Metrics/ClassLength:
+  Max: 200
+
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+
+Layout/LeadingCommentSpace:
+  AllowRBSInlineAnnotation: true
+
+RSpec/NamedSubject:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/MultipleMemoizedHelpers:
+  Enabled: false
+
+RSpec/NestedGroups:
+  Max: 4
+
+RSpec/ExampleLength:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-11-17
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Denis Talakevich
+
+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,171 @@
+# ShinseiConfig
+
+[![Gem Version](https://badge.fury.io/rb/shinsei_config.svg)](https://rubygems.org/gems/shinsei_config)
+[![CI](https://github.com/senid231/shinsei_config/actions/workflows/main.yml/badge.svg)](https://github.com/senid231/shinsei_config/actions/workflows/main.yml)
+[![CodeQL](https://github.com/senid231/shinsei_config/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/senid231/shinsei_config/actions/workflows/github-code-scanning/codeql)
+
+Shinsei (真正 — "genuine, correct, authentic")
+
+A Ruby gem for loading configuration from YAML files with schema validation, ERB interpolation, and environment-specific settings.
+
+## Features
+
+- **Schema Validation**: Uses [dry-schema](https://dry-rb.org/gems/dry-schema/) for robust configuration validation
+- **ERB Interpolation**: Process ERB templates before YAML parsing
+- **Environment Splitting**: Load environment-specific configurations
+- **Immutable Config Objects**: Uses Ruby 3.2+ `Data.define` for frozen, immutable configuration objects
+- **Type-Safe Access**: Access configuration values with dot notation
+- **Custom YAML Options**: Pass custom options to YAML parser
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add shinsei_config
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install shinsei_config
+```
+
+## Usage
+
+### Basic Example
+
+```ruby
+require 'shinsei_config'
+
+class MyAppConfig < ShinseiConfig::RootConfig
+  settings do |s|
+    s.config_path = Rails.root.join('config/my_app_config.yml').to_s # required
+    s.env = Rails.env.to_s # optional, default nil which means no env splitting
+    s.yaml_opts = { aliases: true } # optional, default {}
+  end
+
+  schema do
+    required(:write_account_stats).value(:bool?)
+    required(:api_keys).hash do
+      required(:service_a).filled(:string)
+      required(:service_b).filled(:string)
+    end
+  end
+
+  def self.service_a_test?
+    # custom methods to access config values
+    api_keys.service_a.start_with?('test-')
+  end
+end
+
+# When application starts
+MyAppConfig.load! # may raise ShinseiConfig::ValidationError if config is invalid
+
+# Somewhere in the app
+MyAppConfig.api_keys.service_a # => "actual-key"
+MyAppConfig.write_account_stats # => true
+MyAppConfig.service_a_test? # => false
+```
+
+### YAML File Examples
+
+#### Simple Configuration (config/my_app_config.yml)
+
+```yaml
+write_account_stats: true
+api_keys:
+  service_a: <%= ENV['SERVICE_A_KEY'] %>
+  service_b: production-key-b
+```
+
+#### Environment-Specific Configuration
+
+```yaml
+development:
+  write_account_stats: false
+  api_keys:
+    service_a: test-key-a
+    service_b: test-key-b
+
+production:
+  write_account_stats: true
+  api_keys:
+    service_a: <%= ENV['SERVICE_A_KEY'] %>
+    service_b: <%= ENV['SERVICE_B_KEY'] %>
+```
+
+### Features in Detail
+
+#### ERB Interpolation
+
+ERB is processed on the raw YAML content before parsing:
+
+```yaml
+# config.yml
+database_url: <%= ENV.fetch('DATABASE_URL', 'postgres://localhost/mydb') %>
+max_connections: <%= 2 * 5 %>
+```
+
+#### Schema Validation
+
+The gem uses [dry-schema](https://dry-rb.org/gems/dry-schema/) for validation:
+
+```ruby
+schema do
+  required(:database).hash do
+    required(:host).filled(:string)
+    required(:port).filled(:integer)
+  end
+
+  optional(:features).array(:string)
+
+  required(:timeout).value(:integer, gt?: 0)
+end
+```
+
+#### Custom YAML Options
+
+Pass custom options to the YAML parser:
+
+```ruby
+settings do |s|
+  s.config_path = 'config/app.yml'
+  s.yaml_opts = {
+    aliases: true,
+    permitted_classes: [Date, Time],
+    permitted_symbols: []
+  }
+end
+```
+
+#### Immutable Configuration
+
+All configuration objects are deeply frozen and immutable:
+
+```ruby
+MyAppConfig.api_keys.frozen? # => true
+MyAppConfig.api_keys.service_a.frozen? # => true
+```
+
+#### Reloading Configuration
+
+You can reload the configuration at runtime (useful for development):
+
+```ruby
+MyAppConfig.reload!
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/senid231/shinsei_config.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/shinsei_config/config_builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ShinseiConfig
+  # Recursively builds Data.define objects from hash with deep freezing
+  class ConfigBuilder
+    # @rbs hash: Hash[untyped, untyped] -- return: Data
+    def self.build(hash)
+      new(hash).build
+    end
+
+    # @rbs @hash: Hash[untyped, untyped]
+
+    # @rbs attr_reader hash: Hash[untyped, untyped]
+    attr_reader :hash
+
+    # @rbs hash: Hash[untyped, untyped] -- return: void
+    def initialize(hash)
+      @hash = hash
+    end
+
+    # @rbs return: Data
+    def build
+      raise Error, "Expected Hash, got #{hash.class}" unless hash.is_a?(Hash)
+
+      # Create a Data.define class with all keys as symbols
+      config_class = Data.define(*hash.keys.map(&:to_sym))
+
+      # Build values, recursively converting nested hashes
+      # Convert keys to symbols for Data.define
+      values = hash.transform_keys(&:to_sym).transform_values { |v| build_value(v) }
+
+      # Create instance and freeze
+      config_class.new(**values).freeze
+    end
+
+    private
+
+    # @rbs value: untyped -- return: untyped
+    def build_value(value)
+      case value
+      when Hash
+        ConfigBuilder.build(value)
+      when Array
+        value.map { |v| build_value(v) }.freeze
+      else
+        value
+      end
+    end
+  end
+end

data/lib/shinsei_config/loader.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'erb'
+
+module ShinseiConfig
+  # Handles loading YAML files with ERB interpolation and environment splitting
+  class Loader
+    # @rbs @config_path: String
+    # @rbs @env: String?
+    # @rbs @yaml_opts: Hash[Symbol, untyped]
+
+    # @rbs attr_reader config_path: String
+    # @rbs attr_reader env: String?
+    # @rbs attr_reader yaml_opts: Hash[Symbol, untyped]
+    attr_reader :config_path, :env, :yaml_opts
+
+    # @rbs config_path: String, env: String?, **yaml_opts: untyped -- return: void
+    def initialize(config_path:, env: nil, **yaml_opts)
+      @config_path = config_path
+      @env = env
+      @yaml_opts = yaml_opts
+    end
+
+    # @rbs return: Hash[String, untyped]
+    def load
+      raise Error, "Config file not found: #{config_path}" unless File.exist?(config_path)
+
+      # Read raw content
+      raw_content = File.read(config_path)
+
+      # Process ERB on raw content before YAML parsing
+      erb_processed = ERB.new(raw_content).result
+
+      # Parse YAML with provided options
+      parsed_yaml = YAML.safe_load(erb_processed, **yaml_opts)
+
+      # Extract environment section if env is set
+      extract_env_section(parsed_yaml)
+    end
+
+    private
+
+    # @rbs parsed_yaml: Hash[String, untyped] -- return: Hash[String, untyped]
+    def extract_env_section(parsed_yaml)
+      return parsed_yaml unless env
+
+      unless parsed_yaml.is_a?(Hash) && parsed_yaml.key?(env)
+        raise Error, "Environment '#{env}' not found in config file"
+      end
+
+      parsed_yaml[env]
+    end
+  end
+end

data/lib/shinsei_config/root_config.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ShinseiConfig
+  # Base class for configuration. Users inherit from this class.
+  class RootConfig
+    class << self
+      # @rbs @settings: Settings?
+      # @rbs @schema_validator: SchemaValidator?
+      # @rbs @config: Data?
+
+      # Configure settings for this config class
+      # @rbs () { (Settings) -> void } -> Settings
+      def settings(&block)
+        @settings ||= Settings.new
+        block&.call(@settings)
+        @settings
+      end
+
+      # Define validation schema
+      # @rbs () { () -> void } -> SchemaValidator?
+      def schema(&block)
+        @schema_validator = SchemaValidator.new(&block) if block
+        @schema_validator
+      end
+
+      # Load and validate configuration
+      # @rbs return: singleton(RootConfig)
+      def load!
+        validate_setup!
+
+        # Load YAML with ERB and env splitting
+        loader = Loader.new(
+          config_path: settings.config_path,
+          env: settings.env,
+          **settings.yaml_opts
+        )
+        config_hash = loader.load
+
+        # Validate against schema if defined
+        schema&.validate!(config_hash)
+
+        # Build config object
+        @config = ConfigBuilder.build(config_hash)
+
+        self
+      end
+
+      # Reload configuration
+      # @rbs return: singleton(RootConfig)
+      def reload!
+        @config = nil
+        load!
+      end
+
+      # Access config instance
+      # @rbs return: Data
+      def config
+        raise Error, "Config not loaded. Call #{name}.load! first" unless @config
+
+        @config
+      end
+
+      # Delegate method calls to config instance
+      # @rbs method_name: Symbol, *args: untyped, **kwargs: untyped -- return: untyped
+      def method_missing(method_name, *, &)
+        if config.respond_to?(method_name)
+          config.public_send(method_name, *, &)
+        else
+          super
+        end
+      end
+
+      # @rbs method_name: Symbol, include_private: bool -- return: bool
+      def respond_to_missing?(method_name, include_private = false)
+        config.respond_to?(method_name) || super
+      end
+
+      private
+
+      # @rbs return: void
+      def validate_setup!
+        settings.validate!
+
+        return if schema
+
+        raise Error, "Schema not defined. Call #{name}.schema { ... } in class body"
+      end
+    end
+  end
+end

data/lib/shinsei_config/schema_validator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+
+module ShinseiConfig
+  # Wraps dry-schema for validating configuration
+  class SchemaValidator
+    # @rbs @schema: Dry::Schema::Processor
+
+    # @rbs attr_reader schema: Dry::Schema::Processor
+    attr_reader :schema
+
+    # @rbs **opts: untyped -- return: void
+    def initialize(**, &)
+      @schema = Dry::Schema.define(processor_type: Dry::Schema::JSON, **, &)
+    end
+
+    # @rbs config_hash: Hash[untyped, untyped] -- return: void
+    def validate!(config_hash)
+      result = schema.call(config_hash)
+
+      return if result.success?
+
+      raise ValidationError, result.errors
+    end
+  end
+end

data/lib/shinsei_config/settings.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ShinseiConfig
+  # Stores settings for RootConfig that are not part of the schema
+  class Settings
+    # @rbs @config_path: String?
+    # @rbs @env: String?
+    # @rbs @yaml_opts: Hash[Symbol, untyped]
+
+    # @rbs attr_accessor config_path: String?
+    # @rbs attr_accessor env: String?
+    # @rbs attr_accessor yaml_opts: Hash[Symbol, untyped]
+    attr_accessor :config_path, :env, :yaml_opts
+
+    # @rbs return: void
+    def initialize
+      @config_path = nil
+      @env = nil
+      @yaml_opts = {}
+    end
+
+    # @rbs return: void
+    def validate!
+      raise Error, 'config_path is required' if config_path.nil? || config_path.empty?
+    end
+  end
+end

data/lib/shinsei_config/validation_error.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ShinseiConfig
+  # Raised when config validation fails
+  class ValidationError < Error
+    # @rbs @errors: Hash[Symbol, Array[String]]
+
+    # @rbs attr_reader errors: Hash[Symbol, Array[String]]
+    attr_reader :errors
+
+    # @rbs errors: Hash[Symbol, Array[String]] -- return: void
+    def initialize(errors)
+      @errors = errors
+      super(format_errors)
+    end
+
+    private
+
+    # @rbs return: String
+    def format_errors
+      return 'Validation failed' if errors.empty?
+
+      formatted = errors.to_h.map do |key, messages|
+        "  #{key}: #{messages.join(', ')}"
+      end
+
+      "Validation failed:\n#{formatted.join("\n")}"
+    end
+  end
+end

data/lib/shinsei_config/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ShinseiConfig
+  VERSION = '0.1.0'
+end

data/lib/shinsei_config.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'shinsei_config/version'
+
+module ShinseiConfig
+  class Error < StandardError; end
+end
+
+require_relative 'shinsei_config/settings'
+require_relative 'shinsei_config/validation_error'
+require_relative 'shinsei_config/loader'
+require_relative 'shinsei_config/schema_validator'
+require_relative 'shinsei_config/config_builder'
+require_relative 'shinsei_config/root_config'

data/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: dry-schema

data/sig/shinsei_config/config_builder.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/shinsei_config/config_builder.rb with RBS::Inline
+
+module ShinseiConfig
+  # Recursively builds Data.define objects from hash with deep freezing
+  class ConfigBuilder
+    # @rbs hash: Hash[untyped, untyped] -- return: Data
+    def self.build: (Hash[untyped, untyped] hash) -> untyped
+
+    @hash: Hash[untyped, untyped]
+
+    # @rbs attr_reader hash: Hash[untyped, untyped]
+    attr_reader hash: untyped
+
+    # @rbs hash: Hash[untyped, untyped] -- return: void
+    def initialize: (Hash[untyped, untyped] hash) -> untyped
+
+    # @rbs return: Data
+    def build: () -> Data
+
+    private
+
+    # @rbs value: untyped -- return: untyped
+    def build_value: (untyped value) -> untyped
+  end
+end

data/sig/shinsei_config/loader.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/shinsei_config/loader.rb with RBS::Inline
+
+module ShinseiConfig
+  # Handles loading YAML files with ERB interpolation and environment splitting
+  class Loader
+    @config_path: String
+
+    @env: String?
+
+    @yaml_opts: Hash[Symbol, untyped]
+
+    # @rbs attr_reader config_path: String
+    # @rbs attr_reader env: String?
+    # @rbs attr_reader yaml_opts: Hash[Symbol, untyped]
+    attr_reader config_path: untyped
+
+    # @rbs attr_reader config_path: String
+    # @rbs attr_reader env: String?
+    # @rbs attr_reader yaml_opts: Hash[Symbol, untyped]
+    attr_reader env: untyped
+
+    # @rbs attr_reader config_path: String
+    # @rbs attr_reader env: String?
+    # @rbs attr_reader yaml_opts: Hash[Symbol, untyped]
+    attr_reader yaml_opts: untyped
+
+    # @rbs config_path: String, env: String?, **yaml_opts: untyped -- return: void
+    def initialize: (config_path: String, ?env: untyped, **untyped yaml_opts) -> untyped
+
+    # @rbs return: Hash[String, untyped]
+    def load: () -> Hash[String, untyped]
+
+    private
+
+    # @rbs parsed_yaml: Hash[String, untyped] -- return: Hash[String, untyped]
+    def extract_env_section: (Hash[String, untyped] parsed_yaml) -> untyped
+  end
+end

data/sig/shinsei_config/root_config.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/shinsei_config/root_config.rb with RBS::Inline
+
+module ShinseiConfig
+  # Base class for configuration. Users inherit from this class.
+  class RootConfig
+    @settings: Settings?
+
+    @schema_validator: SchemaValidator?
+
+    @config: Data?
+
+    # Configure settings for this config class
+    # @rbs () { (Settings) -> void } -> Settings
+    def self.settings: () { (Settings) -> void } -> Settings
+
+    # Define validation schema
+    # @rbs () { () -> void } -> SchemaValidator?
+    def self.schema: () { () -> void } -> SchemaValidator?
+
+    # Load and validate configuration
+    # @rbs return: singleton(RootConfig)
+    def self.load!: () -> singleton(RootConfig)
+
+    # Reload configuration
+    # @rbs return: singleton(RootConfig)
+    def self.reload!: () -> singleton(RootConfig)
+
+    # Access config instance
+    # @rbs return: Data
+    def self.config: () -> Data
+
+    # Delegate method calls to config instance
+    # @rbs method_name: Symbol, *args: untyped, **kwargs: untyped -- return: untyped
+    def self.method_missing: (Symbol method_name, *untyped) ?{ (?) -> untyped } -> untyped
+
+    # @rbs method_name: Symbol, include_private: bool -- return: bool
+    def self.respond_to_missing?: (Symbol method_name, ?untyped include_private) -> untyped
+
+    # @rbs return: void
+    private def self.validate_setup!: () -> void
+  end
+end

data/sig/shinsei_config/schema_validator.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/shinsei_config/schema_validator.rb with RBS::Inline
+
+module ShinseiConfig
+  # Wraps dry-schema for validating configuration
+  class SchemaValidator
+    @schema: Dry::Schema::Processor
+
+    # @rbs attr_reader schema: Dry::Schema::Processor
+    attr_reader schema: untyped
+
+    # @rbs **opts: untyped -- return: void
+    def initialize: (**untyped) ?{ (?) -> untyped } -> untyped
+
+    # @rbs config_hash: Hash[untyped, untyped] -- return: void
+    def validate!: (Hash[untyped, untyped] config_hash) -> untyped
+  end
+end

data/sig/shinsei_config/settings.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/shinsei_config/settings.rb with RBS::Inline
+
+module ShinseiConfig
+  # Stores settings for RootConfig that are not part of the schema
+  class Settings
+    @config_path: String?
+
+    @env: String?
+
+    @yaml_opts: Hash[Symbol, untyped]
+
+    # @rbs attr_accessor config_path: String?
+    # @rbs attr_accessor env: String?
+    # @rbs attr_accessor yaml_opts: Hash[Symbol, untyped]
+    attr_accessor config_path: untyped
+
+    # @rbs attr_accessor config_path: String?
+    # @rbs attr_accessor env: String?
+    # @rbs attr_accessor yaml_opts: Hash[Symbol, untyped]
+    attr_accessor env: untyped
+
+    # @rbs attr_accessor config_path: String?
+    # @rbs attr_accessor env: String?
+    # @rbs attr_accessor yaml_opts: Hash[Symbol, untyped]
+    attr_accessor yaml_opts: untyped
+
+    # @rbs return: void
+    def initialize: () -> void
+
+    # @rbs return: void
+    def validate!: () -> void
+  end
+end

data/sig/shinsei_config/validation_error.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/shinsei_config/validation_error.rb with RBS::Inline
+
+module ShinseiConfig
+  # Raised when config validation fails
+  class ValidationError < Error
+    @errors: Hash[Symbol, Array[String]]
+
+    # @rbs attr_reader errors: Hash[Symbol, Array[String]]
+    attr_reader errors: untyped
+
+    # @rbs errors: Hash[Symbol, Array[String]] -- return: void
+    def initialize: (Hash[Symbol, Array[String]] errors) -> untyped
+
+    private
+
+    # @rbs return: String
+    def format_errors: () -> String
+  end
+end

data/sig/shinsei_config/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/shinsei_config/version.rb with RBS::Inline
+
+module ShinseiConfig
+  VERSION: ::String
+end

data/sig/shinsei_config.rbs

@@ -0,0 +1,6 @@
+# Generated from lib/shinsei_config.rb with RBS::Inline
+
+module ShinseiConfig
+  class Error < StandardError
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: shinsei_config
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Denis Talakevich
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+description: ShinseiConfig (真正 — genuine, correct, authentic) loads configuration
+  from YAML files, supports ERB interpolation, per-environment splitting, and validates
+  structure using dry-schema.
+email:
+- senid231@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/shinsei_config.rb
+- lib/shinsei_config/config_builder.rb
+- lib/shinsei_config/loader.rb
+- lib/shinsei_config/root_config.rb
+- lib/shinsei_config/schema_validator.rb
+- lib/shinsei_config/settings.rb
+- lib/shinsei_config/validation_error.rb
+- lib/shinsei_config/version.rb
+- manifest.yaml
+- sig/shinsei_config.rbs
+- sig/shinsei_config/config_builder.rbs
+- sig/shinsei_config/loader.rbs
+- sig/shinsei_config/root_config.rbs
+- sig/shinsei_config/schema_validator.rbs
+- sig/shinsei_config/settings.rbs
+- sig/shinsei_config/validation_error.rbs
+- sig/shinsei_config/version.rbs
+homepage: https://github.com/senid231/shinsei_config
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/senid231/shinsei_config
+  source_code_uri: https://github.com/senid231/shinsei_config
+  changelog_uri: https://github.com/senid231/shinsei_config/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.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: Loads and validates configuration from YAML files with schema validation
+test_files: []