revisable 0.1.0

data/lib/revisable/repository.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Revisable
+  class Repository
+    attr_reader :versionable, :versionable_fields
+
+    def initialize(versionable:, fields:)
+      @versionable = versionable
+      @versionable_fields = fields.map(&:to_sym)
+    end
+
+    # --- Commits ---
+
+    def commit!(branch: "main", author: nil, message:, fields:, parent_shas: nil)
+      timestamp = Time.current
+
+      # Resolve parent(s)
+      if parent_shas.nil?
+        ref = find_ref(branch, type: "branch") if branch
+        parent_commit = ref&.commit
+        parent_shas = parent_commit ? [parent_commit.sha] : []
+      end
+
+      # Build full field set: start from parent, overlay changes
+      parent_field_set = parent_shas.any? ? Commit.find_by!(sha: parent_shas.first).field_set : FieldSet.empty
+      blob_shas = {}
+
+      versionable_fields.each do |field|
+        if fields.key?(field)
+          blob = Blob.store(fields[field])
+          blob_shas[field] = blob.sha
+        elsif parent_field_set[field]
+          blob_shas[field] = parent_field_set.sha_for(field)
+        else
+          blob = Blob.store("")
+          blob_shas[field] = blob.sha
+        end
+      end
+
+      # Compute commit SHA
+      sha = Commit.build_sha(
+        parent_shas: parent_shas,
+        field_blobs: blob_shas,
+        message: message,
+        timestamp: timestamp
+      )
+
+      # Create commit
+      commit = Commit.create!(
+        sha: sha,
+        versionable: versionable,
+        author: author,
+        message: message,
+        committed_at: timestamp
+      )
+
+      # Link parents
+      parent_shas.each_with_index do |parent_sha, i|
+        CommitParent.create!(commit_sha: sha, parent_sha: parent_sha, position: i)
+      end
+
+      # Create commit fields
+      blob_shas.each do |field, blob_sha|
+        CommitField.create!(commit_sha: sha, field_name: field.to_s, blob_sha: blob_sha)
+      end
+
+      # Advance branch ref
+      if branch
+        ref = find_ref(branch, type: "branch")
+        if ref
+          ref.advance!(sha)
+        else
+          Ref.create!(
+            versionable: versionable,
+            name: branch,
+            ref_type: "branch",
+            commit_sha: sha
+          )
+        end
+      end
+
+      commit
+    end
+
+    # --- Branches ---
+
+    def branch!(name, from: "main")
+      source_ref = find_ref!(from)
+      ref = Ref.create!(
+        versionable: versionable,
+        name: name,
+        ref_type: "branch",
+        commit_sha: source_ref.commit_sha
+      )
+      Branch.new(ref)
+    end
+
+    def branches
+      refs_scope.branches.map { |ref| Branch.new(ref) }
+    end
+
+    # --- Tags ---
+
+    def tag!(name, ref: "main", message: nil)
+      source = find_ref!(ref)
+      ref = Ref.create!(
+        versionable: versionable,
+        name: name,
+        ref_type: "tag",
+        commit_sha: source.commit_sha,
+        message: message
+      )
+      Tag.new(ref)
+    end
+
+    def tags
+      refs_scope.tags.map { |ref| Tag.new(ref) }
+    end
+
+    # --- Reading ---
+
+    def at(ref_or_sha)
+      commit = resolve_commit(ref_or_sha)
+      Snapshot.new(commit: commit, fields: versionable_fields)
+    end
+
+    def log(ref = "main", limit: nil)
+      commit = resolve_commit(ref)
+      commits = walk_history(commit, limit: limit)
+      Log.new(commits)
+    end
+
+    # --- Diffing ---
+
+    def diff(ref_a, ref_b)
+      commit_a = resolve_commit(ref_a)
+      commit_b = resolve_commit(ref_b)
+
+      Diff.new(
+        commit_a: commit_a,
+        commit_b: commit_b,
+        versionable_fields: versionable_fields
+      )
+    end
+
+    # --- Merging ---
+
+    def merge(from_ref, into: "main")
+      into_commit = resolve_commit(into)
+      from_commit = resolve_commit(from_ref)
+      ancestor_commit = find_common_ancestor(into_commit, from_commit)
+
+      Merge.new(
+        into_commit: into_commit,
+        from_commit: from_commit,
+        ancestor_commit: ancestor_commit,
+        into: into,
+        from: from_ref,
+        versionable_fields: versionable_fields
+      )
+    end
+
+    # --- Publishing ---
+
+    def publish!(ref = nil)
+      ref ||= refs_scope.tags.order(created_at: :desc).first&.name
+      raise RefNotFoundError, "No tags found" unless ref
+
+      snapshot = at(ref)
+      attrs = snapshot.to_h
+      versionable.update!(attrs)
+    end
+
+    private
+
+    def refs_scope
+      Ref.where(versionable_type: versionable.class.name, versionable_id: versionable.id)
+    end
+
+    def commits_scope
+      Commit.where(versionable_type: versionable.class.name, versionable_id: versionable.id)
+    end
+
+    def find_ref(name, type: nil)
+      scope = refs_scope.where(name: name)
+      scope = scope.where(ref_type: type) if type
+      scope.first
+    end
+
+    def find_ref!(name, type: nil)
+      find_ref(name, type: type) || raise(RefNotFoundError, "Ref '#{name}' not found")
+    end
+
+    def resolve_commit(ref_or_sha)
+      # Try as ref first (branch or tag)
+      ref = find_ref(ref_or_sha)
+      return ref.commit if ref
+
+      # Try as SHA
+      commit = commits_scope.find_by(sha: ref_or_sha)
+      return commit if commit
+
+      # Try as SHA prefix
+      commit = commits_scope.where("sha LIKE ?", "#{ref_or_sha}%").first
+      return commit if commit
+
+      raise RefNotFoundError, "Could not resolve '#{ref_or_sha}'"
+    end
+
+    def walk_history(commit, limit: nil)
+      result = []
+      queue = [commit]
+      visited = Set.new
+
+      while queue.any? && (limit.nil? || result.size < limit)
+        current = queue.shift
+        next if visited.include?(current.sha)
+        visited.add(current.sha)
+
+        result << current
+
+        current.parents.order(committed_at: :desc).each do |parent|
+          queue << parent unless visited.include?(parent.sha)
+        end
+      end
+
+      result
+    end
+
+    def find_common_ancestor(commit_a, commit_b)
+      ancestors_a = collect_ancestors(commit_a)
+      ancestors_b = collect_ancestors(commit_b)
+      common = ancestors_a & ancestors_b
+      return nil if common.empty?
+
+      # Return the most recent common ancestor
+      commits_scope.where(sha: common.to_a).order(committed_at: :desc).first
+    end
+
+    def collect_ancestors(commit)
+      ancestors = Set.new
+      queue = [commit]
+
+      while queue.any?
+        current = queue.shift
+        next if ancestors.include?(current.sha)
+        ancestors.add(current.sha)
+        current.parents.each { |p| queue << p }
+      end
+
+      ancestors
+    end
+  end
+end

