jaculabilis/danbooru
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add alternate comparison types to versions

Browse Source 
- The types are:
-- Previous: The default and the previously used type
-- Subsequent: Compares against the next version
-- Current: Compares against the current version
- Allow switching between comparison types in index and diff views
-- Have links vary depending upon current comparison type
This commit is contained in:
BrokenEagle
2020-03-17 07:23:42 +00:00
parent a95e57d938
commit e23ee170f5
41 changed files with 488 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
app/helpers/application_helper.rb
View File

@@ -5,37 +5,45 @@ module ApplicationHelper
(fields.reduce(false) { |acc, field| acc || params.dig(:search, field).present? } && (!member_check || CurrentUser.is_member?) ? types[0] : types[1])
end
def diff_list_html(new, old, latest, ul_class: ["diff-list"], li_class: [])
diff = SetDiff.new(new, old, latest)
def diff_list_html(this_list, other_list, ul_class: ["diff-list"], li_class: [])
diff = SetDiff.new(this_list, other_list)
render "diff_list", diff: diff, ul_class: ul_class, li_class: li_class
end
def diff_name_html(this_name, prev_name)
def diff_name_html(this_name, other_name)
pattern = Regexp.new('.')
DiffBuilder.new(this_name, prev_name, pattern).build
DiffBuilder.new(this_name, other_name, pattern).build
end
def diff_body_html(record, previous, field)
return h(record[field]).gsub(/\r?\n/, '<span class="paragraph-mark">¶</span><br>').html_safe if previous.blank?
def diff_body_html(record, other, field)
if record.blank? || other.blank?
diff_record = other.presence || record
return h(diff_record[field]).gsub(/\r?\n/, '<span class="paragraph-mark">¶</span><br>').html_safe
end
pattern = Regexp.new('(?:<.+?>)|(?:\w+)|(?:[ \t]+)|(?:\r?\n)|(?:.+?)')
DiffBuilder.new(record[field], previous[field], pattern).build
DiffBuilder.new(record[field], other[field], pattern).build
end
def status_diff_html(record)
previous = record.previous
def status_diff_html(record, type)
other = record.send(type)
return "New" if previous.blank?
if other.blank?
return type == "previous" ? "New" : ""
end
statuses = []
record.class.status_fields.each do |field, status|
if record.has_attribute?(field)
statuses += [status] if record[field] != previous[field]
statuses += [status] if record[field] != other[field]
else
statuses += [status] if record.send(field)
statuses += [status] if record.send(field, type)
end
end
statuses.join("<br>").html_safe
altered = record.updater_id != other.updater_id
%(<div class="version-statuses" data-altered="#{altered}">#{statuses.join("<br>")}</div>).html_safe
end
def wordbreakify(string)
@@ -44,6 +52,18 @@ module ApplicationHelper
raw(wordbreaked_string)
end
def version_type_links(params)
html = []
%w[previous subsequent current].each do |type|
if type == params[:type]
html << %(<span>#{type}</span>)
else
html << tag.li(link_to(type, params.except(:controller, :action).merge(type: type).permit!))
end
end
html.join(" | ").html_safe
end
def nav_link_to(text, url, **options)
klass = options.delete(:class)

10
app/helpers/artist_commentary_versions_helper.rb Normal file
View File

@@ -0,0 +1,10 @@
module ArtistCommentaryVersionsHelper
def commentary_version_field_diff(commentary_version, type, field)
other = commentary_version.send(params[:type])
if type == "previous"
diff_body_html(commentary_version, other, field)
else
diff_body_html(other, commentary_version, field)
end
end
end

65
app/helpers/artist_versions_helper.rb
View File

@@ -1,34 +1,63 @@
module ArtistVersionsHelper
def artist_version_other_names_diff(artist_version)
new_names = artist_version.other_names
old_names = artist_version.previous.try(:other_names)
latest_names = artist_version.artist.other_names
def artist_version_other_names_diff(artist_version, type)
other = artist_version.send(type)
this_names = artist_version.other_names
if other.present?
other_names = other.other_names
elsif type == "subsequent"
other_names = this_names
else
other_names = []
end
diff_list_html(new_names, old_names, latest_names)
if type == "previous"
diff_list_html(this_names, other_names)
else
diff_list_html(other_names, this_names)
end
end
def artist_version_urls_diff(artist_version)
new_urls = artist_version.urls
old_urls = artist_version.previous.try(:urls)
latest_urls = artist_version.artist.urls.map(&:to_s)
def artist_version_urls_diff(artist_version, type)
other = artist_version.send(type)
this_urls = artist_version.urls
if other.present?
other_urls = other.urls
elsif type == "subsequent"
other_urls = this_urls
else
other_urls = []
end
diff_list_html(new_urls, old_urls, latest_urls)
if type == "previous"
diff_list_html(this_urls, other_urls)
else
diff_list_html(other_urls, this_urls)
end
end
def artist_version_name_diff(artist_version)
previous = artist_version.previous
if previous.present? && (artist_version.name != previous.name)
name_diff = diff_name_html(artist_version.name, previous.name)
def artist_version_name_diff(artist_version, type)
other = artist_version.send(type)
if other.present? && (artist_version.name != other.name)
if type == "previous"
name_diff = diff_name_html(artist_version.name, other.name)
else
name_diff = diff_name_html(other.name, artist_version.name)
end
%(<br><br><b>Rename:</b><br>&ensp;#{name_diff}</p>).html_safe
else
""
end
end
def artist_version_group_name_diff(artist_version)
previous = artist_version.previous
if artist_version.group_name.present? || (previous.present? && previous.group_name.present?)
group_name_diff = diff_name_html(artist_version.group_name, previous.group_name)
def artist_version_group_name_diff(artist_version, type)
other = artist_version.send(type)
if artist_version.group_name.present? || (other.present? && other.group_name.present?)
other_group_name = (other.present? ? other.group_name : artist_version.group_name)
if type == "previous"
group_name_diff = diff_name_html(artist_version.group_name, other_group_name)
else
group_name_diff = diff_name_html(other_group_name, artist_version.group_name)
end
%(<b>Group:</b><br>&ensp;#{group_name_diff}<br><br>).html_safe
else
""

29
app/helpers/note_versions_helper.rb
View File

@@ -1,23 +1,36 @@
module NoteVersionsHelper
def note_version_position_diff(note_version)
previous = note_version.previous
def note_version_position_diff(note_version, type)
other = note_version.send(type)
html = "#{note_version.x},#{note_version.y}"
if previous.nil? || (note_version.x == previous.x && note_version.y == previous.y)
if other.nil? || (note_version.x == other.x && note_version.y == other.y)
html
elsif type == "previous"
"#{other.x},#{other.y} -> " + html
else
"#{previous.x},#{previous.y} -> " + html
html + " -> #{other.x},#{other.y}"
end
end
def note_version_size_diff(note_version)
previous = note_version.previous
def note_version_size_diff(note_version, type)
other = note_version.send(type)
html = "#{note_version.width}x#{note_version.height}"
if previous.nil? || (note_version.width == previous.width && note_version.height == previous.height)
if other.nil? || (note_version.width == other.width && note_version.height == other.height)
html
elsif type == "previous"
"#{other.width}x#{other.height} -> " + html
else
"#{previous.width}x#{previous.height} -> " + html
html + " -> #{other.width}x#{other.height}"
end
end
def note_version_body_diff(note_version, type)
other = note_version.send(params[:type])
if type == "previous"
diff_body_html(note_version, other, :body)
else
diff_body_html(other, note_version, :body)
end
end
end

35
app/helpers/pool_versions_helper.rb
View File

@@ -1,29 +1,38 @@
module PoolVersionsHelper
def pool_version_show_diff(pool_version)
previous = pool_version.previous
previous.present? && pool_version.description != previous.description
def pool_version_show_diff(pool_version, type)
other = pool_version.send(type)
other.present? && pool_version.description != other.description
end
def pool_version_name_diff(pool_version)
previous = pool_version.previous
if previous.present? && (pool_version.name != previous.name)
name_diff = diff_name_html(pool_version.pretty_name, previous.pretty_name)
def pool_version_name_diff(pool_version, type)
other = pool_version.send(type)
if other.present? && (pool_version.name != other.name)
if type == "previous"
name_diff = diff_name_html(pool_version.name, other.name)
else
name_diff = diff_name_html(other.name, pool_version.name)
end
%(<br><br><b>Rename:</b><br>&ensp;#{name_diff}</p>).html_safe
else
""
end
end
def pool_version_post_diff(pool_version)
previous = pool_version.previous
def pool_version_post_diff(pool_version, type)
other = pool_version.send(type)
diff = {}
if previous.present?
diff[:added_post_ids] = pool_version.post_ids - previous.post_ids
diff[:removed_post_ids] = previous.post_ids - pool_version.post_ids
else
if other.present? && type == "previous"
diff[:added_post_ids] = pool_version.post_ids - other.post_ids
diff[:removed_post_ids] = other.post_ids - pool_version.post_ids
elsif other.present?
diff[:added_post_ids] = other.post_ids - pool_version.post_ids
diff[:removed_post_ids] = pool_version.post_ids - other.post_ids
elsif type == "previous"
diff[:added_post_ids] = pool_version.added_post_ids
diff[:removed_post_ids] = pool_version.removed_post_ids
else
return ""
end
render "pool_versions/diff", diff: diff

55
app/helpers/post_versions_helper.rb
View File

@@ -1,45 +1,38 @@
module PostVersionsHelper
def post_version_diff(post_version)
previous = post_version.previous
post = post_version.post
def post_version_diff(post_version, type)
other = post_version.send(type)
if post.nil?
latest_tags = post_version.tag_array
this_tags = post_version.tag_array
this_tags << "rating:#{post_version.rating}" if post_version.rating.present?
this_tags << "parent:#{post_version.parent_id}" if post_version.parent_id.present?
this_tags << "source:#{post_version.source}" if post_version.source.present?
other_tags = other.present? ? other.tag_array : []
if other.present?
other_tags << "rating:#{other.rating}" if other.rating.present?
other_tags << "parent:#{other.parent_id}" if other.parent_id.present?
other_tags << "source:#{other.source}" if other.source.present?
elsif type == "subsequent"
other_tags = this_tags
end
if type == "previous"
added_tags = this_tags - other_tags
removed_tags = other_tags - this_tags
else
latest_tags = post.tag_array
latest_tags << "rating:#{post.rating}" if post.rating.present?
latest_tags << "parent:#{post.parent_id}" if post.parent_id.present?
latest_tags << "source:#{post.source}" if post.source.present?
added_tags = other_tags - this_tags
removed_tags = this_tags - other_tags
end
new_tags = post_version.tag_array
new_tags << "rating:#{post_version.rating}" if post_version.rating.present?
new_tags << "parent:#{post_version.parent_id}" if post_version.parent_id.present?
new_tags << "source:#{post_version.source}" if post_version.source.present?
old_tags = previous.present? ? previous.tag_array : []
if previous.present?
old_tags << "rating:#{previous.rating}" if previous.rating.present?
old_tags << "parent:#{previous.parent_id}" if previous.parent_id.present?
old_tags << "source:#{previous.source}" if previous.source.present?
end
added_tags = new_tags - old_tags
removed_tags = old_tags - new_tags
obsolete_added_tags = added_tags - latest_tags,
obsolete_removed_tags = removed_tags & latest_tags,
unchanged_tags = new_tags & old_tags
unchanged_tags = this_tags & other_tags
html = '<span class="diff-list">'
added_tags.each do |tag|
prefix = obsolete_added_tags.include?(tag) ? '+<ins class="obsolete">' : '<ins>+'
html << prefix + link_to(wordbreakify(tag), posts_path(:tags => tag)) + '</ins>'
html << '<ins>+' + link_to(wordbreakify(tag), posts_path(:tags => tag)) + '</ins>'
html << " "
end
removed_tags.each do |tag|
prefix = obsolete_removed_tags.include?(tag) ? '-<del class="obsolete">' : '<del>-'
html << prefix + link_to(wordbreakify(tag), posts_path(:tags => tag)) + '</del>'
html << '<del>-' + link_to(wordbreakify(tag), posts_path(:tags => tag)) + '</del>'
html << " "
end
unchanged_tags.each do |tag|

31
app/helpers/wiki_page_versions_helper.rb
View File

@@ -1,25 +1,28 @@
module WikiPageVersionsHelper
def wiki_version_show_diff(wiki_page_version)
previous = wiki_page_version.previous
previous.present? && ((wiki_page_version.body != previous.body) || wiki_page_version.other_names_changed)
def wiki_version_show_diff(wiki_page_version, type)
other = wiki_page_version.send(type)
other.present? && ((wiki_page_version.body != other.body) || wiki_page_version.other_names_changed(type))
end
def wiki_version_show_other_names(new_version, old_version)
((new_version.other_names - old_version.other_names) | (old_version.other_names - new_version.other_names)).length > 0
def wiki_version_show_other_names(this_version, other_version)
((this_version.other_names - other_version.other_names) | (other_version.other_names - this_version.other_names)).length.positive?
end
def wiki_version_other_names_diff(new_version, old_version)
new_names = new_version.other_names
old_names = old_version.other_names
latest_names = new_version.wiki_page.other_names
def wiki_version_other_names_diff(this_version, other_version)
this_names = this_version.other_names
other_names = other_version.other_names
diff_list_html(new_names, old_names, latest_names, ul_class: ["wiki-other-names-diff-list list-inline"], li_class: ["wiki-other-name"])
diff_list_html(this_names, other_names, ul_class: ["wiki-other-names-diff-list list-inline"], li_class: ["wiki-other-name"])
end
def wiki_version_title_diff(wiki_page_version)
previous = wiki_page_version.previous
if previous.present? && (wiki_page_version.title != previous.title)
name_diff = diff_name_html(wiki_page_version.title, previous.title)
def wiki_version_title_diff(wiki_page_version, type)
other = wiki_page_version.send(type)
if other.present? && (wiki_page_version.title != other.title)
if type == "previous"
name_diff = diff_name_html(wiki_page_version.title, other.title)
else
name_diff = diff_name_html(other.title, wiki_page_version.title)
end
%((<b>Rename:</b>&ensp;#{name_diff})).html_safe
else
""