revisable 0.1.0

data/lib/revisable/field_diff.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Revisable
+  class FieldDiff
+    attr_reader :field_name, :status, :a, :b
+
+    def initialize(field_name:, blob_a:, blob_b:)
+      @field_name = field_name.to_sym
+      @a = blob_a&.data
+      @b = blob_b&.data
+
+      @status = if blob_a.nil? && blob_b.nil?
+        :unchanged
+      elsif blob_a.nil?
+        :added
+      elsif blob_b.nil?
+        :removed
+      elsif blob_a.sha == blob_b.sha
+        :unchanged
+      else
+        :modified
+      end
+    end
+
+    def changed?
+      status != :unchanged
+    end
+
+    def hunks
+      @hunks ||= changed? ? ::Diff::LCS.sdiff(lines_a, lines_b) : []
+    end
+
+    def to_text
+      Renderers::TextRenderer.new(self).render
+    end
+
+    def to_html
+      Renderers::HtmlRenderer.new(self).render
+    end
+
+    private
+
+    def lines_a
+      @lines_a ||= (@a || "").lines(chomp: true)
+    end
+
+    def lines_b
+      @lines_b ||= (@b || "").lines(chomp: true)
+    end
+  end
+end

data/lib/revisable/field_set.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Revisable
+  class FieldSet
+    include Enumerable
+
+    def initialize(fields = {})
+      @fields = fields.transform_keys(&:to_sym)
+    end
+
+    def [](field_name)
+      @fields[field_name.to_sym]
+    end
+
+    def each(&block)
+      @fields.each(&block)
+    end
+
+    def keys
+      @fields.keys
+    end
+
+    def values
+      @fields.values
+    end
+
+    def sha_for(field_name)
+      self[field_name]&.sha
+    end
+
+    def data_for(field_name)
+      self[field_name]&.data
+    end
+
+    def shas
+      @fields.transform_values(&:sha)
+    end
+
+    def diff(other)
+      keys.each_with_object({}) do |field, result|
+        result[field] = sha_for(field) != other.sha_for(field)
+      end
+    end
+
+    def empty?
+      @fields.empty?
+    end
+
+    def self.empty
+      new({})
+    end
+  end
+end

data/lib/revisable/log.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Revisable
+  class Log
+    include Enumerable
+
+    attr_reader :commits
+
+    def initialize(commits)
+      @commits = commits
+    end
+
+    def each(&block)
+      @commits.each(&block)
+    end
+
+    def size
+      @commits.size
+    end
+    alias_method :length, :size
+
+    def first(n = nil)
+      n ? self.class.new(@commits.first(n)) : @commits.first
+    end
+
+    def last(n = nil)
+      n ? self.class.new(@commits.last(n)) : @commits.last
+    end
+
+    def empty?
+      @commits.empty?
+    end
+
+    def to_text
+      @commits.map do |commit|
+        prefix = commit.merge? ? "M" : "*"
+        "#{prefix} #{commit.sha[0..6]} #{commit.message}"
+      end.join("\n")
+    end
+  end
+end

