rubydb 0.1.4 → 0.1.5

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

@@ -1,63 +1,63 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module CLI
-    module Commands
-      # Merge - Merge a branch
-      class Merge
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb merge [options]"
-            opts.on("--into BRANCH", "Target branch") do |branch|
-              options[:into] = branch
-            end
-            opts.on("--strategy STRATEGY", "Merge strategy (fast-forward, recursive)") do |strategy|
-              options[:strategy] = strategy.to_sym
-            end
-            opts.on("--no-commit", "Don't commit after merge") do
-              options[:no_commit] = true
-            end
-            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
-            opts.on("--branch-dir DIR", "Branch metadata directory") { |path| options[:branch_dir] = path }
-            opts.on("-h", "--help", "Show help") do
-              @output.puts opts
-              exit(0)
-            end
-          end
-
-          parser.parse!(args)
-
-          source = args.first
-          if source.nil?
-            @output.error("Source branch required")
-            @output.puts parser
-            return
-          end
-
-          target = options[:into] || "main"
-          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
-          manager = RubyDB::Branching::BranchManager.new(
-            database.engine,
-            branch_dir: options[:branch_dir] || "branches"
-          )
-          merger = RubyDB::Branching::Merge.new(database.engine, manager,
-                                                strategy: (options[:strategy] || :fast_forward))
-          result = nil
-          @output.spinner("Merging #{source} into #{target}...") do
-            result = merger.merge(source, target, abort_on_conflict: true)
-          end
-          raise result[:error] || result[:message] unless result[:success]
-          @output.success(result[:message] || "Merge completed successfully")
-          0
-        ensure
-          database&.close
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Merge - Merge a branch
+      class Merge
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb merge [options]"
+            opts.on("--into BRANCH", "Target branch") do |branch|
+              options[:into] = branch
+            end
+            opts.on("--strategy STRATEGY", "Merge strategy (fast-forward, recursive)") do |strategy|
+              options[:strategy] = strategy.to_sym
+            end
+            opts.on("--no-commit", "Don't commit after merge") do
+              options[:no_commit] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--branch-dir DIR", "Branch metadata directory") { |path| options[:branch_dir] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          source = args.first
+          if source.nil?
+            @output.error("Source branch required")
+            @output.puts parser
+            return
+          end
+
+          target = options[:into] || "main"
+          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
+          manager = RubyDB::Branching::BranchManager.new(
+            database.engine,
+            branch_dir: options[:branch_dir] || "branches"
+          )
+          merger = RubyDB::Branching::Merge.new(database.engine, manager,
+            strategy: options[:strategy] || :fast_forward)
+          result = nil
+          @output.spinner("Merging #{source} into #{target}...") do
+            result = merger.merge(source, target, abort_on_conflict: true)
+          end
+          raise result[:error] || result[:message] unless result[:success]
+          @output.success(result[:message] || "Merge completed successfully")
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

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

