hati-config 0.1.0

data/lib/hati_config/environment.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module HatiConfig
+  # Environment module provides functionality for managing environment-specific configurations.
+  module Environment
+    # Defines environment-specific configuration overrides.
+    #
+    # @param env_name [Symbol] The name of the environment (e.g., :development, :staging, :production)
+    # @yield The configuration block for the environment
+    # @example
+    #   environment :development do
+    #     config api_url: 'http://localhost:3000'
+    #     config debug: true
+    #   end
+    def environment(env_name, &block)
+      return unless current_environment == env_name
+
+      instance_eval(&block)
+    end
+
+    # Sets the current environment.
+    #
+    # @param env [Symbol] The environment to set
+    # @example
+    #   HatiConfig.environment = :production
+    def self.current_environment=(env)
+      @current_environment = env&.to_sym
+    end
+
+    # Gets the current environment.
+    #
+    # @return [Symbol] The current environment
+    def self.current_environment
+      @current_environment ||= begin
+        env = if ENV['HATI_ENV']
+                ENV['HATI_ENV']
+              elsif ENV['RACK_ENV']
+                ENV['RACK_ENV']
+              elsif ENV['RAILS_ENV']
+                ENV['RAILS_ENV']
+              else
+                'development'
+              end
+        env.to_sym
+      end
+    end
+
+    # Gets the current environment.
+    #
+    # @return [Symbol] The current environment
+    def current_environment
+      Environment.current_environment
+    end
+
+    # Temporarily changes the environment for a block of code.
+    #
+    # @param env [Symbol] The environment to use
+    # @yield The block to execute in the specified environment
+    # @example
+    #   HatiConfig.with_environment(:staging) do
+    #     # Configuration will use staging environment here
+    #   end
+    def self.with_environment(env)
+      original_env = current_environment
+      self.current_environment = env
+      yield
+    ensure
+      self.current_environment = original_env
+    end
+
+    # Checks if the current environment matches the given environment.
+    #
+    # @param env [Symbol] The environment to check
+    # @return [Boolean] True if the current environment matches
+    def environment?(env)
+      current_environment == env.to_sym
+    end
+
+    # Checks if the current environment is development.
+    #
+    # @return [Boolean] True if in development environment
+    def development?
+      environment?(:development)
+    end
+
+    # Checks if the current environment is test.
+    #
+    # @return [Boolean] True if in test environment
+    def test?
+      environment?(:test)
+    end
+
+    # Checks if the current environment is staging.
+    #
+    # @return [Boolean] True if in staging environment
+    def staging?
+      environment?(:staging)
+    end
+
+    # Checks if the current environment is production.
+    #
+    # @return [Boolean] True if in production environment
+    def production?
+      environment?(:production)
+    end
+  end
+end

data/lib/hati_config/errors.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# HatiConfig module provides functionality for managing HatiConfig features.
+module HatiConfig
+  # Custom error raised when a setting type does not match the expected type.
+  #
+  # @example Raising an SettingTypeError
+  #   raise SettingTypeError.new(:int, "string")
+  #   # => raises SettingTypeError with message
+  #   # "Expected: <int>. Given: \"string\" which is <String> class."
+  class SettingTypeError < TypeError
+    # Initializes a new SettingTypeError.
+    #
+    # @param type [Symbol] The expected type.
+    # @param val [Object] The value that was provided.
+    def initialize(type, val)
+      super(type_error_msg(type, val))
+    end
+
+    # Generates the error message for the exception.
+    #
+    # @param type [Symbol] The expected type.
+    # @param val [Object] The value that was provided.
+    # @return [String] The formatted error message.
+    def type_error_msg(type, val)
+      "Expected: <#{type}>. Given: #{val.inspect} which is <#{val.class}> class."
+    end
+  end
+
+  # Custom error raised when a type definition is missing.
+  #
+  # @example Raising a TypeCheckerError
+  #   raise TypeCheckerError.new(:unknown_type)
+  #   # => raises TypeCheckerError with message "No type Definition for: <unknown_type> type"
+  class TypeCheckerError < StandardError
+    # Initializes a new TypeCheckerError.
+    #
+    # @param type [Symbol] The type that is missing a definition.
+    def initialize(type)
+      super(definition_error_msg(type))
+    end
+
+    # Generates the error message for the exception.
+    #
+    # @param type [Symbol] The type that is missing a definition.
+    # @return [String] The formatted error message.
+    def definition_error_msg(type)
+      "No type Definition for: <#{type}> type"
+    end
+  end
+
+  # Custom error raised when data loading fails.
+  class LoadDataError < StandardError; end
+end

