rubydb 0.1.4 → 0.1.6

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

@@ -1,81 +1,80 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module CLI
-    module Commands
-      class Backup
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb backup [options]"
-            opts.on("-t", "--type TYPE", "Backup type (full, incremental, differential)") do |type|
-              options[:type] = type.to_sym
-            end
-            opts.on("-d", "--dir DIR", "Backup directory") do |dir|
-              options[:dir] = dir
-            end
-            opts.on("--compress", "Compress backup") do
-              options[:compress] = true
-            end
-            opts.on("--no-verify", "Skip verification") do
-              options[:no_verify] = 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)
-
-          # Get real config
-          config = RubyDB::Configuration::Config.instance
-          db_path = options[:database] || config.get("storage.data_dir") || "data/rubydb.rdb"
-          backup_dir = options[:dir] || config.get("backup.backup_dir") || "backups"
-
-          # Create backup instance
-          engine = RubyDB::Storage::Engine.new(db_path, {})
-          backup = RubyDB::Backup::Backup.new(engine,
-            backup_dir: backup_dir,
-            compress: options[:compress] != false,
-            verify_after_backup: !options[:no_verify]
-          )
-
-          @output.spinner("Creating #{options[:type] || 'full'} backup...") do
-            result = backup.create_backup(type: options[:type] || :full)
-
-            if result[:success]
-              @output.success("Backup created successfully")
-              @output.puts("  Name: #{result[:backup_name]}")
-              @output.puts("  Size: #{format_size(result[:size])}")
-              @output.puts("  Path: #{result[:backup_path]}")
-              @output.puts("  Time: #{result[:elapsed_ms].round(2)}ms")
-            else
-              @output.error("Backup failed: #{result[:error]}")
-              return 1
-            end
-          end
-
-          0
-        ensure
-          engine&.close if engine&.open?
-        end
-
-        private
-
-        def format_size(bytes)
-          return "0 B" if bytes.to_i == 0
-          units = ["B", "KB", "MB", "GB", "TB"]
-          exp = (Math.log(bytes) / Math.log(1024)).floor
-          size = bytes / (1024.0 ** exp)
-          "#{size.round(2)} #{units[exp]}"
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      class Backup
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb backup [options]"
+            opts.on("-t", "--type TYPE", "Backup type (full, incremental, differential)") do |type|
+              options[:type] = type.to_sym
+            end
+            opts.on("-d", "--dir DIR", "Backup directory") do |dir|
+              options[:dir] = dir
+            end
+            opts.on("--compress", "Compress backup") do
+              options[:compress] = true
+            end
+            opts.on("--no-verify", "Skip verification") do
+              options[:no_verify] = 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)
+
+          # Get real config
+          config = RubyDB::Configuration::Config.instance
+          db_path = options[:database] || config.get("storage.data_dir") || "data/rubydb.rdb"
+          backup_dir = options[:dir] || config.get("backup.backup_dir") || "backups"
+
+          # Create backup instance
+          engine = RubyDB::Storage::Engine.new(db_path, {})
+          backup = RubyDB::Backup::Backup.new(engine,
+            backup_dir: backup_dir,
+            compress: options[:compress] != false,
+            verify_after_backup: !options[:no_verify])
+
+          @output.spinner("Creating #{options[:type] || "full"} backup...") do
+            result = backup.create_backup(type: options[:type] || :full)
+
+            if result[:success]
+              @output.success("Backup created successfully")
+              @output.puts("  Name: #{result[:backup_name]}")
+              @output.puts("  Size: #{format_size(result[:size])}")
+              @output.puts("  Path: #{result[:backup_path]}")
+              @output.puts("  Time: #{result[:elapsed_ms].round(2)}ms")
+            else
+              @output.error("Backup failed: #{result[:error]}")
+              return 1
+            end
+          end
+
+          0
+        ensure
+          engine&.close if engine&.open?
+        end
+
+        private
+
+        def format_size(bytes)
+          return "0 B" if bytes.to_i == 0
+          units = ["B", "KB", "MB", "GB", "TB"]
+          exp = (Math.log(bytes) / Math.log(1024)).floor
+          size = bytes / (1024.0**exp)
+          "#{size.round(2)} #{units[exp]}"
+        end
+      end
+    end
+  end
+end

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