@@ -1,62 +1,62 @@
-# frozen_string_literal: true
-
-require "optparse"
-
-module RubyDB
-  module CLI
-    module Commands
-      # Migrate - Run database migrations
-      class Migrate
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb migrate [options]"
-            opts.on("-v", "--version VERSION", "Migrate to version") do |version|
-              options[:version] = version
-            end
-            opts.on("-s", "--steps N", Integer, "Rollback N steps") do |steps|
-              options[:steps] = steps
-            end
-            opts.on("--down", "Migrate down") do
-              options[:down] = true
-            end
-            opts.on("--dry-run", "Show what would be run") do
-              options[:dry_run] = true
-            end
-            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
-            opts.on("--path DIR", "Migration directory") { |path| options[:migrations_path] = 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
-          manager = RubyDB::Migrations::MigrationManager.new(
-            database,
-            path: options[:migrations_path] || "db/migrate",
-            version: options[:version]
-          )
-          if options[:dry_run]
-            @formatter.format_migrations(manager.status)
-          elsif options[:down]
-            manager.rollback(options[:steps] || 1)
-            @output.success("Migration rollback completed")
-          else
-            manager.migrate
-            @output.success("Migrations completed successfully")
-          end
-          0
-        ensure
-          database&.close
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyDB
+  module CLI
+    module Commands
+      # Migrate - Run database migrations
+      class Migrate
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb migrate [options]"
+            opts.on("-v", "--version VERSION", "Migrate to version") do |version|
+              options[:version] = version
+            end
+            opts.on("-s", "--steps N", Integer, "Rollback N steps") do |steps|
+              options[:steps] = steps
+            end
+            opts.on("--down", "Migrate down") do
+              options[:down] = true
+            end
+            opts.on("--dry-run", "Show what would be run") do
+              options[:dry_run] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--path DIR", "Migration directory") { |path| options[:migrations_path] = 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
+          manager = RubyDB::Migrations::MigrationManager.new(
+            database,
+            path: options[:migrations_path] || "db/migrate",
+            version: options[:version]
+          )
+          if options[:dry_run]
+            @formatter.format_migrations(manager.status)
+          elsif options[:down]
+            manager.rollback(options[:steps] || 1)
+            @output.success("Migration rollback completed")
+          else
+            manager.migrate
+            @output.success("Migrations completed successfully")
+          end
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

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

@@ -1,39 +1,42 @@
-# frozen_string_literal: true
-
-require "optparse"
-
-module RubyDB
-  module CLI
-    module Commands
-      # Sends a restart signal to the process recorded by the PID file.
-      class Restart
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb restart [options]"
-            opts.on("--pid-file FILE", "PID file") { |file| options[:pid_file] = file }
-            opts.on("--force", "Send KILL instead of TERM") { options[:force] = true }
-            opts.on("-h", "--help", "Show help") { @output.puts opts; return 0 }
-          end
-          parser.parse!(args)
-
-          pid_file = options[:pid_file] || "rubydb.pid"
-          raise "PID file not found: #{pid_file}" unless File.file?(pid_file)
-          pid = Integer(File.read(pid_file).strip, 10)
-          Process.kill(0, pid)
-          Process.kill(options[:force] ? "KILL" : "TERM", pid)
-          @output.success("RubyDB restart signal sent to PID #{pid}")
-          0
-        rescue Errno::ESRCH
-          raise "RubyDB process #{pid} is not running"
-        rescue ArgumentError
-          raise "Invalid PID in #{pid_file}"
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyDB
+  module CLI
+    module Commands
+      # Sends a restart signal to the process recorded by the PID file.
+      class Restart
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb restart [options]"
+            opts.on("--pid-file FILE", "PID file") { |file| options[:pid_file] = file }
+            opts.on("--force", "Send KILL instead of TERM") { options[:force] = true }
+            opts.on("-h", "--help", "Show help") {
+              @output.puts opts
+              return 0
+            }
+          end
+          parser.parse!(args)
+
+          pid_file = options[:pid_file] || "rubydb.pid"
+          raise "PID file not found: #{pid_file}" unless File.file?(pid_file)
+          pid = Integer(File.read(pid_file).strip, 10)
+          Process.kill(0, pid)
+          Process.kill(options[:force] ? "KILL" : "TERM", pid)
+          @output.success("RubyDB restart signal sent to PID #{pid}")
+          0
+        rescue Errno::ESRCH
+          raise "RubyDB process #{pid} is not running"
+        rescue ArgumentError
+          raise "Invalid PID in #{pid_file}"
+        end
+      end
+    end
+  end
+end

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

@@ -1,121 +1,121 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module CLI
-    module Commands
-      class Restore
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb restore [options]"
-            opts.on("-b", "--backup NAME", "Backup name") do |name|
-              options[:backup] = name
-            end
-            opts.on("-l", "--latest", "Restore latest backup") do
-              options[:latest] = true
-            end
-            opts.on("--point-in-time TIME", "Restore to point in time") do |time|
-              options[:point_in_time] = time
-            end
-            opts.on("--dry-run", "Show what would be restored") do
-              options[:dry_run] = true
-            end
-            opts.on("-f", "--force", "Force restore") do
-              options[:force] = true
-            end
-            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
-            opts.on("--dir DIR", "Backup directory") { |path| options[:backup_dir] = path }
-            opts.on("-h", "--help", "Show help") do
-              @output.puts opts
-              exit(0)
-            end
-          end
-
-          parser.parse!(args)
-
-          # Get real config
-          config = RubyDB::Configuration::Config.instance
-          db_path = options[:database] || config.get("storage.data_dir") || "data/rubydb.rdb"
-          backup_dir = options[:backup_dir] || config.get("backup.backup_dir") || "backups"
-
-          selected_path = if options[:backup]
-                            File.join(backup_dir, options[:backup])
-                          elsif options[:latest]
-                            nil
-                          end
-
-          if options[:dry_run]
-            available = RubyDB::Backup::Restore.new(nil, backup_dir: backup_dir).list_available_backups
-            selected = if selected_path
-                         available.find { |backup| backup[:path] == selected_path }
-                       else
-                         available.first
-                       end
-            raise "No matching backup available" unless selected
-            @output.info("Would restore #{selected[:name]} from #{selected[:path]}")
-            return 0
-          end
-
-          unless options[:force]
-            @output.warn("This will overwrite the current database")
-            @output.print("Are you sure? (yes/no): ", nil, false)
-            response = $stdin.gets.chomp
-            return 1 unless response.downcase == "yes"
-          end
-
-          # Create restore instance
-          engine = RubyDB::Storage::Engine.new(db_path, {})
-          restore = RubyDB::Backup::Restore.new(engine, backup_dir: backup_dir)
-
-          if options[:latest]
-            @output.spinner("Restoring latest backup...") do
-              result = restore.restore_latest
-
-              if result[:success]
-                @output.success("Backup restored successfully")
-              else
-                @output.error("Restore failed: #{result[:error]}")
-                return 1
-              end
-            end
-          elsif options[:backup]
-          backup_path = File.join(backup_dir, options[:backup])
-            @output.spinner("Restoring backup #{options[:backup]}...") do
-              result = restore.restore(backup_path)
-
-              if result[:success]
-                @output.success("Backup restored successfully")
-              else
-                @output.error("Restore failed: #{result[:error]}")
-                return 1
-              end
-            end
-          elsif options[:point_in_time]
-            @output.spinner("Restoring to point in time #{options[:point_in_time]}...") do
-              result = restore.restore_point_in_time(options[:point_in_time])
-
-              if result[:success]
-                @output.success("Database restored to #{options[:point_in_time]}")
-              else
-                @output.error("Restore failed: #{result[:error]}")
-                return 1
-              end
-            end
-          else
-            @output.error("Please specify --backup, --latest, or --point-in-time")
-            @output.puts parser
-            return 1
-          end
-
-          0
-        ensure
-          engine&.close if engine&.open?
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      class Restore
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb restore [options]"
+            opts.on("-b", "--backup NAME", "Backup name") do |name|
+              options[:backup] = name
+            end
+            opts.on("-l", "--latest", "Restore latest backup") do
+              options[:latest] = true
+            end
+            opts.on("--point-in-time TIME", "Restore to point in time") do |time|
+              options[:point_in_time] = time
+            end
+            opts.on("--dry-run", "Show what would be restored") do
+              options[:dry_run] = true
+            end
+            opts.on("-f", "--force", "Force restore") do
+              options[:force] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--dir DIR", "Backup directory") { |path| options[:backup_dir] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          # Get real config
+          config = RubyDB::Configuration::Config.instance
+          db_path = options[:database] || config.get("storage.data_dir") || "data/rubydb.rdb"
+          backup_dir = options[:backup_dir] || config.get("backup.backup_dir") || "backups"
+
+          selected_path = if options[:backup]
+            File.join(backup_dir, options[:backup])
+          elsif options[:latest]
+            nil
+          end
+
+          if options[:dry_run]
+            available = RubyDB::Backup::Restore.new(nil, backup_dir: backup_dir).list_available_backups
+            selected = if selected_path
+              available.find { |backup| backup[:path] == selected_path }
+            else
+              available.first
+            end
+            raise "No matching backup available" unless selected
+            @output.info("Would restore #{selected[:name]} from #{selected[:path]}")
+            return 0
+          end
+
+          unless options[:force]
+            @output.warn("This will overwrite the current database")
+            @output.print("Are you sure? (yes/no): ", nil, false)
+            response = $stdin.gets.chomp
+            return 1 unless response.downcase == "yes"
+          end
+
+          # Create restore instance
+          engine = RubyDB::Storage::Engine.new(db_path, {})
+          restore = RubyDB::Backup::Restore.new(engine, backup_dir: backup_dir)
+
+          if options[:latest]
+            @output.spinner("Restoring latest backup...") do
+              result = restore.restore_latest
+
+              if result[:success]
+                @output.success("Backup restored successfully")
+              else
+                @output.error("Restore failed: #{result[:error]}")
+                return 1
+              end
+            end
+          elsif options[:backup]
+            backup_path = File.join(backup_dir, options[:backup])
+            @output.spinner("Restoring backup #{options[:backup]}...") do
+              result = restore.restore(backup_path)
+
+              if result[:success]
+                @output.success("Backup restored successfully")
+              else
+                @output.error("Restore failed: #{result[:error]}")
+                return 1
+              end
+            end
+          elsif options[:point_in_time]
+            @output.spinner("Restoring to point in time #{options[:point_in_time]}...") do
+              result = restore.restore_point_in_time(options[:point_in_time])
+
+              if result[:success]
+                @output.success("Database restored to #{options[:point_in_time]}")
+              else
+                @output.error("Restore failed: #{result[:error]}")
+                return 1
+              end
+            end
+          else
+            @output.error("Please specify --backup, --latest, or --point-in-time")
+            @output.puts parser
+            return 1
+          end
+
+          0
+        ensure
+          engine&.close if engine&.open?
+        end
+      end
+    end
+  end
+end