rubydb 0.1.0

data/lib/rubydb/configuration/config.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module RubyDB
+  module Configuration
+    # Config - Main configuration access point
+    class Config
+      include Singleton
+
+      attr_reader :environment, :parser, :validation
+
+      def initialize
+        @environment = Environment.new
+        @parser = Parser.new
+        @validation = Validation.new
+        @loaded = false
+        @config_path = nil
+        @config = {}
+        @lock = Mutex.new
+      end
+
+      def self.load(config_path = nil)
+        instance.load(config_path)
+      end
+
+      def self.get(path)
+        instance.get(path)
+      end
+
+      def self.set(path, value)
+        instance.set(path, value)
+      end
+
+      def self.[](key)
+        instance[key]
+      end
+
+      def self.[]=(key, value)
+        instance[key] = value
+      end
+
+      def self.to_hash
+        instance.to_hash
+      end
+
+      def self.valid?
+        instance.valid?
+      end
+
+      def self.errors
+        instance.errors
+      end
+
+      def self.warnings
+        instance.warnings
+      end
+
+      def self.environment
+        instance.environment.name
+      end
+
+      def self.environment=(env)
+        instance.environment = env
+      end
+
+      def load(config_path = nil)
+        @lock.synchronize do
+          @config_path = config_path
+          @config = @environment.load(config_path)
+          @loaded = true
+          @config
+        end
+      end
+
+      def reload
+        config_path = @lock.synchronize do
+          @loaded = false
+          @config_path
+        end
+        load(config_path)
+      end
+
+      def get(path)
+        ensure_loaded
+        @environment.get(path)
+      end
+
+      def set(path, value)
+        ensure_loaded
+        @environment.set(path, value)
+      end
+
+      def [](key)
+        ensure_loaded
+        @environment[key]
+      end
+
+      def []=(key, value)
+        ensure_loaded
+        @environment[key] = value
+      end
+
+      def to_hash
+        ensure_loaded
+        @environment.to_hash
+      end
+
+      def valid?
+        ensure_loaded
+        @environment.valid?
+      end
+
+      def errors
+        ensure_loaded
+        @environment.errors
+      end
+
+      def warnings
+        ensure_loaded
+        @environment.warnings
+      end
+
+      def environment=(env)
+        @lock.synchronize do
+          @environment = Environment.new(env)
+          @loaded = false
+        end
+      end
+
+      def environment
+        @environment.name
+      end
+
+      def production?
+        @environment.production?
+      end
+
+      def development?
+        @environment.development?
+      end
+
+      def test?
+        @environment.test?
+      end
+
+      def staging?
+        @environment.staging?
+      end
+
+      def stats
+        {
+          loaded: @loaded,
+          config_path: @config_path,
+          environment: environment,
+          config_keys: @config.keys.size,
+          errors: errors.size,
+          warnings: warnings.size,
+          valid: valid?
+        }
+      end
+
+      private
+
+      def ensure_loaded
+        load unless @loaded
+      end
+    end
+  end
+end

