hati-config 0.1.0

data/lib/hati_config/setting.rb

@@ -0,0 +1,389 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+
+# HatiConfig module provides functionality for managing HatiConfig features.
+module HatiConfig
+  # rubocop:disable Metrics/ClassLength
+
+  # Setting class provides a configuration tree structure for managing settings.
+  #
+  # This class allows for dynamic configuration management, enabling
+  # the loading of settings from hashes, YAML, or JSON formats.
+  #
+  # @example Basic usage
+  #   settings = Setting.new do
+  #     config(:key1, value: "example")
+  #     config(:key2, type: :int)
+  #   end
+  #
+  class Setting
+    extend HatiConfig::Environment
+    include HatiConfig::Environment
+    extend HatiConfig::Schema
+    extend HatiConfig::Cache
+    extend HatiConfig::Encryption
+
+    # Dynamically define methods for each type in TypeMap.
+    #
+    # @!method int(value)
+    #   Sets an integer configuration value.
+    #   @param value [Integer] The integer value to set.
+    #
+    # @!method string(value)
+    #   Sets a string configuration value.
+    #   @param value [String] The string value to set.
+    #
+    # ... (other type methods)
+    HatiConfig::TypeMap.list_types.each do |type|
+      define_method(type.downcase) do |stng, lock = nil|
+        params = { type: type }
+        params[:lock] = lock if lock.nil?
+
+        config(stng, **params)
+      end
+    end
+
+    # Initializes a new Setting instance.
+    #
+    # @yield [self] Configures the instance upon creation if a block is given.
+    def initialize(&block)
+      @config_tree = {}
+      @schema = {}
+      @immutable_schema = {}
+      @encrypted_tree = {}
+
+      if self.class.encryption_config.key_provider
+        self.class.encryption do
+          key_provider :env
+        end
+      end
+
+      instance_eval(&block) if block_given?
+    end
+
+    # Loads configuration from a hash with an optional schema.
+    #
+    # @param data [Hash] The hash containing configuration data.
+    # @param schema [Hash] Optional schema for type validation.
+    # @raise [NoMethodError] If a method corresponding to a key is not defined.
+    # @raise [SettingTypeError] If a value doesn't match the specified type in the schema.
+    #
+    # @example Loading from a hash with type validation
+    #   settings.load_from_hash({ name: "admin", max_connections: 10 }, schema: { name: :str, max_connections: :int })
+    def load_from_hash(data, schema: {}, lock_schema: {}, encrypted_fields: {})
+      data.each do |key, value|
+        key = key.to_sym
+        type = schema[key] if schema
+        lock = lock_schema[key] if lock_schema
+        encrypted = encrypted_fields[key] if encrypted_fields
+
+        if value.is_a?(Hash)
+          configure(key) do
+            load_from_hash(value,
+                           schema: schema.is_a?(Hash) ? schema[key] : {},
+                           lock_schema: lock_schema.is_a?(Hash) ? lock_schema[key] : {},
+                           encrypted_fields: encrypted_fields.is_a?(Hash) ? encrypted_fields[key] : {})
+          end
+        elsif value.is_a?(Setting)
+          configure(key) do
+            load_from_hash(value.to_h, schema: schema[key], lock_schema: lock_schema[key],
+                                       encrypted_fields: encrypted_fields[key])
+          end
+        else
+          config(key => value, type: type, lock: lock, encrypted: encrypted)
+        end
+      end
+    end
+
+    # Configures a node of the configuration tree.
+    #
+    # @param node [Symbol, String] The name of the config node key.
+    # @yield [Setting] A block that configures the new node.
+    #
+    # @example Configuring a new node
+    #   settings.configure(:database) do
+    #     config(:host, value: "localhost")
+    #     config(:port, value: 5432)
+    #   end
+    def configure(node, &block)
+      if config_tree[node]
+        config_tree[node].instance_eval(&block)
+      else
+        create_new_node(node, &block)
+      end
+    end
+
+    # Configures a setting with a given name and type.
+    #
+    # @param setting [Symbol, Hash, nil] The name of the setting or a hash of settings.
+    # @param type [Symbol, nil] The expected type of the setting.
+    # @param opt [Hash] Additional options for configuration.
+    # @return [self] The current instance for method chaining.
+    # @raise [SettingTypeError] If the value does not match the expected type.
+    #
+    # @example Configuring a setting
+    #   settings.config(max_connections: 10, type: :int)
+    def config(setting = nil, type: nil, lock: nil, encrypted: false, **opt)
+      return self if !setting && opt.empty?
+
+      # If setting is a symbol/string and we have keyword options, merge them
+      if (setting.is_a?(Symbol) || setting.is_a?(String)) && !opt.empty?
+        raw_stngs = opt.merge(setting => opt[:value])
+        raw_stngs.delete(:value)
+      else
+        raw_stngs = setting || opt
+      end
+      stngs = extract_setting_info(raw_stngs)
+
+      stng_lock = determine_lock(stngs, lock)
+      stng_type = determine_type(stngs, type)
+      stng_encrypted = determine_encrypted(stngs, encrypted)
+
+      if stng_encrypted
+        value = stngs[:value]
+        if value.nil? && config_tree[stngs[:name]]
+          value = config_tree[stngs[:name]]
+          value = self.class.encryption_config.decrypt(value) if @encrypted_tree[stngs[:name]]
+        end
+
+        if value.is_a?(HatiConfig::Setting)
+          # Handle nested settings
+          value.instance_eval(&block) if block_given?
+        elsif !value.nil?
+          # If we're setting a new value or updating an existing one
+          raise SettingTypeError.new('string (encrypted values must be strings)', value) unless value.is_a?(String)
+
+          stngs[:value] = self.class.encryption_config.encrypt(value)
+          @encrypted_tree[stngs[:name]] = true
+          # If we're just marking an existing value as encrypted
+        elsif config_tree[stngs[:name]]
+          value = config_tree[stngs[:name]]
+          raise SettingTypeError.new('string (encrypted values must be strings)', value) unless value.is_a?(String)
+
+          stngs[:value] = self.class.encryption_config.encrypt(value)
+          @encrypted_tree[stngs[:name]] = true
+        end
+      end
+
+      validate_and_set_configuration(stngs, stng_lock, stng_type, stng_encrypted)
+      self
+    end
+
+    # Returns the type schema of the configuration.
+    #
+    # @return [Hash] A hash representing the type schema.
+    # @example Retrieving the type schema
+    #   schema = settings.type_schema
+    def type_schema
+      {}.tap do |hsh|
+        config_tree.each do |k, v|
+          v.is_a?(HatiConfig::Setting) ? (hsh[k] = v.type_schema) : hsh.merge!(schema)
+        end
+      end
+    end
+
+    def lock_schema
+      {}.tap do |hsh|
+        config_tree.each do |k, v|
+          v.is_a?(HatiConfig::Setting) ? (hsh[k] = v.lock_schema) : hsh.merge!(immutable_schema)
+        end
+      end
+    end
+
+    # Converts the configuration tree into a hash.
+    #
+    # @return [Hash] The config tree as a hash.
+    # @example Converting to hash
+    #   hash = settings.to_h
+    def to_h
+      {}.tap do |hsh|
+        config_tree.each do |k, v|
+          hsh[k] = if v.is_a?(HatiConfig::Setting)
+                     v.to_h
+                   else
+                     get_value(k)
+                   end
+        end
+      end
+    end
+
+    # Converts the configuration tree into YAML format.
+    #
+    # @param dump [String, nil] Optional file path to dump the YAML.
+    # @return [String, nil] The YAML string or nil if dumped to a file.
+    # @example Converting to YAML
+    #   yaml_string = settings.to_yaml
+    #   settings.to_yaml(dump: "config.yml") # Dumps to a file
+    def to_yaml(dump: nil)
+      yaml = to_h.to_yaml
+      dump ? File.write(dump, yaml) : yaml
+    end
+
+    # Converts the configuration tree into JSON format.
+    #
+    # @return [String] The JSON representation of the configuration tree.
+    # @example Converting to JSON
+    #   json_string = settings.to_json
+    def to_json(*_args)
+      to_h.to_json
+    end
+
+    # Provides hash-like access to configuration values
+    #
+    # @param key [Symbol, String] The key to access
+    # @return [Object] The value associated with the key
+    def [](key)
+      key = key.to_sym if key.is_a?(String)
+      return get_value(key) if config_tree.key?(key)
+
+      raise NoMethodError, "undefined method `[]' with key #{key} for #{self.class}"
+    end
+
+    # Sets a configuration value using hash-like syntax
+    #
+    # @param key [Symbol, String] The key to set
+    # @param value [Object] The value to set
+    def []=(key, value)
+      key = key.to_sym if key.is_a?(String)
+      config(key => value)
+    end
+
+    protected
+
+    # @return [Hash] The schema of configuration types.
+    attr_reader :schema, :immutable_schema
+
+    private
+
+    # @return [Hash] The tree structure of configuration settings.
+    attr_reader :config_tree
+
+    # Creates a new node in the configuration tree.
+    #
+    # @param node [Symbol] The name of the node to create.
+    # @yield [Setting] A block to configure the new setting.
+    # @return [Setting] The newly created setting node.
+    def create_new_node(node, &block)
+      new_node = HatiConfig::Setting.new
+      if self.class.encryption_config.key_provider
+        new_node.class.encryption do
+          key_provider :env
+        end
+      end
+      new_node.instance_eval(&block) if block_given?
+      config_tree[node] = new_node
+      define_node_methods(node)
+      new_node
+    end
+
+    # Defines singleton methods for the given node.
+    #
+    # @param node [Symbol] The name of the node to define methods for.
+    def define_node_methods(node)
+      define_singleton_method(node) do |*_args, &node_block|
+        if node_block
+          config_tree[node].instance_eval(&node_block)
+        else
+          config_tree[node]
+        end
+      end
+    end
+
+    # Extracts the setting information from the provided input.
+    #
+    # @param stngs [Symbol, Hash] The setting name or a hash containing the setting name and value.
+    # @return [Hash] A hash containing the setting name and its corresponding value.
+    def extract_setting_info(stngs)
+      val = nil
+      lock = nil
+      encrypted = nil
+
+      if stngs.is_a?(Symbol)
+        name = stngs
+      elsif stngs.is_a?(Hash)
+        lock = stngs.delete(:lock)
+        encrypted = stngs.delete(:encrypted)
+        name, val = stngs.to_a.first
+      end
+
+      { name: name, value: val, lock: lock, encrypted: encrypted }
+    end
+
+    def handle_value(key, value, type, lock, encrypted = false)
+      validate_mutable!(key, lock) if lock
+      validate_setting!(value, type) if type
+
+      config(key => value, type: type, lock: lock, encrypted: encrypted)
+      self
+    end
+
+    def get_value(key)
+      value = config_tree[key]
+      return value if value.is_a?(HatiConfig::Setting)
+      return self.class.encryption_config.decrypt(value) if @encrypted_tree[key]
+
+      value
+    end
+
+    # Validates the setting value against the expected type.
+    #
+    # @param stng_val [Object] The value of the setting to validate.
+    # @param stng_type [Symbol] The expected type of the setting.
+    # @raise [SettingTypeError] If the setting value does not match the expected type.
+    def validate_setting!(stng_val, stng_type)
+      is_valid = HatiConfig::TypeChecker.call(stng_val, type: stng_type)
+      raise HatiConfig::SettingTypeError.new(stng_type, stng_val) unless !stng_val || is_valid
+    end
+
+    def validate_mutable!(name, stng_lock)
+      raise "<#{name}> setting is immutable" if stng_lock
+    end
+
+    # Sets the configuration for a given setting name, value, and type.
+    #
+    # @param stng_name [Symbol] The name of the setting to configure.
+    # @param stng_val [Object] The value to assign to the setting.
+    # @param stng_type [Symbol] The type of the setting.
+    def set_configuration(stng_name:, stng_val:, stng_type:, stng_lock:)
+      schema[stng_name] = stng_type
+      config_tree[stng_name] = stng_val
+      immutable_schema[stng_name] = stng_lock
+
+      return if respond_to?(stng_name)
+
+      define_singleton_method(stng_name) do |value = nil, type: nil, lock: nil, encrypted: false|
+        return get_value(stng_name) unless value || encrypted
+
+        if encrypted && !value.nil? && !value.is_a?(String)
+          raise SettingTypeError.new('string (encrypted values must be strings)', value)
+        end
+
+        config(**{ stng_name => value, type: type, lock: lock, encrypted: encrypted })
+      end
+    end
+
+    def determine_lock(stngs, lock)
+      lock.nil? ? stngs[:lock] : lock
+    end
+
+    def determine_type(stngs, type)
+      type || schema[stngs[:name]] || :any
+    end
+
+    def determine_encrypted(stngs, encrypted)
+      encrypted.nil? ? stngs[:encrypted] : encrypted
+    end
+
+    def validate_and_set_configuration(stngs, stng_lock, stng_type, stng_encrypted)
+      validate_mutable!(stngs[:name], stng_lock) if stngs[:value] && config_tree[stngs[:name]] && !stng_lock
+      validate_setting!(stngs[:value], stng_type)
+
+      set_configuration(stng_name: stngs[:name], stng_val: stngs[:value], stng_type: stng_type, stng_lock: stng_lock)
+      @encrypted_tree[stngs[:name]] = stng_encrypted if stng_encrypted
+      self
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/hati_config/team.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module HatiConfig
+  # Team module provides functionality for managing team-specific configurations.
+  module Team
+    # Defines team-specific configuration namespace.
+    #
+    # @param team_name [Symbol] The name of the team (e.g., :frontend, :backend, :mobile)
+    # @yield The configuration block for the team
+    # @example
+    #   team :frontend do
+    #     configure :settings do
+    #       config api_endpoint: '/api/v1'
+    #       config cache_ttl: 300
+    #     end
+    #   end
+    def team(team_name, &block)
+      team_module = Module.new do
+        extend HatiConfig::Configuration
+        extend HatiConfig::Environment
+      end
+
+      const_name = team_name.to_s.capitalize
+      const_set(const_name, team_module)
+      team_module.instance_eval(&block) if block_given?
+
+      # Define method for accessing team module
+      singleton_class.class_eval do
+        define_method(team_name) { const_get(const_name) }
+      end
+
+      team_module
+    end
+
+    # Gets a list of all defined teams.
+    #
+    # @return [Array<Symbol>] The list of team names
+    def teams
+      constants.select { |c| const_get(c).is_a?(Module) && const_get(c).respond_to?(:configure) }
+    end
+
+    # Gets a specific team's configuration module.
+    #
+    # @param team_name [Symbol] The name of the team
+    # @return [Module] The team's configuration module
+    # @raise [NameError] If the team does not exist
+    def [](team_name)
+      const_get(team_name.to_s.capitalize)
+    end
+
+    # Checks if a team exists.
+    #
+    # @param team_name [Symbol] The name of the team
+    # @return [Boolean] True if the team exists
+    def team?(team_name)
+      const_defined?(team_name.to_s.capitalize)
+    end
+
+    # Removes a team's configuration.
+    #
+    # @param team_name [Symbol] The name of the team
+    # @return [Boolean] True if the team was removed
+    def remove_team?(team_name)
+      const_name = team_name.to_s.capitalize
+      return false unless const_defined?(const_name)
+
+      remove_const(const_name)
+      true
+    end
+
+    # Temporarily switches to a team's configuration context.
+    #
+    # @param team_name [Symbol] The name of the team
+    # @yield The block to execute in the team's context
+    # @example
+    #   with_team(:frontend) do
+    #     # Configuration will use frontend team's context here
+    #   end
+    def with_team(team_name)
+      raise NameError, "Team '#{team_name}' does not exist" unless team?(team_name)
+
+      yield self[team_name]
+    end
+  end
+end

