rubydb 0.1.4 → 0.1.5

data/lib/rubydb/cli/commands/doctor.rb

@@ -1,74 +1,74 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module CLI
-    module Commands
-      # Doctor - Run health checks
-      class Doctor
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb doctor [options]"
-            opts.on("--fix", "Attempt to fix issues") do
-              options[:fix] = true
-            end
-            opts.on("--quick", "Quick check only") do
-              options[:quick] = true
-            end
-            opts.on("--json", "Output as JSON") do
-              options[:json] = true
-            end
-            opts.on("-h", "--help", "Show help") do
-              @output.puts opts
-              exit(0)
-            end
-          end
-
-          parser.parse!(args)
-
-          config = RubyDB::Configuration::Config.instance
-          db_path = config.get("storage.data_dir") || "data/rubydb.rdb"
-          checks = []
-          engine = nil
-
-          begin
-            started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-            engine = RubyDB::Storage::Engine.new(db_path, auto_vacuum: false)
-            latency_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
-            checks << { name: "Connection", passed: true, details: { database: db_path, latency_ms: latency_ms } }
-            checks << { name: "Storage", passed: engine.storage_manager.open?, details: engine.storage_manager.stats }
-            checks << { name: "WAL", passed: !engine.wal.nil?, details: engine.wal.stats }
-            unless options[:quick]
-              checks << { name: "Indexes", passed: !engine.index_manager.nil?, details: engine.index_manager.stats }
-            end
-          rescue => e
-            checks << { name: "Connection", passed: false, errors: [e.message] }
-          ensure
-            engine&.close if engine&.open?
-          end
-
-          results = {
-            passed: checks.all? { |check| check[:passed] },
-            total_count: checks.size,
-            passed_count: checks.count { |check| check[:passed] },
-            checks: checks
-          }
-
-          if options[:json]
-            @output.json(results)
-          else
-            @formatter.format_doctor(results)
-
-            if options[:fix] && !results[:passed]
-              @output.puts "\nAutomatic repair is not available for the reported checks; no changes were made.", :yellow
-            end
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Doctor - Run health checks
+      class Doctor
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb doctor [options]"
+            opts.on("--fix", "Attempt to fix issues") do
+              options[:fix] = true
+            end
+            opts.on("--quick", "Quick check only") do
+              options[:quick] = true
+            end
+            opts.on("--json", "Output as JSON") do
+              options[:json] = true
+            end
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          config = RubyDB::Configuration::Config.instance
+          db_path = config.get("storage.data_dir") || "data/rubydb.rdb"
+          checks = []
+          engine = nil
+
+          begin
+            started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            engine = RubyDB::Storage::Engine.new(db_path, auto_vacuum: false)
+            latency_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+            checks << {name: "Connection", passed: true, details: {database: db_path, latency_ms: latency_ms}}
+            checks << {name: "Storage", passed: engine.storage_manager.open?, details: engine.storage_manager.stats}
+            checks << {name: "WAL", passed: !engine.wal.nil?, details: engine.wal.stats}
+            unless options[:quick]
+              checks << {name: "Indexes", passed: !engine.index_manager.nil?, details: engine.index_manager.stats}
+            end
+          rescue => e
+            checks << {name: "Connection", passed: false, errors: [e.message]}
+          ensure
+            engine&.close if engine&.open?
+          end
+
+          results = {
+            passed: checks.all? { |check| check[:passed] },
+            total_count: checks.size,
+            passed_count: checks.count { |check| check[:passed] },
+            checks: checks
+          }
+
+          if options[:json]
+            @output.json(results)
+          else
+            @formatter.format_doctor(results)
+
+            if options[:fix] && !results[:passed]
+              @output.puts "\nAutomatic repair is not available for the reported checks; no changes were made.", :yellow
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/drop.rb