@@ -1,72 +1,72 @@
-# frozen_string_literal: true
-
-require "optparse"
-
-module RubyDB
-  module CLI
-    module Commands
-      # Branch - Manage database branches
-      class Branch
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb branch [options]"
-            opts.on("-l", "--list", "List branches") do
-              options[:list] = true
-            end
-            opts.on("-c", "--create NAME", "Create branch") do |name|
-              options[:create] = name
-            end
-            opts.on("-d", "--delete NAME", "Delete branch") do |name|
-              options[:delete] = name
-            end
-            opts.on("--from BRANCH", "Create from branch") do |branch|
-              options[:from] = branch
-            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)
-
-          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"
-          )
-
-          if options[:list] || (args.empty? && !options[:create] && !options[:delete])
-            @formatter.format_branches(manager.list_branches)
-            return 0
-          end
-
-          if options[:create]
-            from = options[:from] || "main"
-            result = manager.create_branch(options[:create], from: from)
-            raise result[:error] unless result[:success]
-            @output.success("Branch #{options[:create]} created")
-            return 0
-          end
-
-          if options[:delete]
-            result = manager.delete_branch(options[:delete])
-            raise result[:error] unless result[:success]
-            @output.success("Branch #{options[:delete]} deleted")
-            return 0
-          end
-          raise "Specify --list, --create, or --delete"
-        ensure
-          database&.close
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyDB
+  module CLI
+    module Commands
+      # Branch - Manage database branches
+      class Branch
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb branch [options]"
+            opts.on("-l", "--list", "List branches") do
+              options[:list] = true
+            end
+            opts.on("-c", "--create NAME", "Create branch") do |name|
+              options[:create] = name
+            end
+            opts.on("-d", "--delete NAME", "Delete branch") do |name|
+              options[:delete] = name
+            end
+            opts.on("--from BRANCH", "Create from branch") do |branch|
+              options[:from] = branch
+            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)
+
+          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"
+          )
+
+          if options[:list] || (args.empty? && !options[:create] && !options[:delete])
+            @formatter.format_branches(manager.list_branches)
+            return 0
+          end
+
+          if options[:create]
+            from = options[:from] || "main"
+            result = manager.create_branch(options[:create], from: from)
+            raise result[:error] unless result[:success]
+            @output.success("Branch #{options[:create]} created")
+            return 0
+          end
+
+          if options[:delete]
+            result = manager.delete_branch(options[:delete])
+            raise result[:error] unless result[:success]
+            @output.success("Branch #{options[:delete]} deleted")
+            return 0
+          end
+          raise "Specify --list, --create, or --delete"
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

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

@@ -1,54 +1,54 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module CLI
-    module Commands
-      # Checkout - Switch to a branch
-      class Checkout
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb checkout [options]"
-            opts.on("-b", "--create NAME", "Create and checkout branch") do |name|
-              options[:create] = name
-            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)
-
-          branch = args.first
-          if branch.nil? && options[:create].nil?
-            @output.error("Branch name required")
-            @output.puts parser
-            return
-          end
-
-          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"
-          )
-          selected = options[:create] || branch
-          result = manager.create_branch(selected, from: manager.current_branch_name) if options[:create]
-          raise result[:error] if result && !result[:success]
-          result = manager.checkout(selected)
-          raise result[:error] unless result[:success]
-          @output.success("Switched to branch #{selected}")
-          0
-        ensure
-          database&.close
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Checkout - Switch to a branch
+      class Checkout
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb checkout [options]"
+            opts.on("-b", "--create NAME", "Create and checkout branch") do |name|
+              options[:create] = name
+            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)
+
+          branch = args.first
+          if branch.nil? && options[:create].nil?
+            @output.error("Branch name required")
+            @output.puts parser
+            return
+          end
+
+          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"
+          )
+          selected = options[:create] || branch
+          result = manager.create_branch(selected, from: manager.current_branch_name) if options[:create]
+          raise result[:error] if result && !result[:success]
+          result = manager.checkout(selected)
+          raise result[:error] unless result[:success]
+          @output.success("Switched to branch #{selected}")
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

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

@@ -1,58 +1,58 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module CLI
-    module Commands
-      # Create - Create a database
-      class Create
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb create [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 create") do
-              options[:force] = 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)
-
-          name = options[:name] || "rubydb"
-          dir = options[:dir] || "data"
-          db_path = options[:database] || File.join(dir, "#{name}.rdb")
-          if File.exist?(db_path) && !options[:force]
-            @output.error("Database already exists at #{db_path}. Use --force to recreate it.")
-            return 1
-          end
-
-          @output.spinner("Creating database #{name}...") do
-            FileUtils.mkdir_p(File.dirname(db_path))
-            if options[:force]
-              [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
-            end
-            engine = RubyDB::Storage::Engine.new(db_path, auto_vacuum: false)
-            engine.close
-            @output.success("Database #{name} created at #{db_path}")
-          end
-          0
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Create - Create a database
+      class Create
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb create [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 create") do
+              options[:force] = 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)
+
+          name = options[:name] || "rubydb"
+          dir = options[:dir] || "data"
+          db_path = options[:database] || File.join(dir, "#{name}.rdb")
+          if File.exist?(db_path) && !options[:force]
+            @output.error("Database already exists at #{db_path}. Use --force to recreate it.")
+            return 1
+          end
+
+          @output.spinner("Creating database #{name}...") do
+            FileUtils.mkdir_p(File.dirname(db_path))
+            if options[:force]
+              [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
+            end
+            engine = RubyDB::Storage::Engine.new(db_path, auto_vacuum: false)
+            engine.close
+            @output.success("Database #{name} created at #{db_path}")
+          end
+          0
+        end
+      end
+    end
+  end
+end