data/lib/hati_config/hati_configuration.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# HatiConfig module provides functionality for managing configuration features.
+#
+# @example Using HatiConfiguration in a class
+#   class MyApp
+#     include HatiConfiguration
+#
+#     configure :settings do
+#       config api_key: "default_key"
+#       config max_retries: 3
+#     end
+#   end
+#
+#   MyApp.settings.api_key # => "default_key"
+#   MyApp.settings.max_retries # => 3
+#
+# @example Configuring with a block
+#   class AnotherApp
+#     include HatiConfiguration
+#
+#     configure :app_settings do
+#       config feature_enabled: true
+#       config max_users: 100
+#     end
+#   end
+#
+#   AnotherApp.app_settings.feature_enabled # => true
+#   AnotherApp.app_settings.max_users # => 100
+module HatiConfiguration
+  # Extends the base class with HatiConfig::Configuration and HatiConfig::Team module methods
+  #
+  # @param base [Class] The class extending this module
+  # @return [void]
+  def self.extended(base)
+    base.extend(HatiConfig::Configuration)
+    base.extend(HatiConfig::Team)
+  end
+
+  # Isolated module handles isolated configurations.
+  #
+  # This module allows for configuration inheritance while maintaining
+  # isolation between parent and child configurations.
+  #
+  # @example Using Isolated configurations
+  #   class ParentApp
+  #     include HatiConfiguration::Isolated
+  #
+  #     configure :parent_settings do
+  #       config timeout: 30
+  #       config tries: 3
+  #     end
+  #   end
+  #
+  #   class ChildApp < ParentApp
+  #     parent_settings do
+  #       config tries: 4
+  #     end
+  #   end
+  #
+  #   ChildApp.parent_settings.timeout # => 30
+  #   ChildApp.parent_settings.tries # => 4
+  #   ParentApp.parent_settings.tries # => 3
+  #
+  # @example Configuring a child class
+  #   class AnotherChildApp < ParentApp
+  #     parent_settings do
+  #       config timeout: 60
+  #     end
+  #   end
+  #
+  #   AnotherChildApp.parent_settings.timeout # => 60
+  #   AnotherChildApp.parent_settings.tries # => 3
+  module Local
+    # Extends the base class with HatiConfig::Configuration and HatiConfig::Configuration::Isolated module methods
+    #
+    # @param base [Class] The class extending this module
+    # @return [void]
+    def self.extended(base)
+      base.extend(HatiConfig::Configuration)
+      base.extend(HatiConfig::Configuration::Local)
+    end
+  end
+end