@@ -1,57 +1,57 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module CLI
-    module Commands
-      # Drop - Drop a database
-      class Drop
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb drop [options]"
-            opts.on("-n", "--name NAME", "Database name") do |name|
-              options[:name] = name
-            end
-            opts.on("-f", "--force", "Force drop") do
-              options[:force] = true
-            end
-            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
-            opts.on("--dir DIR", "Database data directory") { |dir| options[:dir] = dir }
-            opts.on("-h", "--help", "Show help") do
-              @output.puts opts
-              exit(0)
-            end
-          end
-
-          parser.parse!(args)
-
-          name = options[:name] || "rubydb"
-          db_path = options[:database] || File.join(options[:dir] || "data", "#{name}.rdb")
-          unless File.file?(db_path)
-            @output.error("Database not found at #{db_path}")
-            return 1
-          end
-
-          unless options[:force]
-            @output.warn("This will permanently delete database '#{name}'")
-            @output.print("Are you sure? (yes/no): ", nil, false)
-            response = $stdin.gets.chomp
-            return unless response.downcase == "yes"
-          end
-
-          @output.spinner("Dropping database #{name}...") do
-            [db_path, "#{db_path}.metadata", "#{db_path}.visibility", "#{db_path}.mvcc", "#{db_path}.wal"].each do |path|
-              FileUtils.rm_rf(path) if File.exist?(path)
-            end
-            @output.success("Database #{name} dropped")
-          end
-          0
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Drop - Drop a database
+      class Drop
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb drop [options]"
+            opts.on("-n", "--name NAME", "Database name") do |name|
+              options[:name] = name
+            end
+            opts.on("-f", "--force", "Force drop") do
+              options[:force] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--dir DIR", "Database data directory") { |dir| options[:dir] = dir }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          name = options[:name] || "rubydb"
+          db_path = options[:database] || File.join(options[:dir] || "data", "#{name}.rdb")
+          unless File.file?(db_path)
+            @output.error("Database not found at #{db_path}")
+            return 1
+          end
+
+          unless options[:force]
+            @output.warn("This will permanently delete database '#{name}'")
+            @output.print("Are you sure? (yes/no): ", nil, false)
+            response = $stdin.gets.chomp
+            return unless response.downcase == "yes"
+          end
+
+          @output.spinner("Dropping database #{name}...") do
+            [db_path, "#{db_path}.metadata", "#{db_path}.visibility", "#{db_path}.mvcc", "#{db_path}.wal"].each do |path|
+              FileUtils.rm_rf(path) if File.exist?(path)
+            end
+            @output.success("Database #{name} dropped")
+          end
+          0
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/init.rb

