rubydb 0.1.0

data/lib/rubydb/branching/checkout.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Branching
+    # Checkout - Handles branch checkout operations
+    class Checkout
+      attr_reader :stats
+
+      def initialize(engine, branch_manager, config = {})
+        @engine = engine
+        @branch_manager = branch_manager
+        @config = config
+        @checkout_history = []
+        @stats = {
+          checkouts: 0,
+          successful_checkouts: 0,
+          failed_checkouts: 0,
+          checkout_time_ms: 0,
+          avg_checkout_time_ms: 0,
+          last_checkout: nil
+        }
+        @lock = Mutex.new
+        @max_history = config[:max_history] || 100
+      end
+
+      def checkout(branch_name, options = {})
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:checkouts] += 1
+
+          # Validate branch exists
+          branch = @branch_manager.get_branch(branch_name)
+          unless branch
+            @stats[:failed_checkouts] += 1
+            return { success: false, error: "Branch '#{branch_name}' not found" }
+          end
+
+          # Check if branch can be checked out
+          if branch.locked? && !options[:force]
+            @stats[:failed_checkouts] += 1
+            return { success: false, error: "Branch '#{branch_name}' is locked" }
+          end
+
+          begin
+            # Perform checkout
+            result = perform_checkout(branch, options)
+
+            if result[:success]
+              # Update branch manager
+              @branch_manager.checkout(branch_name)
+
+              # Record history
+              record_checkout(branch_name, options)
+
+              @stats[:successful_checkouts] += 1
+              @stats[:last_checkout] = Time.now
+
+              elapsed_ms = (Time.now - start_time) * 1000
+              @stats[:checkout_time_ms] += elapsed_ms
+              @stats[:avg_checkout_time_ms] = @stats[:checkout_time_ms] / @stats[:successful_checkouts]
+            else
+              @stats[:failed_checkouts] += 1
+            end
+
+            result.merge(elapsed_ms: elapsed_ms)
+
+          rescue => e
+            @stats[:failed_checkouts] += 1
+            { success: false, error: e.message }
+          end
+        end
+      end
+
+      def checkout_or_create(branch_name, options = {})
+        @lock.synchronize do
+          branch = @branch_manager.get_branch(branch_name)
+
+          if branch
+            checkout(branch_name, options)
+          else
+            # Create branch then checkout
+            result = @branch_manager.create_branch(branch_name, options)
+            if result[:success]
+              checkout(branch_name, options)
+            else
+              result
+            end
+          end
+        end
+      end
+
+      def checkout_latest(options = {})
+        @lock.synchronize do
+          # Find latest branch by creation time
+          branches = @branch_manager.list_branches
+          return { success: false, error: "No branches available" } if branches.empty?
+
+          latest = branches.max_by { |b| b[:created_at] }
+          checkout(latest[:name], options)
+        end
+      end
+
+      def checkout_history
+        @checkout_history.dup
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            history_size: @checkout_history.size,
+            max_history: @max_history
+          })
+        end
+      end
+
+      private
+
+      def perform_checkout(branch, options)
+        branch_name = branch.name
+
+        # Get branch data
+        branch_data = get_branch_data(branch_name)
+
+        # Apply branch state to engine
+        apply_branch_state(branch_data)
+
+        # Update engine to branch head
+        @engine.apply_branch_head(branch.head_lsn) if branch.head_lsn
+
+        { success: true, branch_name: branch_name, head_lsn: branch.head_lsn }
+      end
+
+      def get_branch_data(branch_name)
+        branch = @branch_manager.get_branch(branch_name)
+        raise ArgumentError, "Branch '#{branch_name}' not found" unless branch
+        snapshot = branch.respond_to?(:state_snapshot) ? branch.state_snapshot : nil
+        changes = branch.respond_to?(:logical_changes) ? branch.logical_changes : branch.changes
+        { base: snapshot, changes: changes }
+      end
+
+      def apply_branch_state(branch_data)
+        unless @engine.respond_to?(:apply_branch_state)
+          raise ArgumentError, "Branch checkout requires an engine state-application hook"
+        end
+
+        result = @engine.apply_branch_state(branch_data)
+        raise ArgumentError, "Engine rejected branch state" if result == false
+        result
+      end
+
+      def record_checkout(branch_name, options)
+        entry = {
+          branch_name: branch_name,
+          timestamp: Time.now.iso8601,
+          options: options
+        }
+
+        @checkout_history << entry
+
+        if @checkout_history.size > @max_history
+          @checkout_history.shift
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/branching/copy_on_write.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "pathname"
+
+module RubyDB
+  module Branching
+    # CopyOnWrite - Manages copy-on-write for branches
+    class CopyOnWrite
+      attr_reader :stats
+
+      def initialize(engine, config = {})
+        @engine = engine
+        @config = config
+        @cow_dir = config[:cow_dir] || "cow"
+        @branch_data = {}
+        @stats = {
+          cow_files_created: 0,
+          cow_files_accessed: 0,
+          cow_files_updated: 0,
+          cow_files_deleted: 0,
+          total_cow_size: 0
+        }
+        @lock = Mutex.new
+
+        FileUtils.mkdir_p(@cow_dir)
+        load_cow_data
+      end
+
+      def create_cow(branch_name, base_path)
+        @lock.synchronize do
+          cow_path = branch_path(branch_name)
+          return { success: false, error: "Invalid branch name" } unless cow_path
+          base_root = File.expand_path(base_path)
+          return { success: false, error: "Base path does not exist" } unless Dir.exist?(base_root)
+          FileUtils.mkdir_p(cow_path)
+
+          # Create COW for each file
+          files = Dir.glob(File.join(base_root, "**/*")).select { |file| File.file?(file) }
+          files.each do |file|
+            relative_path = Pathname.new(file).relative_path_from(Pathname.new(base_root)).to_s
+            cow_file = nested_path(cow_path, relative_path)
+            raise "Invalid source path for copy-on-write" unless cow_file
+            FileUtils.mkdir_p(File.dirname(cow_file))
+
+            # Create hard link or copy
+            begin
+              File.link(file, cow_file)
+            rescue
+              FileUtils.cp(file, cow_file)
+            end
+
+            @stats[:cow_files_created] += 1
+            @stats[:total_cow_size] += File.size(cow_file)
+          end
+
+          @branch_data[branch_name] = {
+            base_path: base_root,
+            cow_path: cow_path,
+            created_at: Time.now.iso8601,
+            files: files.map { |file| Pathname.new(file).relative_path_from(Pathname.new(base_root)).to_s }
+          }
+
+          save_cow_data
+
+          { success: true, cow_path: cow_path, file_count: files.size }
+        end
+      end
+
+      def read_file(branch_name, file_path)
+        @lock.synchronize do
+          cow_path = branch_path(branch_name)
+          cow_file = cow_path && nested_path(cow_path, file_path)
+          return nil unless cow_file
+
+          if File.exist?(cow_file)
+            @stats[:cow_files_accessed] += 1
+            return File.read(cow_file)
+          end
+
+          # Read from base
+          branch_data = @branch_data[branch_name]
+          return nil unless branch_data
+
+          base_file = nested_path(branch_data[:base_path], file_path)
+          return nil unless File.exist?(base_file)
+
+          File.read(base_file)
+        end
+      end
+
+      def write_file(branch_name, file_path, content)
+        @lock.synchronize do
+          cow_path = branch_path(branch_name)
+          cow_file = cow_path && nested_path(cow_path, file_path)
+          return { success: false, error: "Invalid branch name or file path" } unless cow_file
+          FileUtils.mkdir_p(File.dirname(cow_file))
+
+          File.write(cow_file, content)
+          @stats[:cow_files_updated] += 1
+
+          # Update branch data
+          @branch_data[branch_name] ||= { files: [] }
+          unless @branch_data[branch_name][:files].include?(file_path)
+            @branch_data[branch_name][:files] << file_path
+          end
+
+          save_cow_data
+
+          { success: true, path: cow_file }
+        end
+      end
+
+      def delete_file(branch_name, file_path)
+        @lock.synchronize do
+          cow_path = branch_path(branch_name)
+          cow_file = cow_path && nested_path(cow_path, file_path)
+          return { success: false, error: "Invalid branch name or file path" } unless cow_file
+
+          if File.exist?(cow_file)
+            File.delete(cow_file)
+            @stats[:cow_files_deleted] += 1
+
+            # Update branch data
+            if @branch_data[branch_name]
+              @branch_data[branch_name][:files].delete(file_path)
+            end
+
+            save_cow_data
+            return { success: true }
+          end
+
+          { success: false, error: "File not found in COW" }
+        end
+      end
+
+      def list_cow_files(branch_name)
+        @lock.synchronize do
+          cow_path = branch_path(branch_name)
+          return [] unless cow_path
+          return [] unless Dir.exist?(cow_path)
+
+          Dir.glob(File.join(cow_path, "**/*")).select do |f|
+            File.file?(f)
+          end.map { |f| f.sub(cow_path + "/", "") }
+        end
+      end
+
+      def delete_branch_cow(branch_name)
+        @lock.synchronize do
+          cow_path = branch_path(branch_name)
+          return { success: false, error: "Invalid branch name" } unless cow_path
+          if Dir.exist?(cow_path)
+            size = calculate_dir_size(cow_path)
+            FileUtils.rm_rf(cow_path)
+            @stats[:total_cow_size] -= size
+            @stats[:cow_files_deleted] += 1
+          end
+
+          @branch_data.delete(branch_name)
+          save_cow_data
+
+          { success: true }
+        end
+      end
+
+      def snapshot(branch_name, snapshot_name)
+        @lock.synchronize do
+          cow_path = branch_path(branch_name)
+          return { success: false, error: "Invalid branch name" } unless cow_path
+          return { success: false, error: "Branch COW not found" } unless Dir.exist?(cow_path)
+
+          snapshot_path = snapshot_path(snapshot_name)
+          return { success: false, error: "Invalid snapshot name" } unless snapshot_path
+          FileUtils.mkdir_p(File.dirname(snapshot_path))
+
+          # Copy all COW files
+          FileUtils.cp_r(cow_path, snapshot_path)
+
+          { success: true, snapshot_path: snapshot_path }
+        end
+      end
+
+      def restore_snapshot(snapshot_name, branch_name)
+        @lock.synchronize do
+          snapshot_path = snapshot_path(snapshot_name)
+          return { success: false, error: "Invalid snapshot name" } unless snapshot_path
+          return { success: false, error: "Snapshot not found" } unless Dir.exist?(snapshot_path)
+
+          cow_path = branch_path(branch_name)
+          return { success: false, error: "Invalid branch name" } unless cow_path
+          FileUtils.rm_rf(cow_path) if Dir.exist?(cow_path)
+          FileUtils.cp_r(snapshot_path, cow_path)
+
+          { success: true }
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            branches: @branch_data.size,
+            cow_dir: @cow_dir,
+            snapshots: Dir.glob(File.join(@cow_dir, "snapshots", "*")).size
+          })
+        end
+      end
+
+      private
+
+      def branch_path(branch_name)
+        name = branch_name.to_s
+        return nil unless safe_name?(name)
+
+        nested_path(@cow_dir, name)
+      end
+
+      def snapshot_path(snapshot_name)
+        name = snapshot_name.to_s
+        return nil unless safe_name?(name)
+
+        nested_path(File.join(@cow_dir, "snapshots"), name)
+      end
+
+      def safe_name?(name)
+        !name.empty? && name == File.basename(name) && !Pathname.new(name).absolute?
+      end
+
+      def nested_path(root_path, relative_path)
+        relative = relative_path.to_s
+        return nil if relative.empty? || Pathname.new(relative).absolute?
+
+        root = File.expand_path(root_path)
+        path = File.expand_path(File.join(root, relative))
+        path.start_with?("#{root}#{File::SEPARATOR}") ? path : nil
+      end
+
+      def load_cow_data
+        data_file = File.join(@cow_dir, "cow_data.json")
+        return unless File.exist?(data_file)
+
+        begin
+          data = JSON.parse(File.read(data_file), symbolize_names: true)
+          @branch_data = data[:branch_data] || {}
+          @stats = data[:stats] || @stats
+        rescue
+          @branch_data = {}
+        end
+      end
+
+      def save_cow_data
+        data = {
+          branch_data: @branch_data,
+          stats: @stats,
+          updated_at: Time.now.iso8601
+        }
+
+        data_file = File.join(@cow_dir, "cow_data.json")
+        temp_file = "#{data_file}.tmp"
+        File.write(temp_file, JSON.generate(data))
+        File.rename(temp_file, data_file)
+      end
+
+      def calculate_dir_size(path)
+        Dir.glob(File.join(path, "**/*")).sum do |f|
+          File.size(f) if File.file?(f)
+        end || 0
+      end
+    end
+  end
+end