data/lib/revisable/snapshot.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Revisable
+  class Snapshot
+    attr_reader :commit, :fields
+
+    def initialize(commit:, fields:)
+      @commit = commit
+      @fields = fields
+      @field_set = commit.field_set
+    end
+
+    def [](field_name)
+      @field_set.data_for(field_name)
+    end
+
+    def to_h
+      fields.each_with_object({}) do |field, hash|
+        hash[field.to_sym] = self[field]
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      fields.map(&:to_sym).include?(method.to_sym) || super
+    end
+
+    def method_missing(method, *args)
+      if fields.map(&:to_sym).include?(method.to_sym)
+        self[method]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/revisable/tag.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Revisable
+  class Tag
+    attr_reader :ref
+
+    def initialize(ref)
+      @ref = ref
+    end
+
+    def name
+      ref.name
+    end
+
+    def message
+      ref.message
+    end
+
+    def commit
+      ref.commit
+    end
+
+    def commit_sha
+      ref.commit_sha
+    end
+
+    def snapshot(fields:)
+      Snapshot.new(commit: commit, fields: fields)
+    end
+
+    def to_s
+      name
+    end
+
+    def ==(other)
+      other.is_a?(Tag) && name == other.name && commit_sha == other.commit_sha
+    end
+  end
+end

data/lib/revisable/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Revisable
+  VERSION = "0.1.0"
+end

data/lib/revisable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "active_support"
+require "diff/lcs"
+
+require_relative "revisable/version"
+
+# Core (no AR dependency in these objects)
+require_relative "revisable/field_set"
+require_relative "revisable/snapshot"
+require_relative "revisable/renderers/text_renderer"
+require_relative "revisable/renderers/html_renderer"
+require_relative "revisable/field_diff"
+require_relative "revisable/diff"
+require_relative "revisable/log"
+require_relative "revisable/merge_field"
+require_relative "revisable/merge"
+require_relative "revisable/current_author"
+
+# ActiveRecord models
+require_relative "revisable/blob"
+require_relative "revisable/commit"
+require_relative "revisable/commit_field"
+require_relative "revisable/ref"
+require_relative "revisable/branch"
+require_relative "revisable/tag"
+
+# ActiveRecord integration
+require_relative "revisable/repository"
+require_relative "revisable/model"
+require_relative "revisable/active_record/controller_helpers"
+
+module Revisable
+  class Error < StandardError; end
+  class ConflictError < Error; end
+  class RefNotFoundError < Error; end
+  class UnresolvedConflictsError < Error; end
+  class StaleRefError < Error; end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: revisable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brad Gessler
+bindir: bin
+cert_chain: []
+date: 2026-03-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: diff-lcs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: Content-addressed versioning with branches, merges, diffs, and tags for
+  ActiveRecord models. Like git, but in your database.
+email:
+- bradgessler@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/generators/revisable/install_generator.rb
+- lib/generators/revisable/templates/create_revisable_tables.rb.erb
+- lib/revisable.rb
+- lib/revisable/active_record/controller_helpers.rb
+- lib/revisable/blob.rb
+- lib/revisable/branch.rb
+- lib/revisable/commit.rb
+- lib/revisable/commit_field.rb
+- lib/revisable/current_author.rb
+- lib/revisable/diff.rb
+- lib/revisable/field_diff.rb
+- lib/revisable/field_set.rb
+- lib/revisable/log.rb
+- lib/revisable/merge.rb
+- lib/revisable/merge_field.rb
+- lib/revisable/model.rb
+- lib/revisable/ref.rb
+- lib/revisable/renderers/html_renderer.rb
+- lib/revisable/renderers/text_renderer.rb
+- lib/revisable/repository.rb
+- lib/revisable/snapshot.rb
+- lib/revisable/tag.rb
+- lib/revisable/version.rb
+homepage: https://github.com/rubymonolith/revisable
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rubymonolith/revisable
+  source_code_uri: https://github.com/rubymonolith/revisable
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Git-like versioning for ActiveRecord text content
+test_files: []