@@ -1,102 +1,101 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module RubyDB
-  module CLI
-    module Commands
-      class Init
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb init [options]"
-            opts.on("-n", "--name NAME", "Database name") do |name|
-              options[:name] = name
-            end
-            opts.on("-d", "--dir DIR", "Data directory") do |dir|
-              options[:dir] = dir
-            end
-            opts.on("-f", "--force", "Force overwrite") do
-              options[:force] = true
-            end
-            opts.on("-h", "--help", "Show help") do
-              @output.puts opts
-              exit(0)
-            end
-          end
-
-          parser.parse!(args)
-
-          name = options[:name] || "rubydb"
-          dir = options[:dir] || "data"
-          db_path = File.join(dir, "#{name}.rdb")
-
-          if File.exist?(db_path) && !options[:force]
-            @output.error("Database already exists at #{db_path}. Use --force to overwrite.")
-            return 1
-          end
-
-          @output.spinner("Initializing database #{name}...") do
-            # Create directory
-            FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
-
-            # Initialize storage engine
-            engine = RubyDB::Storage::Engine.new(db_path, {})
-            
-            # Create default tables
-            create_default_tables(engine)
-            
-            # Create default user if not exists
-            create_default_user(engine) if options[:user]
-
-            @output.success("Database #{name} initialized at #{db_path}")
-          end
-
-          0
-        end
-
-        private
-
-        def create_default_tables(engine)
-          # Create schema_migrations table
-          engine.create_table("schema_migrations") do |t|
-            t.column("version", :text, primary_key: true)
-            t.column("applied_at", :timestamp)
-          end
-
-          # Create users table
-          engine.create_table("users") do |t|
-            t.column("id", :integer, primary_key: true, auto_increment: true)
-            t.column("username", :text, unique: true, null: false)
-            t.column("email", :text, unique: true)
-            t.column("password_hash", :text)
-            t.column("salt", :text)
-            t.column("created_at", :timestamp)
-            t.column("updated_at", :timestamp)
-          end
-
-          # Create sessions table
-          engine.create_table("sessions") do |t|
-            t.column("id", :integer, primary_key: true, auto_increment: true)
-            t.column("user_id", :integer)
-            t.column("token", :text, unique: true)
-            t.column("created_at", :timestamp)
-            t.column("expires_at", :timestamp)
-          end
-        end
-
-        def create_default_user(engine)
-          # Create admin user
-          engine.insert_row("users", 
-            ["username", "email", "created_at"], 
-            ["admin", "admin@localhost", Time.now]
-          )
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "fileutils"
+
+module RubyDB
+  module CLI
+    module Commands
+      class Init
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb init [options]"
+            opts.on("-n", "--name NAME", "Database name") do |name|
+              options[:name] = name
+            end
+            opts.on("-d", "--dir DIR", "Data directory") do |dir|
+              options[:dir] = dir
+            end
+            opts.on("-f", "--force", "Force overwrite") do
+              options[:force] = true
+            end
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          name = options[:name] || "rubydb"
+          dir = options[:dir] || "data"
+          db_path = File.join(dir, "#{name}.rdb")
+
+          if File.exist?(db_path) && !options[:force]
+            @output.error("Database already exists at #{db_path}. Use --force to overwrite.")
+            return 1
+          end
+
+          @output.spinner("Initializing database #{name}...") do
+            # Create directory
+            FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+
+            # Initialize storage engine
+            engine = RubyDB::Storage::Engine.new(db_path, {})
+
+            # Create default tables
+            create_default_tables(engine)
+
+            # Create default user if not exists
+            create_default_user(engine) if options[:user]
+
+            @output.success("Database #{name} initialized at #{db_path}")
+          end
+
+          0
+        end
+
+        private
+
+        def create_default_tables(engine)
+          # Create schema_migrations table
+          engine.create_table("schema_migrations") do |t|
+            t.column("version", :text, primary_key: true)
+            t.column("applied_at", :timestamp)
+          end
+
+          # Create users table
+          engine.create_table("users") do |t|
+            t.column("id", :integer, primary_key: true, auto_increment: true)
+            t.column("username", :text, unique: true, null: false)
+            t.column("email", :text, unique: true)
+            t.column("password_hash", :text)
+            t.column("salt", :text)
+            t.column("created_at", :timestamp)
+            t.column("updated_at", :timestamp)
+          end
+
+          # Create sessions table
+          engine.create_table("sessions") do |t|
+            t.column("id", :integer, primary_key: true, auto_increment: true)
+            t.column("user_id", :integer)
+            t.column("token", :text, unique: true)
+            t.column("created_at", :timestamp)
+            t.column("expires_at", :timestamp)
+          end
+        end
+
+        def create_default_user(engine)
+          # Create admin user
+          engine.insert_row("users",
+            ["username", "email", "created_at"],
+            ["admin", "admin@localhost", Time.now])
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/inspect.rb

