env_validator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a90ea9c5fad700f6349c118e12389d662a4d13d4a582b4198aeb3744e872a1ba
+  data.tar.gz: f4a043838d0b748377c18b8b6844d1c8a5f70b1d3b2820ae9e8caac12127e0d7
+SHA512:
+  metadata.gz: c8900c21a1d6f1cc4ec19c7283e3f9cc5084e195ab7f949d80d44230c8af248f702d1d63ab45e1315f0cb9c89383b445dc9fbe7c0de3036ae2cfb14d8894dac6
+  data.tar.gz: 808c9b4b117eb23afaa110623d86c499e855e0ddefe1ed0b33199e539d9a222e8345e6dc6eadae21aa342d9358974ef4be65924cbdb160461d94b8a890ae905a

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-09-04
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Alex Lopez
+
+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,115 @@
+# EnvValidator
+
+A lightweight Ruby gem that validates required environment variables at application boot time, providing type checking, format validation, and helpful error messages to prevent production disasters caused by missing or invalid configuration.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add env_validator
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install env_validator
+```
+
+## Quick Start
+
+```ruby
+# config/initializers/env_validator.rb (Rails)
+# or at top of main application file
+
+EnvValidator.configure do
+  # Required variables
+  required :DATABASE_URL, type: :url
+  required :SECRET_KEY_BASE, type: :string, min_length: 32
+  required :RAILS_ENV, type: :string, in: %w[development test production]
+  
+  # Optional with defaults
+  optional :PORT, type: :integer, default: 3000
+  optional :LOG_LEVEL, type: :string, default: 'info', in: %w[debug info warn error]
+  
+  # Format validation
+  required :STRIPE_API_KEY, format: /^sk_[a-zA-Z0-9]+$/
+end
+
+# Validate (call this after configuration)
+EnvValidator.validate!
+```
+
+## Features
+
+- ✅ **Required variable validation** - Ensure critical env vars exist
+- ✅ **Type checking** - String, Integer, Boolean, URL, Email, JSON, Base64, File/Dir paths
+- ✅ **Custom error messages** - Clear indication of what's missing/wrong
+- ✅ **Simple DSL** - Easy configuration syntax
+- ✅ **Boot-time validation** - Fail early before app starts
+- ✅ **Optional variables with defaults** - Handle optional configuration
+- ✅ **Format validation with regex** - API keys, tokens, custom formats
+- ✅ **Constraints** - Length limits, numeric ranges, inclusion lists
+- ✅ **Custom validators** - User-defined validation logic
+
+## Built-in Types
+
+```ruby
+type: :string      # Any string
+type: :integer     # Numeric string that converts to integer
+type: :float       # Numeric string that converts to float
+type: :boolean     # 'true', 'false', '1', '0', 'yes', 'no', 'on', 'off'
+type: :url         # Valid HTTP/HTTPS URL format
+type: :email       # Valid email format
+type: :json        # Valid JSON string
+type: :base64      # Valid Base64 string
+type: :file_path   # Existing file path
+type: :dir_path    # Existing directory path
+```
+
+## Usage Examples
+
+### Basic Validation
+```ruby
+ENV['API_KEY'] = 'sk_test_123'
+ENV['DEBUG'] = 'true'
+
+EnvValidator.configure do
+  required :API_KEY, type: :string
+  required :DEBUG, type: :boolean
+end
+
+EnvValidator.validate! # Passes
+```
+
+### Constraints and Defaults
+```ruby
+EnvValidator.configure do
+  required :SECRET, type: :string, min_length: 32
+  optional :PORT, type: :integer, default: 3000, min: 1000, max: 9999
+  required :ENV, type: :string, in: %w[development test production]
+end
+```
+
+### Custom Validation
+```ruby
+EnvValidator.configure do
+  required :CUSTOM_VALUE, type: :string do |value|
+    value.start_with?('custom_') && value.length > 10
+  end
+end
+```
+
+## 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/[USERNAME]/env_validator.
+
+## 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/examples/basic_usage.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example demonstrating basic EnvValidator usage
+require_relative "../lib/env_validator"
+
+# Set up some test environment variables
+ENV["DATABASE_URL"] = "https://db.example.com/mydb"
+ENV["SECRET_KEY"] = "super_secret_key_with_32_chars!!"
+ENV["DEBUG"] = "true"
+ENV["PORT"] = "3000"
+
+puts "=== EnvValidator Basic Usage Example ==="
+
+begin
+  EnvValidator.configure do
+    # Required variables
+    required :DATABASE_URL, type: :url, description: "Primary database connection URL"
+    required :SECRET_KEY, type: :string, min_length: 32, description: "Application secret key"
+
+    # Optional variables with defaults
+    optional :PORT, type: :integer, default: 5000, min: 1000, max: 9999
+    optional :DEBUG, type: :boolean, default: false
+    optional :LOG_LEVEL, type: :string, default: "info", in: %w[debug info warn error]
+
+    # Format validation
+    required :API_KEY, type: :string, format: /^ak_[a-zA-Z0-9]{16}$/, description: "API key with specific format"
+  end
+
+  puts "\nConfiguration created successfully!"
+  puts "Now validating environment variables..."
+
+  EnvValidator.validate!
+  puts "✅ All environment variables are valid!"
+rescue EnvValidator::ValidationErrors => e
+  puts "❌ Validation failed with the following errors:"
+  puts e.message
+rescue EnvValidator::Error => e
+  puts "❌ Configuration error: #{e.message}"
+end
+
+puts "\n=== Demonstrating Error Messages ==="
+
+# Clear API_KEY to show error message
+ENV.delete("API_KEY")
+
+begin
+  EnvValidator.validate!
+rescue EnvValidator::ValidationErrors => e
+  puts "Expected error for missing API_KEY:"
+  puts e.message
+end
+
+puts "\n=== Demonstrating Type Validation Error ==="
+
+# Set invalid port to show type error
+ENV["PORT"] = "not_a_number"
+EnvValidator.reset!
+
+begin
+  EnvValidator.configure do
+    required :PORT, type: :integer
+  end
+
+  EnvValidator.validate!
+rescue EnvValidator::ValidationErrors => e
+  puts "Expected error for invalid port type:"
+  puts e.message
+end

data/lib/env_validator/configuration.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module EnvValidator
+  class Rule
+    attr_reader :name, :type, :required, :default, :format, :description, :constraints, :custom_validator
+
+    def initialize(name, required: true, type: :string, default: nil, format: nil,
+                   description: nil, custom_validator: nil, **constraints)
+      @name = name.to_sym
+      @required = required
+      @type = type
+      @default = default
+      @format = format
+      @description = description
+      @constraints = constraints
+      @custom_validator = custom_validator
+    end
+
+    def required?
+      @required
+    end
+
+    def optional?
+      !@required
+    end
+
+    def has_default?
+      !@default.nil?
+    end
+
+    def has_format?
+      !@format.nil?
+    end
+
+    def has_constraints?
+      !@constraints.empty?
+    end
+
+    def has_custom_validator?
+      !@custom_validator.nil?
+    end
+  end
+
+  class Configuration
+    attr_reader :rules, :environments, :groups, :current_env
+
+    def initialize
+      @rules = {}
+      @environments = {}
+      @groups = {}
+      @current_env = detect_environment
+    end
+
+    def required(name, **options, &block)
+      custom_validator = block_given? ? block : nil
+      @rules[name.to_sym] = Rule.new(name, required: true, custom_validator: custom_validator, **options)
+    end
+
+    def optional(name, **options, &block)
+      custom_validator = block_given? ? block : nil
+      @rules[name.to_sym] = Rule.new(name, required: false, custom_validator: custom_validator, **options)
+    end
+
+    def environment(env_name, &block)
+      @environments[env_name.to_sym] = block
+    end
+
+    def group(group_name, &block)
+      @groups[group_name.to_sym] = block
+    end
+
+    def applicable_rules
+      rules = @rules.values.dup
+
+      # Apply environment-specific rules if they exist
+      if @environments[@current_env]
+        env_config = Configuration.new
+        env_config.instance_eval(&@environments[@current_env])
+        rules.concat(env_config.rules.values)
+      end
+
+      rules
+    end
+
+    def clear!
+      @rules.clear
+      @environments.clear
+      @groups.clear
+    end
+
+    private
+
+    def detect_environment
+      # Check for Rails environment first
+      return ENV["RAILS_ENV"].to_sym if ENV["RAILS_ENV"]
+
+      # Check for Rack environment
+      return ENV["RACK_ENV"].to_sym if ENV["RACK_ENV"]
+
+      # Check for general environment
+      return ENV["ENV"].to_sym if ENV["ENV"]
+
+      # Default to development
+      :development
+    end
+  end
+end

data/lib/env_validator/error.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module EnvValidator
+  class Error < StandardError; end
+
+  class ValidationError < Error
+    attr_reader :variable_name, :rule
+
+    def initialize(variable_name, rule, message)
+      @variable_name = variable_name
+      @rule = rule
+      super(message)
+    end
+  end
+
+  class MissingVariableError < ValidationError
+    def initialize(variable_name, rule)
+      message = build_missing_message(variable_name, rule)
+      super(variable_name, rule, message)
+    end
+
+    private
+
+    def build_missing_message(variable_name, rule)
+      message = "#{variable_name} is required but not set."
+
+      message += " #{rule.description}" if rule.description
+
+      if (similar = find_similar_env_vars(variable_name))
+        message += " Did you mean #{similar}?"
+      end
+
+      message
+    end
+
+    def find_similar_env_vars(variable_name)
+      env_vars = ENV.keys
+      name_str = variable_name.to_s
+
+      env_vars.find do |var|
+        # Simple similarity check - same length and mostly same characters
+        var.length == name_str.length &&
+          (0...var.length).count { |i| var[i] == name_str[i] } >= (name_str.length * 0.7).to_i
+      end
+    end
+  end
+
+  class TypeError < ValidationError
+    def initialize(variable_name, rule, expected_type, actual_value)
+      message = "#{variable_name} must be #{expected_type_description(expected_type)}, got: #{actual_value.inspect}"
+      super(variable_name, rule, message)
+    end
+
+    private
+
+    def expected_type_description(type)
+      case type
+      when :string then "a string"
+      when :integer then "an integer"
+      when :boolean then "a boolean (true/false)"
+      when :url then "a valid URL"
+      when :email then "a valid email address"
+      when :json then "valid JSON"
+      else type.to_s
+      end
+    end
+  end
+
+  class FormatError < ValidationError
+    def initialize(variable_name, rule, pattern)
+      message = "#{variable_name} format is invalid. Expected format: #{pattern}"
+      super(variable_name, rule, message)
+    end
+  end
+
+  class ConstraintError < ValidationError
+    def initialize(variable_name, rule, constraint_type, constraint_value, actual_value)
+      message = build_constraint_message(variable_name, constraint_type, constraint_value, actual_value)
+      super(variable_name, rule, message)
+    end
+
+    private
+
+    def build_constraint_message(variable_name, constraint_type, constraint_value, actual_value)
+      case constraint_type
+      when :min_length
+        "#{variable_name} must be at least #{constraint_value} characters long, got #{actual_value.length}"
+      when :max_length
+        "#{variable_name} must be at most #{constraint_value} characters long, got #{actual_value.length}"
+      when :min
+        "#{variable_name} must be at least #{constraint_value}, got #{actual_value}"
+      when :max
+        "#{variable_name} must be at most #{constraint_value}, got #{actual_value}"
+      when :in
+        "#{variable_name} must be one of #{constraint_value.inspect}, got #{actual_value.inspect}"
+      else
+        "#{variable_name} failed constraint #{constraint_type}: #{constraint_value}"
+      end
+    end
+  end
+
+  class ValidationErrors < Error
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      "Environment validation failed:\n" +
+        errors.map { |e| "  - #{e.message}" }.join("\n")
+    end
+  end
+end

data/lib/env_validator/types.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "uri"
+require "json"
+require "base64"
+
+module EnvValidator
+  module Types
+    class Base
+      def validate(value)
+        raise NotImplementedError, "Subclasses must implement #validate"
+      end
+
+      def coerce(value)
+        value # Default: no coercion
+      end
+    end
+
+    class String < Base
+      def validate(value)
+        return true if value.is_a?(::String)
+
+        raise TypeError, "Expected string, got #{value.class}"
+      end
+    end
+
+    class Integer < Base
+      def validate(value)
+        # Try to convert to integer
+        Integer(value)
+        true
+      rescue ArgumentError
+        raise TypeError, "Expected integer, got #{value.inspect}"
+      end
+
+      def coerce(value)
+        Integer(value)
+      end
+    end
+
+    class Float < Base
+      def validate(value)
+        # Try to convert to float
+        Float(value)
+        true
+      rescue ArgumentError
+        raise TypeError, "Expected float, got #{value.inspect}"
+      end
+
+      def coerce(value)
+        Float(value)
+      end
+    end
+
+    class Boolean < Base
+      TRUTHY_VALUES = %w[true 1 yes y on].freeze
+      FALSY_VALUES = %w[false 0 no n off].freeze
+      VALID_VALUES = (TRUTHY_VALUES + FALSY_VALUES).freeze
+
+      def validate(value)
+        normalized = value.to_s.downcase.strip
+        return true if VALID_VALUES.include?(normalized)
+
+        raise TypeError, "Expected boolean (#{VALID_VALUES.join(", ")}), got #{value.inspect}"
+      end
+
+      def coerce(value)
+        normalized = value.to_s.downcase.strip
+        TRUTHY_VALUES.include?(normalized)
+      end
+    end
+
+    class URL < Base
+      def validate(value)
+        uri = URI.parse(value.to_s)
+
+        # Must have a scheme and host for a valid URL
+        raise TypeError, "Expected valid URL with scheme and host, got #{value.inspect}" unless uri.scheme && uri.host
+
+        # Must be HTTP or HTTPS
+        unless %w[http https].include?(uri.scheme.downcase)
+          raise TypeError, "Expected HTTP or HTTPS URL, got #{value.inspect}"
+        end
+
+        true
+      rescue URI::InvalidURIError
+        raise TypeError, "Expected valid URL, got #{value.inspect}"
+      end
+
+      def coerce(value)
+        URI.parse(value.to_s)
+      end
+    end
+
+    class Email < Base
+      # Basic email regex - not RFC compliant but good enough for most cases
+      EMAIL_REGEX = /\A[^@\s]+@[^@\s]+\.[^@\s]+\z/
+
+      def validate(value)
+        raise TypeError, "Expected valid email address, got #{value.inspect}" unless value.to_s.match?(EMAIL_REGEX)
+
+        true
+      end
+    end
+
+    class Json < Base
+      def validate(value)
+        JSON.parse(value.to_s)
+        true
+      rescue JSON::ParserError
+        raise TypeError, "Expected valid JSON, got #{value.inspect}"
+      end
+
+      def coerce(value)
+        JSON.parse(value.to_s)
+      end
+    end
+
+    class Base64 < Base
+      def validate(value)
+        # Check if it's valid base64
+        ::Base64.strict_decode64(value.to_s)
+        true
+      rescue ArgumentError
+        raise TypeError, "Expected valid Base64 string, got #{value.inspect}"
+      end
+
+      def coerce(value)
+        ::Base64.strict_decode64(value.to_s)
+      end
+    end
+
+    class FilePath < Base
+      def validate(value)
+        path = value.to_s
+        unless File.exist?(path) && File.file?(path)
+          raise TypeError, "Expected existing file path, got #{value.inspect}"
+        end
+
+        true
+      end
+    end
+
+    class DirPath < Base
+      def validate(value)
+        path = value.to_s
+        unless File.exist?(path) && File.directory?(path)
+          raise TypeError, "Expected existing directory path, got #{value.inspect}"
+        end
+
+        true
+      end
+    end
+
+    # Registry for type lookup
+    TYPE_REGISTRY = {
+      string: String,
+      integer: Integer,
+      float: Float,
+      boolean: Boolean,
+      url: URL,
+      email: Email,
+      json: Json,
+      base64: Base64,
+      file_path: FilePath,
+      dir_path: DirPath
+    }.freeze
+
+    def self.get_validator(type)
+      validator_class = TYPE_REGISTRY[type.to_sym]
+      raise ArgumentError, "Unknown type: #{type}" unless validator_class
+
+      validator_class.new
+    end
+  end
+end

data/lib/env_validator/validator.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "types"
+require_relative "error"
+
+module EnvValidator
+  class Validator
+    def initialize(configuration)
+      @config = configuration
+    end
+
+    def validate!
+      errors = []
+
+      @config.applicable_rules.each do |rule|
+        validate_rule(rule)
+      rescue ValidationError => e
+        errors << e
+      end
+
+      raise ValidationErrors, errors unless errors.empty?
+
+      true
+    end
+
+    private
+
+    def validate_rule(rule)
+      value = ENV[rule.name.to_s]
+
+      # Handle missing required variables
+      raise MissingVariableError.new(rule.name, rule) if rule.required? && value.nil?
+
+      # If optional and missing, use default if available
+      if value.nil? && rule.optional?
+        return unless rule.has_default?
+
+        ENV[rule.name.to_s] = rule.default.to_s
+        value = rule.default.to_s
+
+        # Optional and no default, skip validation
+
+      end
+
+      return if value.nil? # Should not happen but safety check
+
+      # Validate type
+      validate_type(rule, value)
+
+      # Validate format if specified
+      validate_format(rule, value) if rule.has_format?
+
+      # Validate constraints
+      validate_constraints(rule, value) if rule.has_constraints?
+
+      # Run custom validator if specified
+      validate_custom(rule, value) if rule.has_custom_validator?
+    end
+
+    def validate_type(rule, value)
+      type_validator = Types.get_validator(rule.type)
+      type_validator.validate(value)
+    rescue ::TypeError
+      raise EnvValidator::TypeError.new(rule.name, rule, rule.type, value)
+    rescue ArgumentError
+      raise EnvValidator::TypeError.new(rule.name, rule, rule.type, value)
+    end
+
+    def validate_format(rule, value)
+      pattern = rule.format
+      return if value.to_s.match?(pattern)
+
+      raise FormatError.new(rule.name, rule, pattern)
+    end
+
+    def validate_constraints(rule, value)
+      rule.constraints.each do |constraint_type, constraint_value|
+        validate_constraint(rule, value, constraint_type, constraint_value)
+      end
+    end
+
+    def validate_constraint(rule, value, constraint_type, constraint_value)
+      case constraint_type
+      when :min_length
+        if value.to_s.length < constraint_value
+          raise ConstraintError.new(rule.name, rule, constraint_type, constraint_value, value)
+        end
+      when :max_length
+        if value.to_s.length > constraint_value
+          raise ConstraintError.new(rule.name, rule, constraint_type, constraint_value, value)
+        end
+      when :min
+        # Coerce value to numeric for comparison
+        numeric_value = coerce_to_numeric(rule, value)
+        if numeric_value < constraint_value
+          raise ConstraintError.new(rule.name, rule, constraint_type, constraint_value, value)
+        end
+      when :max
+        # Coerce value to numeric for comparison
+        numeric_value = coerce_to_numeric(rule, value)
+        if numeric_value > constraint_value
+          raise ConstraintError.new(rule.name, rule, constraint_type, constraint_value, value)
+        end
+      when :in
+        unless constraint_value.include?(value.to_s)
+          raise ConstraintError.new(rule.name, rule, constraint_type, constraint_value, value)
+        end
+      end
+    end
+
+    def validate_custom(rule, value)
+      result = rule.custom_validator.call(value)
+      raise ValidationError.new(rule.name, rule, "Custom validation failed for #{rule.name}") unless result
+    rescue StandardError => e
+      raise e if e.is_a?(ValidationError)
+
+      raise ValidationError.new(rule.name, rule, "Custom validation error: #{e.message}")
+    end
+
+    def coerce_to_numeric(rule, value)
+      case rule.type
+      when :integer
+        Integer(value)
+      when :float
+        Float(value)
+      else
+        # For non-numeric types, try to convert anyway
+        begin
+          Float(value)
+        rescue ArgumentError
+          raise ConstraintError.new(rule.name, rule, :type, "numeric", value)
+        end
+      end
+    end
+  end
+end

data/lib/env_validator/version.rb

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

data/lib/env_validator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "env_validator/version"
+require_relative "env_validator/error"
+require_relative "env_validator/configuration"
+require_relative "env_validator/validator"
+require_relative "env_validator/types"
+
+module EnvValidator
+  class << self
+    def configure(&block)
+      @configuration = Configuration.new
+      @configuration.instance_eval(&block)
+      @configuration
+    end
+
+    def validate!
+      raise Error, "No configuration defined. Call EnvValidator.configure first." unless @configuration
+
+      validator = Validator.new(@configuration)
+      validator.validate!
+    end
+
+    attr_reader :configuration
+
+    def reset!
+      @configuration = nil
+    end
+  end
+end

data/sig/env_validator.rbs

@@ -0,0 +1,4 @@
+module EnvValidator
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: env_validator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alex Lopez
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A lightweight gem that validates required environment variables at application
+  boot time, providing type checking, format validation, and helpful error messages
+  to prevent production disasters caused by missing or invalid configuration.
+email:
+- webodessa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/basic_usage.rb
+- lib/env_validator.rb
+- lib/env_validator/configuration.rb
+- lib/env_validator/error.rb
+- lib/env_validator/types.rb
+- lib/env_validator/validator.rb
+- lib/env_validator/version.rb
+- sig/env_validator.rbs
+homepage: https://github.com/logicalgroove/env_validator
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/logicalgroove/env_validator
+  source_code_uri: https://github.com/logicalgroove/env_validator
+  changelog_uri: https://github.com/logicalgroove/env_validator/blob/master/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Environment variable validation for Ruby applications
+test_files: []