rubydb 0.1.4 → 0.1.6

data/lib/rubydb/configuration/defaults.rb

@@ -1,179 +1,191 @@
-# 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
+# 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
+        },
+
+        # Bundled Go acceleration. Ruby remains the correctness path and
+        # automatically handles operations the accelerator cannot prove safe.
+        accelerator: {
+          mode: "auto",
+          timeout: 30,
+          max_frame_size: 16 * 1024 * 1024,
+          min_rows: 256,
+          read_pipeline: "on",
+          direct_snapshot: true,
+          binary: nil
+        }
+      }
+
+      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|
+          result[key] = if value.is_a?(Hash) && result[key].is_a?(Hash)
+            deep_merge(result[key], value)
+          else
+            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

@@ -1,152 +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
+# 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|
+          result[key] = if value.is_a?(Hash) && result[key].is_a?(Hash)
+            deep_merge(result[key], value)
+          else
+            value
+          end
+        end
+        result
+      end
+    end
+  end
+end