data/lib/revisable/merge.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Revisable
+  class Merge
+    include Enumerable
+
+    attr_reader :into_commit, :from_commit, :ancestor_commit,
+                :into, :from
+
+    def initialize(into_commit:, from_commit:, ancestor_commit:,
+                   into:, from:, versionable_fields:)
+      @into_commit = into_commit
+      @from_commit = from_commit
+      @ancestor_commit = ancestor_commit
+      @into = into.to_s
+      @from = from.to_s
+      @versionable_fields = versionable_fields
+
+      @into_fields = into_commit.field_set
+      @from_fields = from_commit.field_set
+      @ancestor_fields = ancestor_commit&.field_set || FieldSet.empty
+
+      @fields = build_merge_fields
+    end
+
+    def field(name)
+      @fields[name.to_sym]
+    end
+
+    def each(&block)
+      @fields.each(&block)
+    end
+
+    def clean?
+      conflicts.empty?
+    end
+
+    def conflicts
+      @fields.values.select(&:conflicted?)
+    end
+
+    def auto_resolved
+      @fields.values.select(&:auto_resolved?)
+    end
+
+    def unchanged
+      @fields.values.select(&:unchanged?)
+    end
+
+    def resolve(field_name, value)
+      f = field(field_name)
+      raise Error, "Unknown field: #{field_name}" unless f
+      f.resolve(value)
+    end
+
+    def resolved?(field_name)
+      field(field_name)&.resolved? || false
+    end
+
+    def all_resolved?
+      @fields.values.none?(&:conflicted?)
+    end
+
+    def unresolved
+      @fields.values.select(&:conflicted?)
+    end
+
+    def commit!(repository:, author: nil, message: "Merge #{from} into #{into}")
+      raise UnresolvedConflictsError, "Unresolved conflicts: #{unresolved.map(&:field_name).join(', ')}" unless all_resolved?
+
+      fields = @fields.each_with_object({}) do |(name, merge_field), hash|
+        hash[name] = merge_field.value
+      end
+
+      repository.commit!(
+        branch: nil,
+        author: author,
+        message: message,
+        fields: fields,
+        parent_shas: [into_commit.sha, from_commit.sha]
+      )
+    end
+
+    private
+
+    def build_merge_fields
+      @versionable_fields.each_with_object({}) do |field, result|
+        field = field.to_sym
+
+        ancestor_sha = @ancestor_fields.sha_for(field)
+        into_sha = @into_fields.sha_for(field)
+        from_sha = @from_fields.sha_for(field)
+
+        into_data = @into_fields.data_for(field)
+        from_data = @from_fields.data_for(field)
+        ancestor_data = @ancestor_fields.data_for(field)
+
+        into_changed = into_sha != ancestor_sha
+        from_changed = from_sha != ancestor_sha
+
+        status, auto_value = if !into_changed && !from_changed
+          [:unchanged, into_data]
+        elsif into_changed && !from_changed
+          [:auto_resolved, into_data]
+        elsif !into_changed && from_changed
+          [:auto_resolved, from_data]
+        elsif into_sha == from_sha
+          [:auto_resolved, into_data]
+        else
+          [:conflicted, nil]
+        end
+
+        result[field] = MergeField.new(
+          field_name: field,
+          status: status,
+          versions: { @into => into_data, @from => from_data },
+          ancestor: ancestor_data,
+          auto_resolved_value: auto_value
+        )
+      end
+    end
+  end
+end

data/lib/revisable/merge_field.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Revisable
+  class MergeField
+    attr_reader :field_name, :status, :ancestor, :resolved_value, :versions
+
+    def initialize(field_name:, status:, versions:, ancestor:, auto_resolved_value: nil)
+      @field_name = field_name.to_sym
+      @status = status
+      @versions = versions
+      @ancestor = ancestor
+      @auto_resolved_value = auto_resolved_value
+      @resolved_value = nil
+    end
+
+    def version(branch_name)
+      @versions[branch_name.to_s]
+    end
+
+    def conflicted?
+      status == :conflicted && !resolved?
+    end
+
+    def auto_resolved?
+      status == :auto_resolved
+    end
+
+    def unchanged?
+      status == :unchanged
+    end
+
+    def resolved?
+      !@resolved_value.nil?
+    end
+
+    def resolve(value)
+      @resolved_value = case value
+      when :ancestor then ancestor
+      when Symbol, String
+        name = value.to_s
+        if @versions.key?(name)
+          @versions[name]
+        else
+          value.to_s
+        end
+      else
+        value.to_s
+      end
+    end
+
+    def value
+      if resolved?
+        resolved_value
+      elsif auto_resolved? || unchanged?
+        @auto_resolved_value
+      end
+    end
+  end
+end

