summaryrefslogtreecommitdiffstats
path: root/app/models/wiki_page.rb
blob: 32d04335522bfa5d0ae2e2ba9b217a83b2f73131 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
# Redmine - project management software
# Copyright (C) 2006-2014  Jean-Philippe Lang
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

require 'diff'
require 'enumerator'

class WikiPage < ActiveRecord::Base
  include Redmine::SafeAttributes

  belongs_to :wiki
  has_one :content, :class_name => 'WikiContent', :foreign_key => 'page_id', :dependent => :destroy
  acts_as_attachable :delete_permission => :delete_wiki_pages_attachments
  acts_as_tree :dependent => :nullify, :order => 'title'

  acts_as_watchable
  acts_as_event :title => Proc.new {|o| "#{l(:label_wiki)}: #{o.title}"},
                :description => :text,
                :datetime => :created_on,
                :url => Proc.new {|o| {:controller => 'wiki', :action => 'show', :project_id => o.wiki.project, :id => o.title}}

  acts_as_searchable :columns => ['title', "#{WikiContent.table_name}.text"],
                     :scope => joins(:content, {:wiki => :project}),
                     :preload => [:content, {:wiki => :project}],
                     :permission => :view_wiki_pages,
                     :project_key => "#{Wiki.table_name}.project_id"

  attr_accessor :redirect_existing_links

  validates_presence_of :title
  validates_format_of :title, :with => /\A[^,\.\/\?\;\|\s]*\z/
  validates_uniqueness_of :title, :scope => :wiki_id, :case_sensitive => false
  validates_associated :content
  attr_protected :id

  validate :validate_parent_title
  before_destroy :delete_redirects
  before_save :handle_rename_or_move
  after_save :handle_children_move

  # eager load information about last updates, without loading text
  scope :with_updated_on, lambda {
    select("#{WikiPage.table_name}.*, #{WikiContent.table_name}.updated_on, #{WikiContent.table_name}.version").
      joins("LEFT JOIN #{WikiContent.table_name} ON #{WikiContent.table_name}.page_id = #{WikiPage.table_name}.id")
  }

  # Wiki pages that are protected by default
  DEFAULT_PROTECTED_PAGES = %w(sidebar)

  safe_attributes 'parent_id', 'parent_title', 'title', 'redirect_existing_links', 'wiki_id',
    :if => lambda {|page, user| page.new_record? || user.allowed_to?(:rename_wiki_pages, page.project)}

  def initialize(attributes=nil, *args)
    super
    if new_record? && DEFAULT_PROTECTED_PAGES.include?(title.to_s.downcase)
      self.protected = true
    end
  end

  def visible?(user=User.current)
    !user.nil? && user.allowed_to?(:view_wiki_pages, project)
  end

  def title=(value)
    value = Wiki.titleize(value)
    write_attribute(:title, value)
  end

  def safe_attributes=(attrs, user=User.current)
    return unless attrs.is_a?(Hash)
    attrs = attrs.deep_dup

    # Project and Tracker must be set before since new_statuses_allowed_to depends on it.
    if (w_id = attrs.delete('wiki_id')) && safe_attribute?('wiki_id')
      if (w = Wiki.find_by_id(w_id)) && w.project && user.allowed_to?(:rename_wiki_pages, w.project)
        self.wiki = w
      end
    end

    super attrs, user
  end

  # Manages redirects if page is renamed or moved
  def handle_rename_or_move
    if !new_record? && (title_changed? || wiki_id_changed?)
      # Update redirects that point to the old title
      WikiRedirect.where(:redirects_to => title_was, :redirects_to_wiki_id => wiki_id_was).each do |r|
        r.redirects_to = title
        r.redirects_to_wiki_id = wiki_id
        (r.title == r.redirects_to && r.wiki_id == r.redirects_to_wiki_id) ? r.destroy : r.save
      end
      # Remove redirects for the new title
      WikiRedirect.where(:wiki_id => wiki_id, :title => title).delete_all
      # Create a redirect to the new title
      unless redirect_existing_links == "0"
        WikiRedirect.create(
          :wiki_id => wiki_id_was, :title => title_was,
          :redirects_to_wiki_id => wiki_id, :redirects_to => title
        )
      end
    end
    if !new_record? && wiki_id_changed? && parent.present?
      unless parent.wiki_id == wiki_id
        self.parent_id = nil
      end
    end
  end
  private :handle_rename_or_move

  # Moves child pages if page was moved
  def handle_children_move
    if !new_record? && wiki_id_changed?
      children.each do |child|
        child.wiki_id = wiki_id
        child.redirect_existing_links = redirect_existing_links
        unless child.save
          WikiPage.where(:id => child.id).update_all :parent_nil => nil
        end
      end
    end
  end
  private :handle_children_move

  # Deletes redirects to this page
  def delete_redirects
    WikiRedirect.where(:redirects_to_wiki_id => wiki_id, :redirects_to => title).delete_all
  end

  def pretty_title
    WikiPage.pretty_title(title)
  end

  def content_for_version(version=nil)
    if content
      result = content.versions.find_by_version(version.to_i) if version
      result ||= content
      result
    end
  end

  def diff(version_to=nil, version_from=nil)
    version_to = version_to ? version_to.to_i : self.content.version
    content_to = content.versions.find_by_version(version_to)
    content_from = version_from ? content.versions.find_by_version(version_from.to_i) : content_to.try(:previous)
    return nil unless content_to && content_from

    if content_from.version > content_to.version
      content_to, content_from = content_from, content_to
    end

    (content_to && content_from) ? WikiDiff.new(content_to, content_from) : nil
  end

  def annotate(version=nil)
    version = version ? version.to_i : self.content.version
    c = content.versions.find_by_version(version)
    c ? WikiAnnotate.new(c) : nil
  end

  def self.pretty_title(str)
    (str && str.is_a?(String)) ? str.tr('_', ' ') : str
  end

  def project
    wiki.try(:project)
  end

  def text
    content.text if content
  end

  def updated_on
    unless @updated_on
      if time = read_attribute(:updated_on)
        # content updated_on was eager loaded with the page
        begin
          @updated_on = (self.class.default_timezone == :utc ? Time.parse(time.to_s).utc : Time.parse(time.to_s).localtime)
        rescue
        end
      else
        @updated_on = content && content.updated_on
      end
    end
    @updated_on
  end

  # Returns true if usr is allowed to edit the page, otherwise false
  def editable_by?(usr)
    !protected? || usr.allowed_to?(:protect_wiki_pages, wiki.project)
  end

  def attachments_deletable?(usr=User.current)
    editable_by?(usr) && super(usr)
  end

  def parent_title
    @parent_title || (self.parent && self.parent.pretty_title)
  end

  def parent_title=(t)
    @parent_title = t
    parent_page = t.blank? ? nil : self.wiki.find_page(t)
    self.parent = parent_page
  end

  # Saves the page and its content if text was changed
  # Return true if the page was saved
  def save_with_content(content)
    ret = nil
    transaction do
      ret = save
      if content.text_changed?
        begin
          self.content = content
          ret = ret && content.changed?
        rescue ActiveRecord::RecordNotSaved
          ret = false
        end
      end
      raise ActiveRecord::Rollback unless ret
    end
    ret
  end

  protected

  def validate_parent_title
    errors.add(:parent_title, :invalid) if !@parent_title.blank? && parent.nil?
    errors.add(:parent_title, :circular_dependency) if parent && (parent == self || parent.ancestors.include?(self))
    if parent_id_changed? && parent && (parent.wiki_id != wiki_id)
      errors.add(:parent_title, :not_same_project)
    end
  end