data/lib/hati_config/remote_loader.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'aws-sdk-s3'
+require 'redis'
+require 'json'
+require 'yaml'
+
+module HatiConfig
+  # RemoteLoader handles loading configurations from remote sources like HTTP, S3, and Redis.
+  # It supports automatic refresh and caching of configurations.
+  class RemoteLoader
+    class << self
+      # Loads configuration from an HTTP endpoint
+      #
+      # @param url [String] The URL to load the configuration from
+      # @param headers [Hash] Optional headers to include in the request
+      # @param refresh_interval [Integer] Optional interval in seconds to refresh the configuration
+      # @return [Hash] The loaded configuration
+      # @raise [LoadDataError] If the configuration cannot be loaded
+      def from_http(url:, headers: {})
+        uri = URI(url)
+        request = Net::HTTP::Get.new(uri)
+        headers.each { |key, value| request[key] = value }
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request(request)
+        end
+
+        parse_response(response.body, File.extname(uri.path))
+      rescue StandardError => e
+        raise LoadDataError, "Failed to load configuration from HTTP: #{e.message}"
+      end
+
+      # Loads configuration from an S3 bucket
+      #
+      # @param bucket [String] The S3 bucket name
+      # @param key [String] The S3 object key
+      # @param region [String] The AWS region
+      # @param refresh_interval [Integer] Optional interval in seconds to refresh the configuration
+      # @return [Hash] The loaded configuration
+      # @raise [LoadDataError] If the configuration cannot be loaded
+      def from_s3(bucket:, key:, region:)
+        s3 = Aws::S3::Client.new(region: region)
+        response = s3.get_object(bucket: bucket, key: key)
+        parse_response(response.body.read, File.extname(key))
+      rescue Aws::S3::Errors::ServiceError => e
+        raise LoadDataError, "Failed to load configuration from S3: #{e.message}"
+      end
+
+      # Loads configuration from Redis
+      #
+      # @param host [String] The Redis host
+      # @param key [String] The Redis key
+      # @param port [Integer] The Redis port (default: 6379)
+      # @param db [Integer] The Redis database number (default: 0)
+      # @param refresh_interval [Integer] Optional interval in seconds to refresh the configuration
+      # @return [Hash] The loaded configuration
+      # @raise [LoadDataError] If the configuration cannot be loaded
+      def from_redis(host:, key:, port: 6379, db: 0)
+        redis = Redis.new(host: host, port: port, db: db)
+        data = redis.get(key)
+        raise LoadDataError, "Key '#{key}' not found in Redis" unless data
+
+        parse_response(data)
+      rescue Redis::BaseError => e
+        raise LoadDataError, "Failed to load configuration from Redis: #{e.message}"
+      end
+
+      private
+
+      def parse_response(data, extension = nil)
+        case extension&.downcase
+        when '.json', nil
+          JSON.parse(data, symbolize_names: true)
+        when '.yaml', '.yml'
+          YAML.safe_load(data, symbolize_names: true)
+        else
+          raise LoadDataError, "Unsupported file format: #{extension}"
+        end
+      rescue JSON::ParserError, Psych::SyntaxError => e
+        raise LoadDataError, "Failed to parse configuration: #{e.message}"
+      end
+    end
+  end
+end