data/lib/rubydb/configuration/defaults.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Configuration
+    # Defaults - Default configuration values
+    class Defaults
+      DEFAULTS = {
+        # Server settings
+        server: {
+          host: "localhost",
+          port: 7432,
+          max_connections: 100,
+          min_workers: 2,
+          max_workers: 20,
+          worker_queue_size: 1000,
+          read_timeout: 30,
+          write_timeout: 30,
+          idle_timeout: 300,
+          max_request_size: 10 * 1024 * 1024, # 10MB
+          daemonize: false,
+          pid_file: "rubydb.pid",
+          log_level: "info"
+        },
+
+        # Storage settings
+        storage: {
+          data_dir: "data",
+          page_size: 8192,
+          buffer_pool_size: 1000,
+          wal_enabled: true,
+          wal_dir: "wal",
+          wal_segment_size: 16 * 1024 * 1024, # 16MB
+          wal_keep_segments: 100,
+          fsync: true,
+          compress: false
+        },
+
+        # Database settings
+        database: {
+          name: "rubydb",
+          encoding: "UTF8",
+          locale: "en_US.UTF-8",
+          default_isolation_level: "read_committed",
+          max_connections: 100,
+          statement_timeout: 30,
+          idle_in_transaction_timeout: 60
+        },
+
+        # Authentication settings
+        auth: {
+          method: "password",
+          session_timeout: 3600,
+          max_attempts: 5,
+          lockout_duration: 900,
+          password_algorithm: "sha256",
+          password_iterations: 10000,
+          salt_length: 16
+        },
+
+        # SSL settings
+        ssl: {
+          enabled: false,
+          cert_file: nil,
+          key_file: nil,
+          ca_file: nil,
+          verify_peer: false
+        },
+
+        # Replication settings
+        replication: {
+          enabled: false,
+          role: "standalone",
+          primary_host: nil,
+          primary_port: 7433,
+          sync_mode: "async",
+          sync_replicas: 1,
+          replication_port: 7434,
+          max_replicas: 10
+        },
+
+        # Backup settings
+        backup: {
+          backup_dir: "backups",
+          retention_days: 30,
+          max_backups: 10,
+          verify_after_backup: true,
+          include_wal: true,
+          include_schema: true,
+          compress: true,
+          compression_level: 6
+        },
+
+        # Logging settings
+        logging: {
+          log_dir: "log",
+          log_file: "rubydb.log",
+          log_level: "info",
+          log_format: "json",
+          rotate_size: 10 * 1024 * 1024, # 10MB
+          rotate_count: 10,
+          audit_log: true,
+          slow_query_threshold: 1000 # ms
+        },
+
+        # Monitoring settings
+        monitoring: {
+          enabled: true,
+          metrics_interval: 10,
+          health_check_interval: 30,
+          stats_collector: true,
+          prometheus: false,
+          prometheus_port: 9090
+        },
+
+        # Development settings
+        development: {
+          auto_migrate: true,
+          seed_data: false,
+          debug: false,
+          profile: false,
+          fake_data: false
+        }
+      }
+
+      def self.all
+        DEFAULTS
+      end
+
+      def self.get(path)
+        parts = path.to_s.split(".")
+        value = DEFAULTS
+        parts.each do |part|
+          value = value[part.to_sym]
+          return nil if value.nil?
+        end
+        value
+      end
+
+      def self.set(path, value)
+        parts = path.to_s.split(".")
+        target = DEFAULTS
+        parts[0...-1].each do |part|
+          target = target[part.to_sym]
+          return false if target.nil?
+        end
+        target[parts.last.to_sym] = value
+        true
+      end
+
+      def self.merge(overrides)
+        deep_merge(DEFAULTS, overrides)
+      end
+
+      def self.deep_merge(hash1, hash2)
+        result = hash1.dup
+        hash2.each do |key, value|
+          if value.is_a?(Hash) && result[key].is_a?(Hash)
+            result[key] = deep_merge(result[key], value)
+          else
+            result[key] = value
+          end
+        end
+        result
+      end
+
+      def self.to_hash
+        DEFAULTS
+      end
+
+      def self.keys
+        DEFAULTS.keys
+      end
+
+      def self.has_key?(key)
+        DEFAULTS.key?(key)
+      end
+    end
+  end
+end