@@ -1,95 +1,95 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module CLI
-    module Commands
-      # Inspect - Inspect database internals
-      class Inspect
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb inspect [options]"
-            opts.on("-t", "--table TABLE", "Inspect specific table") do |table|
-              options[:table] = table
-            end
-            opts.on("--pages", "Show page information") do
-              options[:pages] = true
-            end
-            opts.on("--indexes", "Show index information") do
-              options[:indexes] = true
-            end
-            opts.on("--stats", "Show statistics") do
-              options[:stats] = true
-            end
-            opts.on("--wal", "Show WAL information") do
-              options[:wal] = true
-            end
-            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
-            opts.on("-h", "--help", "Show help") do
-              @output.puts opts
-              exit(0)
-            end
-          end
-
-          parser.parse!(args)
-
-          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
-          engine = database.engine
-          stats = engine.stats
-
-          if options[:table]
-            table = options[:table]
-            raise "Table '#{table}' does not exist" unless engine.table_exists?(table)
-            columns = engine.table_columns(table)
-            @output.heading("Table: #{table}", 2)
-            @output.puts "Columns:"
-            columns.each { |column| @output.puts "  #{column.name}: #{column.type_class}" }
-            @output.puts "\nRows: #{engine.select_rows(table, columns).size}"
-          end
-
-          if options[:pages]
-            @output.heading("Pages", 2)
-            @output.puts "Total pages: #{stats[:page_count]}"
-            @output.puts "Used pages: #{stats[:used_pages]}"
-            @output.puts "Free pages: #{stats[:free_pages]}"
-          end
-
-          if options[:indexes]
-            @output.heading("Indexes", 2)
-            @output.puts "Index statistics: #{engine.index_manager.stats.inspect}"
-          end
-
-          if options[:stats]
-            @output.heading("Statistics", 2)
-            stats.each { |key, value| @output.puts "#{key}: #{value}" }
-          end
-
-          if options[:wal]
-            @output.heading("WAL Information", 2)
-            wal_files = engine.wal_files
-            wal_size = wal_files.sum { |file| File.size(file) }
-            @output.puts "WAL enabled: #{!wal_files.empty?}"
-            @output.puts "WAL files: #{wal_files.size}"
-            @output.puts "WAL size: #{wal_size} bytes"
-          end
-
-          if !options[:table] && !options[:pages] && !options[:indexes] && !options[:stats] && !options[:wal]
-            @output.heading("Database Inspection", 1)
-            @output.puts "Version: #{RubyDB::VERSION}"
-            @output.puts "Tables: #{stats[:table_count]}"
-            @output.puts "Total pages: #{stats[:page_count]}"
-            @output.puts "Database size: #{File.size(engine.path)} bytes"
-            @output.puts "Cache hit rate: #{stats[:cache_hit_rate]}"
-          end
-          0
-        ensure
-          database&.close
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Inspect - Inspect database internals
+      class Inspect
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb inspect [options]"
+            opts.on("-t", "--table TABLE", "Inspect specific table") do |table|
+              options[:table] = table
+            end
+            opts.on("--pages", "Show page information") do
+              options[:pages] = true
+            end
+            opts.on("--indexes", "Show index information") do
+              options[:indexes] = true
+            end
+            opts.on("--stats", "Show statistics") do
+              options[:stats] = true
+            end
+            opts.on("--wal", "Show WAL information") do
+              options[:wal] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
+          engine = database.engine
+          stats = engine.stats
+
+          if options[:table]
+            table = options[:table]
+            raise "Table '#{table}' does not exist" unless engine.table_exists?(table)
+            columns = engine.table_columns(table)
+            @output.heading("Table: #{table}", 2)
+            @output.puts "Columns:"
+            columns.each { |column| @output.puts "  #{column.name}: #{column.type_class}" }
+            @output.puts "\nRows: #{engine.select_rows(table, columns).size}"
+          end
+
+          if options[:pages]
+            @output.heading("Pages", 2)
+            @output.puts "Total pages: #{stats[:page_count]}"
+            @output.puts "Used pages: #{stats[:used_pages]}"
+            @output.puts "Free pages: #{stats[:free_pages]}"
+          end
+
+          if options[:indexes]
+            @output.heading("Indexes", 2)
+            @output.puts "Index statistics: #{engine.index_manager.stats.inspect}"
+          end
+
+          if options[:stats]
+            @output.heading("Statistics", 2)
+            stats.each { |key, value| @output.puts "#{key}: #{value}" }
+          end
+
+          if options[:wal]
+            @output.heading("WAL Information", 2)
+            wal_files = engine.wal_files
+            wal_size = wal_files.sum { |file| File.size(file) }
+            @output.puts "WAL enabled: #{!wal_files.empty?}"
+            @output.puts "WAL files: #{wal_files.size}"
+            @output.puts "WAL size: #{wal_size} bytes"
+          end
+
+          if !options[:table] && !options[:pages] && !options[:indexes] && !options[:stats] && !options[:wal]
+            @output.heading("Database Inspection", 1)
+            @output.puts "Version: #{RubyDB::VERSION}"
+            @output.puts "Tables: #{stats[:table_count]}"
+            @output.puts "Total pages: #{stats[:page_count]}"
+            @output.puts "Database size: #{File.size(engine.path)} bytes"
+            @output.puts "Cache hit rate: #{stats[:cache_hit_rate]}"
+          end
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end