data/lib/revisable/model.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Revisable
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      after_create :revisable_initial_commit, if: :revisable_has_content?
+      after_update :revisable_auto_commit, if: :revisable_fields_changed?
+    end
+
+    class_methods do
+      def revisable(*fields, auto_commit: true)
+        @revisable_fields = fields.map(&:to_sym)
+        @revisable_auto_commit = auto_commit
+      end
+
+      def revisable_fields
+        @revisable_fields || []
+      end
+
+      def revisable_auto_commit?
+        @revisable_auto_commit != false
+      end
+    end
+
+    def repository
+      @_revisable_repository ||= Repository.new(
+        versionable: self,
+        fields: self.class.revisable_fields
+      )
+    end
+
+    private
+
+    def revisable_has_content?
+      self.class.revisable_auto_commit? &&
+        self.class.revisable_fields.any? { |f| send(f).present? }
+    end
+
+    def revisable_fields_changed?
+      self.class.revisable_auto_commit? &&
+        (saved_changes.keys.map(&:to_sym) & self.class.revisable_fields).any?
+    end
+
+    def revisable_changed_fields
+      self.class.revisable_fields.each_with_object({}) do |field, hash|
+        hash[field] = send(field)
+      end
+    end
+
+    def revisable_initial_commit
+      repository.commit!(
+        message: "Initial version",
+        author: CurrentAuthor.get,
+        fields: revisable_changed_fields
+      )
+    end
+
+    def revisable_auto_commit
+      changed = saved_changes.keys.map(&:to_sym) & self.class.revisable_fields
+      message = "Updated #{changed.map(&:to_s).join(', ')}"
+
+      repository.commit!(
+        message: message,
+        author: CurrentAuthor.get,
+        fields: revisable_changed_fields
+      )
+    end
+  end
+end

data/lib/revisable/ref.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Revisable
+  class Ref < ActiveRecord::Base
+    self.table_name = "revisable_refs"
+
+    belongs_to :versionable, polymorphic: true
+
+    belongs_to :commit,
+      class_name: "Revisable::Commit",
+      foreign_key: :commit_sha,
+      primary_key: :sha
+
+    validates :name, presence: true
+    validates :ref_type, presence: true, inclusion: { in: %w[branch tag] }
+    validates :name, uniqueness: { scope: [:versionable_type, :versionable_id, :ref_type] }
+
+    scope :branches, -> { where(ref_type: "branch") }
+    scope :tags, -> { where(ref_type: "tag") }
+
+    def branch?
+      ref_type == "branch"
+    end
+
+    def tag?
+      ref_type == "tag"
+    end
+
+    def advance!(new_sha, expected_sha: nil)
+      if expected_sha
+        rows = self.class.where(id: id, commit_sha: expected_sha).update_all(commit_sha: new_sha)
+        raise StaleRefError, "Ref #{name} was updated by another process" if rows == 0
+        self.commit_sha = new_sha
+      else
+        update!(commit_sha: new_sha)
+      end
+    end
+  end
+end

data/lib/revisable/renderers/html_renderer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Revisable
+  module Renderers
+    class HtmlRenderer
+      attr_reader :field_diff
+
+      def initialize(field_diff)
+        @field_diff = field_diff
+      end
+
+      def render
+        return nil unless field_diff.changed?
+
+        parts = []
+        parts << "<div class=\"revisable-diff\" data-field=\"#{field_diff.field_name}\">"
+
+        field_diff.hunks.each do |change|
+          escaped_old = escape_html(change.old_element.to_s)
+          escaped_new = escape_html(change.new_element.to_s)
+
+          case change.action
+          when "="
+            parts << "<span class=\"unchanged\">#{escaped_old}</span>"
+          when "!"
+            parts << "<del>#{escaped_old}</del>"
+            parts << "<ins>#{escaped_new}</ins>"
+          when "-"
+            parts << "<del>#{escaped_old}</del>"
+          when "+"
+            parts << "<ins>#{escaped_new}</ins>"
+          end
+        end
+
+        parts << "</div>"
+        parts.join("\n")
+      end
+
+      private
+
+      def escape_html(str)
+        str.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub('"', "&quot;")
+      end
+    end
+  end
+end

data/lib/revisable/renderers/text_renderer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Revisable
+  module Renderers
+    class TextRenderer
+      attr_reader :field_diff
+
+      def initialize(field_diff)
+        @field_diff = field_diff
+      end
+
+      def render
+        return nil unless field_diff.changed?
+
+        lines = []
+        lines << "--- a/#{field_diff.field_name}"
+        lines << "+++ b/#{field_diff.field_name}"
+
+        field_diff.hunks.each do |change|
+          case change.action
+          when "="
+            lines << " #{change.old_element}"
+          when "!"
+            lines << "-#{change.old_element}"
+            lines << "+#{change.new_element}"
+          when "-"
+            lines << "-#{change.old_element}"
+          when "+"
+            lines << "+#{change.new_element}"
+          end
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end