data/lib/rubydb/branching/diff.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Branching
+    # Diff - Compares branches
+    class Diff
+      attr_reader :stats
+
+      # Diff types
+      DIFF_TABLE = :table
+      DIFF_SCHEMA = :schema
+      DIFF_DATA = :data
+      DIFF_ALL = :all
+
+      def initialize(engine, branch_manager, config = {})
+        @engine = engine
+        @branch_manager = branch_manager
+        @config = config
+        @stats = {
+          diffs: 0,
+          diff_time_ms: 0,
+          avg_diff_time_ms: 0,
+          tables_diffed: 0,
+          rows_diffed: 0
+        }
+        @lock = Mutex.new
+        @diff_cache = {}
+      end
+
+      def diff(branch_a, branch_b, options = {})
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:diffs] += 1
+
+          a = @branch_manager.get_branch(branch_a)
+          b = @branch_manager.get_branch(branch_b)
+
+          unless a
+            return { success: false, error: "Branch '#{branch_a}' not found" }
+          end
+
+          unless b
+            return { success: false, error: "Branch '#{branch_b}' not found" }
+          end
+
+          diff_type = options[:type] || DIFF_ALL
+          tables = options[:tables]
+
+          result = case diff_type
+          when DIFF_TABLE
+            diff_tables(a, b, tables)
+          when DIFF_SCHEMA
+            diff_schemas(a, b, tables)
+          when DIFF_DATA
+            diff_data(a, b, tables)
+          else
+            diff_all(a, b, tables)
+          end
+
+          elapsed_ms = (Time.now - start_time) * 1000
+          @stats[:diff_time_ms] += elapsed_ms
+          @stats[:avg_diff_time_ms] = @stats[:diff_time_ms] / @stats[:diffs]
+          @stats[:tables_diffed] += result[:tables]&.size || 0
+          @stats[:rows_diffed] += result[:rows]&.size || 0
+
+          result.merge(elapsed_ms: elapsed_ms)
+        end
+      end
+
+      def diff_tables(branch_a, branch_b, tables = nil)
+        compare_changes(branch_a, branch_b, tables, :tables)
+      end
+
+      def diff_schemas(branch_a, branch_b, tables = nil)
+        compare_changes(branch_a, branch_b, tables, :schemas)
+      end
+
+      def diff_data(branch_a, branch_b, tables = nil)
+        compare_changes(branch_a, branch_b, tables, :data)
+      end
+
+      def diff_all(branch_a, branch_b, tables = nil)
+        compare_changes(branch_a, branch_b, tables, :all)
+      end
+
+      def diff_table(branch_a, branch_b, table)
+        @lock.synchronize do
+          cache_key = "#{branch_a}_#{branch_b}_#{table}"
+          if @diff_cache.key?(cache_key)
+            return @diff_cache[cache_key]
+          end
+
+          result = perform_table_diff(branch_a, branch_b, table)
+          @diff_cache[cache_key] = result if result[:success]
+
+          result
+        end
+      end
+
+      def clear_cache
+        @lock.synchronize do
+          @diff_cache.clear
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            cache_size: @diff_cache.size
+          })
+        end
+      end
+
+      private
+
+      def perform_table_diff(branch_a, branch_b, table)
+        compare_changes(branch_a, branch_b, [table], :table).merge(table: table)
+      end
+
+      def compare_changes(branch_a, branch_b, tables, type)
+        a = branch_a.respond_to?(:logical_changes) ? branch_a : @branch_manager.get_branch(branch_a)
+        b = branch_b.respond_to?(:logical_changes) ? branch_b : @branch_manager.get_branch(branch_b)
+        return { success: false, error: "Branch not found: #{branch_a.inspect}, #{branch_b.inspect}" } unless a && b
+
+        filter = tables && Array(tables).map(&:to_s)
+        changes_a = a.respond_to?(:logical_changes) ? a.logical_changes : a.changes
+        changes_b = b.respond_to?(:logical_changes) ? b.logical_changes : b.changes
+        changes_a = changes_a.select { |change| filter.include?(change[:table].to_s) } if filter
+        changes_b = changes_b.select { |change| filter.include?(change[:table].to_s) } if filter
+        added = changes_b.reject { |change| changes_a.include?(change) }
+        removed = changes_a.reject { |change| changes_b.include?(change) }
+        { success: true, type: type, tables: (changes_a + changes_b).map { |c| c[:table] }.compact.uniq,
+          rows: { added: added, removed: removed }, changes: { added: added, removed: removed } }
+      end
+
+    end
+  end
+end