rubydb 0.1.4 → 0.1.5

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

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

@@ -1,77 +1,76 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module CLI
-    module Commands
-      # Diff - Show differences between branches
-      class Diff
-        def initialize(output, formatter)
-          @output = output
-          @formatter = formatter
-        end
-
-        def execute(args, options)
-          parser = OptionParser.new do |opts|
-            opts.banner = "Usage: rubydb diff [options]"
-            opts.on("--table TABLE", "Only show differences for a table") do |table|
-              options[:table] = table
-            end
-          opts.on("--summary", "Show summary only") do
-            options[:summary] = 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)
-
-          branch_a = args[0] || "main"
-          branch_b = args[1] || "current"
-
-          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"
-          )
-          branch_b = manager.current_branch_name || "main" if branch_b == "current"
-          result = RubyDB::Branching::Diff.new(database.engine, manager).diff(
-            branch_a, branch_b, type: RubyDB::Branching::Diff::DIFF_ALL,
-            tables: (options[:table] && [options[:table]])
-          )
-          raise result[:error] unless result[:success]
-
-          changes = result[:changes]
-          diff_data = {
-            added_tables: [], removed_tables: [], changed_tables: [],
-            added_columns: [], removed_columns: [], changed_columns: [],
-            changes: changes
-          }
-
-          if options[:summary]
-            @output.puts "Differences between #{branch_a} and #{branch_b}:"
-            @output.puts "  Added tables: #{diff_data[:added_tables].size}"
-            @output.puts "  Removed tables: #{diff_data[:removed_tables].size}"
-            @output.puts "  Changed tables: #{diff_data[:changed_tables].size}"
-            @output.puts "  Added columns: #{diff_data[:added_columns].size}"
-            @output.puts "  Removed columns: #{diff_data[:removed_columns].size}"
-            @output.puts "  Changed columns: #{diff_data[:changed_columns].size}"
-          else
-            @output.puts "Differences between #{branch_a} and #{branch_b}:"
-            @output.puts "  Added changes: #{changes[:added].size}"
-            @output.puts "  Removed changes: #{changes[:removed].size}"
-            changes.each do |kind, entries|
-              entries.each { |entry| @output.puts "  #{kind}: #{entry.inspect}" }
-            end
-          end
-          0
-        ensure
-          database&.close
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Diff - Show differences between branches
+      class Diff
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb diff [options]"
+            opts.on("--table TABLE", "Only show differences for a table") do |table|
+              options[:table] = table
+            end
+            opts.on("--summary", "Show summary only") do
+              options[:summary] = 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)
+
+          branch_a = args[0] || "main"
+          branch_b = args[1] || "current"
+
+          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"
+          )
+          branch_b = manager.current_branch_name || "main" if branch_b == "current"
+          result = RubyDB::Branching::Diff.new(database.engine, manager).diff(
+            branch_a, branch_b, type: RubyDB::Branching::Diff::DIFF_ALL,
+            tables: options[:table] && [options[:table]]
+          )
+          raise result[:error] unless result[:success]
+
+          changes = result[:changes]
+          diff_data = {
+            added_tables: [], removed_tables: [], changed_tables: [],
+            added_columns: [], removed_columns: [], changed_columns: [],
+            changes: changes
+          }
+
+          @output.puts "Differences between #{branch_a} and #{branch_b}:"
+          if options[:summary]
+            @output.puts "  Added tables: #{diff_data[:added_tables].size}"
+            @output.puts "  Removed tables: #{diff_data[:removed_tables].size}"
+            @output.puts "  Changed tables: #{diff_data[:changed_tables].size}"
+            @output.puts "  Added columns: #{diff_data[:added_columns].size}"
+            @output.puts "  Removed columns: #{diff_data[:removed_columns].size}"
+            @output.puts "  Changed columns: #{diff_data[:changed_columns].size}"
+          else
+            @output.puts "  Added changes: #{changes[:added].size}"
+            @output.puts "  Removed changes: #{changes[:removed].size}"
+            changes.each do |kind, entries|
+              entries.each { |entry| @output.puts "  #{kind}: #{entry.inspect}" }
+            end
+          end
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end