data/lib/hati_config/type_checker.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# HatiConfig module provides functionality for managing HatiConfig features.
+module HatiConfig
+  # This class is responsible for type checking in the Hati configuration.
+  class TypeChecker
+    class << self
+      # Calls the appropriate validation method based on the type.
+      #
+      # @param value [Object] The value to validate.
+      # @param type [Symbol, Array<Symbol, Class>, Class] The type(s) to validate against.
+      # @return [Boolean] True if the value matches the type, false otherwise.
+      # @raise [TypeCheckerError] if the type is unsupported or not defined.
+      #
+      # @example
+      #   TypeChecker.call(1, type: :int) # => true
+      #   TypeChecker.call(1, type: :numeric) # => true
+      #   TypeChecker.call("hello", type: [:str, Integer]) # => true
+      #   TypeChecker.call(CustomClass.new, type: CustomClass) # => true
+      def call(value, type:, **_opts)
+        case type
+        when Symbol
+          base_type(value, fetch_type(type))
+        when Array
+          if type.length == 1 && type.first.is_a?(Symbol)
+            # Array type validation (e.g., [:string] for array of strings)
+            return false unless value.is_a?(Array)
+
+            value.all? { |v| call(v, type: type.first) }
+          else
+            # Union type validation (e.g., [:string, Integer] for string or integer)
+            one_of(value, type)
+          end
+        else
+          custom_type?(value, type)
+        end
+      end
+
+      # Validates if value matches the base type.
+      #
+      # @param value [Object] the value to validate
+      # @param type [Class] the type to validate against
+      # @return [Boolean] true if the value matches the base type
+      # @raise [TypeCheckerError] if the type is unsupported or not defined.
+      #
+      # @example
+      #   TypeChecker.base_type(1, Integer) # => true
+      #   TypeChecker.base_type(1, [:int, :float, :big_decimal]) # => true
+      def base_type(value, type)
+        type = fetch_type(type) if type.is_a?(Symbol)
+
+        return type.call(value) if type.is_a?(Proc)
+
+        type.is_a?(Array) ? one_of(value, type) : value.is_a?(type)
+      end
+
+      # Checks if value matches any type in the array.
+      #
+      # @param value [Object] the value to validate
+      # @param array_type [Array<Symbol, Class>] the array of types to validate against
+      # @return [Boolean] true if the value matches any type in the array
+      #
+      # @example
+      #   TypeChecker.one_of(1, [Integer, :str]) # => true
+      #   TypeChecker.one_of("hello", [Integer, String, :sym]) # => true
+      #   TypeChecker.one_of(nil, [:null, Integer, String]) # => true
+      #   TypeChecker.one_of(1.5, [:int, :float, :big_decimal]) # => true
+      def one_of(value, array_type)
+        array_type.any? { |type| type.is_a?(Symbol) ? base_type(value, type) : custom_type?(value, type) }
+      end
+
+      # Validates if value is of the specified custom type.
+      #
+      # @param value [Object] the value to validate
+      # @param type [Class] the custom type to validate against
+      # @return [Boolean] true if the value is of the specified custom type
+      #
+      # @example
+      #   TypeChecker.custom_type(1, Integer) # => true
+      #   TypeChecker.custom_type(CustomClass.new, CustomClass) # => true
+      def custom_type?(value, type)
+        value.is_a?(type)
+      end
+
+      # Fetches the basic type from the type map.
+      #
+      # @param type [Symbol] the type to fetch
+      # @return [Class] the corresponding basic type
+      # @raise [TypeCheckerError] if the type does not exist in TYPE_MAP
+      #
+      # @example
+      #   TypeChecker.fetch_type(:int) # => Integer
+      #   TypeChecker.fetch_type(:null) # => NilClass
+      #   TypeChecker.fetch_type(:bool) # => [:truthy, :falsy]
+      def fetch_type(type)
+        basic_type = TypeMap.get(type)
+        raise HatiConfig::TypeCheckerError, type unless basic_type
+
+        basic_type
+      end
+    end
+  end
+end