data/lib/rubydb/configuration/environment.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Configuration
+    # Environment - Manages environment-specific configuration
+    class Environment
+      attr_reader :name, :config, :defaults
+
+      ENVIRONMENTS = [:development, :test, :production, :staging]
+
+      def initialize(name = nil)
+        @name = name || ENV["RUBYDB_ENV"] || "development"
+        @name = @name.to_sym
+        @defaults = Defaults.all
+        @config = {}
+        @loaded = false
+        @parser = Parser.new
+        @validation = Validation.new
+      end
+
+      def load(config_path = nil)
+        @config = {}
+
+        # Load defaults
+        @config = deep_merge(@config, @defaults)
+
+        # Load base config
+        if config_path
+          base_config = @parser.parse_file(config_path)
+          @config = deep_merge(@config, base_config)
+        end
+
+        # Load environment-specific config
+        env_config_path = config_path ? "#{config_path}.#{@name}" : nil
+        if env_config_path && File.exist?(env_config_path)
+          env_config = @parser.parse_file(env_config_path)
+          @config = deep_merge(@config, env_config)
+        end
+
+        # Load environment variables
+        env_config = @parser.parse_env
+        @config = deep_merge(@config, env_config)
+
+        # Validate
+        @validation.validate(@config)
+
+        @loaded = true
+        @config
+      end
+
+      def reload
+        @loaded = false
+        load
+      end
+
+      def [](key)
+        ensure_loaded
+        get_value(@config, key.to_s)
+      end
+
+      def []=(key, value)
+        ensure_loaded
+        set_value(@config, key.to_s, value)
+      end
+
+      def get(path)
+        ensure_loaded
+        get_value(@config, path.to_s)
+      end
+
+      def set(path, value)
+        ensure_loaded
+        set_value(@config, path.to_s, value)
+      end
+
+      def to_hash
+        ensure_loaded
+        @config.dup
+      end
+
+      def valid?
+        ensure_loaded
+        @validation.valid?
+      end
+
+      def errors
+        ensure_loaded
+        @validation.errors
+      end
+
+      def warnings
+        ensure_loaded
+        @validation.warnings
+      end
+
+      def production?
+        @name == :production
+      end
+
+      def development?
+        @name == :development
+      end
+
+      def test?
+        @name == :test
+      end
+
+      def staging?
+        @name == :staging
+      end
+
+      private
+
+      def ensure_loaded
+        load unless @loaded
+      end
+
+      def get_value(hash, path)
+        parts = path.split(".")
+        value = hash
+        parts.each do |part|
+          return nil unless value.is_a?(Hash) && value.key?(part.to_sym)
+          value = value[part.to_sym]
+        end
+        value
+      end
+
+      def set_value(hash, path, value)
+        parts = path.split(".")
+        target = hash
+        parts[0...-1].each do |part|
+          part = part.to_sym
+          target[part] ||= {}
+          target = target[part]
+        end
+        target[parts.last.to_sym] = value
+      end
+
+      def deep_merge(hash1, hash2)
+        result = hash1.dup
+        hash2.each do |key, value|
+          if value.is_a?(Hash) && result[key].is_a?(Hash)
+            result[key] = deep_merge(result[key], value)
+          else
+            result[key] = value
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/rubydb/configuration/parser.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "json"
+require "erb"
+
+module RubyDB
+  module Configuration
+    # Parser - Parses configuration from various sources
+    class Parser
+      attr_reader :errors, :warnings
+
+      def initialize
+        @errors = []
+        @warnings = []
+      end
+
+      def parse_file(file_path)
+        return {} unless File.exist?(file_path)
+
+        content = File.read(file_path)
+        parse_string(content, file_path)
+      end
+
+      def parse_string(content, source = nil)
+        @errors = []
+        @warnings = []
+
+        # Process ERB if present
+        if content.include?("<%")
+          content = ERB.new(content).result
+        end
+
+        # Try YAML first
+        begin
+          config = YAML.safe_load(content, symbolize_names: true)
+          return config if config.is_a?(Hash)
+        rescue Psych::SyntaxError => e
+          @warnings << "YAML parsing failed, trying JSON: #{e.message}"
+        end
+
+        # Try JSON
+        begin
+          config = JSON.parse(content, symbolize_names: true)
+          return config if config.is_a?(Hash)
+        rescue JSON::ParserError => e
+          @errors << "Failed to parse configuration: #{e.message}"
+        end
+
+        {}
+      end
+
+      def parse_env(prefix = "RUBYDB_")
+        config = {}
+
+        ENV.each do |key, value|
+          next unless key.start_with?(prefix)
+
+          # Convert RUBYDB_SERVER_HOST to server.host
+          path = key[prefix.length..-1].downcase.split("_").join(".")
+          set_nested_value(config, path, parse_value(value))
+        end
+
+        config
+      end
+
+      def parse_args(args)
+        config = {}
+        i = 0
+
+        while i < args.length
+          arg = args[i]
+
+          if arg.start_with?("--")
+            key = arg[2..-1]
+            value = args[i + 1] if i + 1 < args.length
+
+            if value && !value.start_with?("--")
+              set_nested_value(config, key, parse_value(value))
+              i += 2
+            else
+              set_nested_value(config, key, true)
+              i += 1
+            end
+          elsif arg.start_with?("-")
+            key = arg[1..-1]
+            value = args[i + 1] if i + 1 < args.length
+
+            if value && !value.start_with?("-")
+              set_nested_value(config, key, parse_value(value))
+              i += 2
+            else
+              set_nested_value(config, key, true)
+              i += 1
+            end
+          else
+            i += 1
+          end
+        end
+
+        config
+      end
+
+      def parse_url(url)
+        config = {}
+
+        return config unless url =~ /^rubydb:\/\/([^@]+@)?([^:]+):([0-9]+)\/(.+)$/
+
+        user_pass = $1
+        host = $2
+        port = $3.to_i
+        database = $4
+
+        config[:server] ||= {}
+        config[:server][:host] = host
+        config[:server][:port] = port
+
+        config[:database] ||= {}
+        config[:database][:name] = database
+
+        if user_pass
+          user, pass = user_pass.chomp("@").split(":")
+          config[:auth] ||= {}
+          config[:auth][:username] = user
+          config[:auth][:password] = pass if pass
+        end
+
+        config
+      end
+
+      def merge_configs(*configs)
+        result = {}
+        configs.compact.each do |config|
+          result = deep_merge(result, config)
+        end
+        result
+      end
+
+      private
+
+      def parse_value(value)
+        return true if value == "true"
+        return false if value == "false"
+        return nil if value == "null" || value == "nil"
+
+        if value =~ /^\d+$/
+          return value.to_i
+        end
+
+        if value =~ /^\d+\.\d+$/
+          return value.to_f
+        end
+
+        value
+      end
+
+      def set_nested_value(hash, path, value)
+        keys = path.split(".")
+        target = hash
+
+        keys[0...-1].each do |key|
+          key = key.to_sym
+          target[key] ||= {}
+          target = target[key]
+        end
+
+        target[keys.last.to_sym] = value
+      end
+
+      def deep_merge(hash1, hash2)
+        result = hash1.dup
+
+        hash2.each do |key, value|
+          if value.is_a?(Hash) && result[key].is_a?(Hash)
+            result[key] = deep_merge(result[key], value)
+          else
+            result[key] = value
+          end
+        end
+
+        result
+      end
+    end
+  end
+end