end

class WikiDiff < Redmine::Helpers::Diff
  attr_reader :content_to, :content_from

  def initialize(content_to, content_from)
    @content_to = content_to
    @content_from = content_from
    super(content_to.text, content_from.text)
  end
end

class WikiAnnotate
  attr_reader :lines, :content

  def initialize(content)
    @content = content
    current = content
    current_lines = current.text.split(/\r?\n/)
    @lines = current_lines.collect {|t| [nil, nil, t]}
    positions = []
    current_lines.size.times {|i| positions << i}
    while (current.previous)
      d = current.previous.text.split(/\r?\n/).diff(current.text.split(/\r?\n/)).diffs.flatten
      d.each_slice(3) do |s|
        sign, line = s[0], s[1]
        if sign == '+' && positions[line] && positions[line] != -1
          if @lines[positions[line]][0].nil?
            @lines[positions[line]][0] = current.version
            @lines[positions[line]][1] = current.author
          end
        end
      end
      d.each_slice(3) do |s|
        sign, line = s[0], s[1]
        if sign == '-'
          positions.insert(line, -1)
        else
          positions[line] = nil
        end
      end
      positions.compact!
      # Stop if every line is annotated
      break unless @lines.detect { |line| line[0].nil? }
      current = current.previous
    end
    @lines.each { |line|
      line[0] ||= current.version
      # if the last known version is > 1 (eg. history was cleared), we don't know the author
      line[1] ||= current.author if current.version == 1
    }
  end
end