data/lib/hati_config/type_map.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'date'
+
+# HatiConfig module provides functionality for managing HatiConfig features.
+module HatiConfig
+  # A class that maps type symbols to their corresponding Ruby classes and provides
+  # predefined collections of type symbols for various categories.
+  #
+  # This class allows retrieval of Ruby classes based on type symbols and provides
+  # methods to access collections of specific type symbols such as booleans, numerics,
+  # and chronological types.
+  class TypeMap
+    TYPE_MAP = {
+      # base types
+      int: Integer,
+      integer: Integer,
+      str: String,
+      string: String,
+      sym: Symbol,
+      null: NilClass,
+      true_class: TrueClass,
+      false_class: FalseClass,
+      # data structures
+      hash: Hash,
+      array: Array,
+      # numeric types
+      big_decimal: BigDecimal,
+      float: Float,
+      complex: Complex,
+      rational: Rational,
+      # time types
+      date: Date,
+      date_time: DateTime,
+      time: Time,
+      # any type
+      any: Object,
+      # composite types
+      bool: %i[true_class false_class],
+      numeric: %i[int float big_decimal],
+      kernel_num: %i[int float big_decimal complex rational],
+      chrono: %i[date date_time time]
+    }.freeze
+
+    # Retrieves the Ruby class associated with a given type symbol.
+    #
+    # @param type [Symbol] The type symbol to look up. Must be one of the keys in TYPE_MAP.
+    # @return [Class, nil] The corresponding Ruby class or nil if the type symbol is not found.
+    #
+    # @example
+    #   TypeMap.get(:int) # => Integer
+    #   TypeMap.get(:str) # => String
+    #   TypeMap.get(:unknown) # => nil
+    def self.get(type)
+      TYPE_MAP[type]
+    end
+
+    # Returns an array of all type symbols defined in TYPE_MAP.
+    #
+    # @return [Array<Symbol>] An array containing all keys from TYPE_MAP.
+    #
+    # @example
+    #   TypeMap.list_types # => [:int, :str, :sym, :null, :true_class, :false_class,
+    #                          :hash, :array, :big_decimal, :float, :complex,
+    #                          :rational, :date, :date_time, :time, :any,
+    #                          :bool, :numeric, :kernel_num, :chrono]
+    def self.list_types
+      TYPE_MAP.keys
+    end
+  end
+end

data/lib/hati_config/version.rb

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

data/lib/hati_config.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'hati_config/version'
+require 'hati_config/errors'
+require 'hati_config/type_map'
+require 'hati_config/type_checker'
+require 'hati_config/remote_loader'
+require 'hati_config/environment'
+require 'hati_config/team'
+require 'hati_config/schema'
+require 'hati_config/cache'
+require 'hati_config/encryption'
+require 'hati_config/setting'
+require 'hati_config/configuration'
+require 'hati_config/hati_configuration'