revisions.rb

class Survey < ApplicationRecord
  has_many :revisions
  belongs_to :draft_revision
  belongs_to :published_revision

  has_many :draft_fields, through: :draft_revision
  has_many :fields, through: :published_revision

  def publish
    self.published_revision = draft_revision
    self.draft_revision = draft_revision.clone
  end
end

class SurveyRevision < ApplicationRecord
  belongs_to :survey
  has_many :field_positions, -> { ordered }
  has_many :fields, through: :field_positions

  def clone(revision)
    new_revision = survey.revisions.create
    revision.field_positions.each do |field_position|
      new_revision.field_positions.create(
        field: field_position.field,
        position: field_position.position
      )
    end
    new_revision
  end

  def add_field(label:)
    ensure_draft

    field = SurveyField.create(revision: self, label: label)
    field_positions.create(field: field, position: field_positions.size)
  end

  def update_field(field, label:)
    ensure_draft

    if field.revision == self
      field.update(label: label)
    else
      cloned_field = SurveyField.create(revision: self, label: field.label)
      field_positions.where(field: field).update(field: cloned_field)
    end
  end

  def remove_field(field)
    ensure_draft

    if field.revision == self
      field.destroy
    else
      field_positions.delete(field)
    end
  end

  def draft?
    survey.draft_revision == self
  end

  def ensure_draft
    raise "only draft can be edited" unless draft?
  end
end

class SurveyField < ApplicationRecord
  belongs_to :revison
  has_many :field_positions
end

class FieldPosition < ApplicationRecord
  belongs_to :revision
  belongs_to :field

  scope :ordered, -> { order(:position) }
end