data/lib/hati_config/schema.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module HatiConfig
+  # Schema module provides functionality for managing configuration schemas and versioning.
+  module Schema
+    # Defines a schema for configuration validation.
+    #
+    # @param version [String] The schema version (e.g., "1.0", "2.0")
+    # @yield The schema definition block
+    # @example
+    #   schema version: "1.0" do
+    #     required :database_url, type: :string
+    #     optional :pool_size, type: :integer, default: 5
+    #     deprecated :old_setting, since: "1.0", remove_in: "2.0"
+    #   end
+    def schema(version: '1.0', &block)
+      @schema_version = version
+      @schema_definition = SchemaDefinition.new(version)
+      @schema_definition.instance_eval(&block) if block_given?
+      @schema_definition
+    end
+
+    # Gets the current schema version.
+    #
+    # @return [String] The current schema version
+    def schema_version
+      @schema_version || '1.0'
+    end
+
+    # Gets the schema definition.
+    #
+    # @return [SchemaDefinition] The schema definition
+    def schema_definition
+      @schema_definition ||= SchemaDefinition.new(schema_version)
+    end
+
+    # Defines a migration between schema versions.
+    #
+    # @param versions [Hash] The from and to versions (e.g., "1.0" => "2.0")
+    # @yield [config] The migration block
+    # @example
+    #   migration "1.0" => "2.0" do |config|
+    #     config.replica_urls = [config.delete(:backup_url)].compact
+    #   end
+    def migration(versions, &block)
+      schema_definition.add_migration(versions, block)
+    end
+
+    # SchemaDefinition class handles schema validation and migration.
+    class SchemaDefinition
+      attr_reader :version, :required_fields, :optional_fields, :deprecated_fields, :migrations
+
+      def initialize(version)
+        @version = version
+        @required_fields = {}
+        @optional_fields = {}
+        @deprecated_fields = {}
+        @migrations = {}
+      end
+
+      # Defines a field in the schema.
+      #
+      # @param name [Symbol] The field name
+      # @param type [Symbol, Class] The field type
+      # @param required [Boolean] Whether the field is required
+      # @param default [Object] The default value for optional fields
+      # @param since [String] The version since this field is available
+      def field(name, type:, required: true, default: nil, since: version)
+        if required
+          required(name, type: type, since: since)
+        else
+          optional(name, type: type, default: default, since: since)
+        end
+      end
+
+      # Defines a required field in the schema.
+      #
+      # @param name [Symbol] The field name
+      # @param type [Symbol, Class] The field type
+      # @param since [String] The version since this field is required
+      def required(name, type:, since: version)
+        @required_fields[name] = { type: type, since: since }
+      end
+
+      # Defines an optional field in the schema.
+      #
+      # @param name [Symbol] The field name
+      # @param type [Symbol, Class] The field type
+      # @param default [Object] The default value
+      # @param since [String] The version since this field is available
+      def optional(name, type:, default: nil, since: version)
+        @optional_fields[name] = { type: type, default: default, since: since }
+      end
+
+      # Marks a field as deprecated.
+      #
+      # @param name [Symbol] The field name
+      # @param since [String] The version since this field is deprecated
+      # @param remove_in [String] The version when this field will be removed
+      def deprecated(name, since:, remove_in:)
+        @deprecated_fields[name] = { since: since, remove_in: remove_in }
+      end
+
+      # Adds a migration between versions.
+      #
+      # @param from_version [String] The source version
+      # @param to_version [String] The target version
+      # @param block [Proc] The migration block
+      def add_migration(from_version, to_version = nil, block = nil, &implicit_block)
+        if block.nil? && to_version.respond_to?(:call)
+          # Handle the case where to_version is the block
+          block = to_version
+          if from_version.is_a?(Hash)
+            from_version, to_version = from_version.first
+          else
+            from_version, to_version = from_version.to_s.gsub(/['"{}]/, '').split('=>').map(&:strip)
+          end
+        end
+
+        migration_block = block || implicit_block
+        raise MigrationError, 'Invalid migration format' unless from_version && to_version && migration_block
+
+        key = migration_key(from_version, to_version)
+        @migrations[key] = migration_block
+      end
+
+      def migration(versions, &block)
+        if versions.is_a?(Hash)
+          from_version, to_version = versions.first
+        else
+          from_version, to_version = versions.to_s.gsub(/['"{}]/, '').split('=>').map(&:strip)
+        end
+        raise MigrationError, 'Invalid migration format' unless from_version && to_version
+
+        add_migration(from_version, to_version, nil, &block)
+      end
+
+      # Validates configuration data against the schema.
+      #
+      # @param data [Hash] The configuration data to validate
+      # @param current_version [String] The current schema version
+      # @raise [ValidationError] If validation fails
+      def validate(data, current_version = version)
+        validate_required_fields(data, current_version)
+        validate_deprecated_fields(data, current_version)
+        validate_types(data)
+      end
+
+      # Migrates configuration data from one version to another.
+      #
+      # @param data [Hash] The configuration data to migrate
+      # @param from_version [String] The source version
+      # @param to_version [String] The target version
+      # @return [Hash] The migrated configuration data
+      def migrate(data, from_version, to_version)
+        key = migration_key(from_version, to_version)
+        migration = migrations[key]
+        raise MigrationError, "No migration path from #{from_version} to #{to_version}" unless migration
+
+        data = data.dup
+        migration.call(data)
+        data
+      end
+
+      private
+
+      def migration_key(from_version, to_version)
+        "#{from_version}-#{to_version}"
+      end
+
+      def validate_required_fields(data, current_version)
+        required_fields.each do |name, field|
+          next if field[:since] > current_version
+          next if data.key?(name)
+
+          raise ValidationError, "Missing required field: #{name}"
+        end
+      end
+
+      def validate_deprecated_fields(data, current_version)
+        deprecated_fields.each do |name, field|
+          next unless data.key?(name)
+          next unless field[:since] <= current_version
+
+          if field[:remove_in] <= current_version
+            raise ValidationError, "Field #{name} was removed in version #{field[:remove_in]}"
+          end
+
+          warn "Field #{name} is deprecated since version #{field[:since]} and will be removed in #{field[:remove_in]}"
+        end
+      end
+
+      def validate_types(data)
+        all_fields = required_fields.merge(optional_fields)
+        data.each do |name, value|
+          field = all_fields[name]
+          next unless field
+
+          type = field[:type]
+          next if TypeChecker.call(value, type: type)
+
+          raise ValidationError, "Invalid type for field #{name}: expected #{type}, got #{value.class}"
+        end
+      end
+    end
+
+    # Error raised when schema validation fails.
+    class ValidationError < StandardError; end
+
+    # Error raised when schema migration fails.
+    class MigrationError < StandardError; end
+  end
+end