Class: Wiki

Inherits:
Object
  • Object
show all
Extended by:
ActiveModel::Naming, Gitlab::Utils::Override
Includes:
Gitlab::Git::WrapsGitalyErrors, Gitlab::Utils::StrongMemoize, GlobalID::Identification, HasRepository, Repositories::CanHousekeepRepository
Defined in:
app/models/wiki.rb

Direct Known Subclasses

ProjectWiki

Constant Summary collapse

MARKUPS =

rubocop:disable Style/MultilineIfModifier

{ # rubocop:disable Style/MultilineIfModifier
  markdown: {
    name: 'Markdown',
    default_extension: :md,
    extension_regex: Regexp.new('md|mkdn?|mdown|markdown', 'i'),
    created_by_user: true
  },
  rdoc: {
    name: 'RDoc',
    default_extension: :rdoc,
    extension_regex: Regexp.new('rdoc', 'i'),
    created_by_user: true
  },
  asciidoc: {
    name: 'AsciiDoc',
    default_extension: :asciidoc,
    extension_regex: Regexp.new('adoc|asciidoc', 'i'),
    created_by_user: true
  },
  org: {
    name: 'Org',
    default_extension: :org,
    extension_regex: Regexp.new('org', 'i'),
    created_by_user: true
  },
  textile: {
    name: 'Textile',
    default_extension: :textile,
    extension_regex: Regexp.new('textile', 'i')
  },
  creole: {
    name: 'Creole',
    default_extension: :creole,
    extension_regex: Regexp.new('creole', 'i')
  },
  rest: {
    name: 'reStructuredText',
    default_extension: :rst,
    extension_regex: Regexp.new('re?st(\.txt)?', 'i')
  },
  mediawiki: {
    name: 'MediaWiki',
    default_extension: :mediawiki,
    extension_regex: Regexp.new('(media)?wiki', 'i')
  },
  pod: {
    name: 'Pod',
    default_extension: :pod,
    extension_regex: Regexp.new('pod', 'i')
  },
  plaintext: {
    name: 'Plain Text',
    default_extension: :txt,
    extension_regex: Regexp.new('txt', 'i')
  }
}.freeze
VALID_USER_MARKUPS = 
MARKUPS.select { |_, v| v[:created_by_user] }.freeze
ALLOWED_EXTENSIONS_REGEX = 
Regexp.union(MARKUPS.map { |key, value| value[:extension_regex] }).freeze
CouldNotCreateWikiError = 
Class.new(StandardError)
HOMEPAGE = 
'home'

'_sidebar'
TEMPLATES_DIR = 
'templates'
REDIRECTS_YML = 
'.gitlab/redirects.yml'
TITLE_ORDER = 
'title'
CREATED_AT_ORDER = 
'created_at'
DIRECTION_DESC = 
'desc'
DIRECTION_ASC = 
'asc'

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Gitlab::Utils::Override

extended, extensions, included, method_added, override, prepended, queue_verification, verify!

Methods included from Gitlab::Git::WrapsGitalyErrors

#wrapped_gitaly_errors

Methods included from Repositories::CanHousekeepRepository

#increment_pushes_since_gc, #pushes_since_gc, #reset_pushes_since_gc

Methods included from HasRepository

#after_change_head_branch_does_not_exist, #after_create_repository, #after_repository_change_head, #apply_desired_default_branch, #branch_exists?, #commit, #commit_by, #commits_by, #default_branch=, #default_branch_from_group_preferences, #default_branch_from_preferences, #empty_repo?, #http_url_to_repo, #lfs_enabled?, #lfs_http_url_to_repo, #ref_exists?, #reload_default_branch, #repo_exists?, #repository_exists?, #repository_size_checker, #root_ref?, #ssh_url_to_repo, #storage, #url_to_repo, #valid_repo?, #web_url

Methods included from Gitlab::ShellAdapter

#gitlab_shell

Methods included from Referable

#referable_inspect, #reference_link_text, #to_reference, #to_reference_base

Constructor Details

#initialize(container, user = nil) ⇒ Wiki

Returns a new instance of Wiki.

Raises:

  • (ArgumentError) 


146
147
148
149
150
151
 
# File 'app/models/wiki.rb', line 146

def initialize(container, user = nil)
  raise ArgumentError, "user must be a User, got #{user.class}" if user && !user.is_a?(User)

  @container = container
  @user = user
end

Class Attribute Details

.container_class ⇒ Object

Returns the value of attribute container_class.



100
101
102
 
# File 'app/models/wiki.rb', line 100

def container_class
  @container_class
end

Instance Attribute Details

#container ⇒ Object (readonly)

Returns the value of attribute container.



88
89
90
 
# File 'app/models/wiki.rb', line 88

def container
  @container
end

#error_message ⇒ Object (readonly)

Returns a string describing what went wrong after an operation fails.



92
93
94
 
# File 'app/models/wiki.rb', line 92

def error_message
  @error_message
end

#user ⇒ Object (readonly)

Returns the value of attribute user.



88
89
90
 
# File 'app/models/wiki.rb', line 88

def user
  @user
end

Class Method Details

.canonicalize_filename(filename) ⇒ Object 



122
123
124
 
# File 'app/models/wiki.rb', line 122

def canonicalize_filename(filename)
  ::File.basename(filename, ::File.extname(filename)).tr('-', ' ')
end

.cname(name, char_white_sub = '-', char_other_sub = '-') ⇒ Object 



126
127
128
 
# File 'app/models/wiki.rb', line 126

def cname(name, char_white_sub = '-', char_other_sub = '-')
  name.to_s.gsub(/\s/, char_white_sub).gsub(/[<>+]/, char_other_sub)
end

.find_by_id(container_id) ⇒ Object

This is needed to support repository lookup through Gitlab::GlRepository::Identifier



107
108
109
 
# File 'app/models/wiki.rb', line 107

def find_by_id(container_id)
  container_class.find_by_id(container_id)&.wiki
end

.for_container(container, user = nil) ⇒ Object 



102
103
104
 
# File 'app/models/wiki.rb', line 102

def for_container(container, user = nil)
  "#{container.class.name}Wiki".constantize.new(container, user)
end

.preview_slug(title, format) ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'app/models/wiki.rb', line 130

def preview_slug(title, format)
  ext = format == :markdown ? "md" : format.to_s
  name = cname(title) + '.' + ext
  canonical_name = canonicalize_filename(name)

  path =
    if name.include?('/')
      name.sub(%r{/[^/]+$}, '/')
    else
      ''
    end

  path + cname(canonical_name, '-', '-')
end

.sluggified_full_path(title, extension) ⇒ Object 



111
112
113
 
# File 'app/models/wiki.rb', line 111

def sluggified_full_path(title, extension)
  sluggified_title(title) + '.' + extension
end

.sluggified_title(title) ⇒ Object 



115
116
117
118
119
120
 
# File 'app/models/wiki.rb', line 115

def sluggified_title(title)
  title = Gitlab::EncodingHelper.encode_utf8_no_detect(title.to_s.strip)
  title = File.absolute_path(title, '/')
  title = Pathname.new(title).relative_path_from('/').to_s
  title.tr(' ', '-')
end

Instance Method Details

#==(other) ⇒ Object 



153
154
155
 
# File 'app/models/wiki.rb', line 153

def ==(other)
  other.is_a?(self.class) && container == other.container
end

#after_post_receive ⇒ Object

Callbacks for background processing after wiki changes. These will be executed after any change to the wiki repository.



432
 
# File 'app/models/wiki.rb', line 432

def after_post_receive; end

#after_wiki_activity ⇒ Object

Callbacks for synchronous processing after wiki changes. These will be executed after any change made through GitLab itself (web UI and API), but not for Git pushes.



428
 
# File 'app/models/wiki.rb', line 428

def after_wiki_activity; end

#cleanup ⇒ Object 



439
440
441
 
# File 'app/models/wiki.rb', line 439

def cleanup
  @repository = nil
end

#create_page(title, content, format = :markdown, message = nil) ⇒ Object 



301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
 
# File 'app/models/wiki.rb', line 301

def create_page(title, content, format = :markdown, message = nil)
  with_valid_format(format) do |default_extension|
    sanitized_path = sluggified_full_path(title, default_extension)

    capture_git_error(:created) do
      # cannot create two pages with:
      # - the same title but different format
      # - the same title but different capitalization
      # - the same title, different capitalization, and different format
      next duplicated_page_error(sanitized_path) if file_exists_by_regex?(title)

      create_wiki_repository unless repository_exists?
      sanitized_path = sluggified_full_path(title, default_extension)
      options = multi_commit_options(:created, message, title)
      actions =
        repository.create_file_actions(sanitized_path, content) +
        update_redirection_actions(sluggified_title(title))

      repository.commit_files(user, **options.merge({ actions: actions }))

      repository.expire_status_cache if repository.empty?
      after_wiki_activity

      true
    rescue Gitlab::Git::Index::IndexError
      duplicated_page_error(sanitized_path)
    end
  end
end

#create_wiki_repository ⇒ Object 



175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'app/models/wiki.rb', line 175

def create_wiki_repository
  repository.create_if_not_exists(default_branch)

  raise CouldNotCreateWikiError unless repository_exists?
rescue StandardError => e
  Gitlab::ErrorTracking.track_exception(e, wiki: {
    container_type: container.class.name,
    container_id: container.id,
    full_path: full_path,
    disk_path: disk_path
  })

  raise CouldNotCreateWikiError
end

#default_branch ⇒ Object 



415
416
417
418
419
 
# File 'app/models/wiki.rb', line 415

def default_branch
  capture_git_error(:default_branch, response_on_error: 'main') do
    super || Gitlab::DefaultBranch.value(object: container)
  end
end

#delete_page(page, message = nil) ⇒ Object 



362
363
364
365
366
367
368
369
370
371
372
373
 
# File 'app/models/wiki.rb', line 362

def delete_page(page, message = nil)
  return unless page

  capture_git_error(:deleted) do
    create_wiki_repository unless repository_exists?
    repository.delete_file(user, page.path, **multi_commit_options(:deleted, message, page.title))

    after_wiki_activity

    true
  end
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


196
197
198
199
200
 
# File 'app/models/wiki.rb', line 196

def empty?
  capture_git_error(:empty, response_on_error: true) do
    !repository_exists? || list_page_paths(limit: 1).empty?
  end
end

#exists? ⇒ Boolean

Returns:

  • (Boolean) 


202
203
204
 
# File 'app/models/wiki.rb', line 202

def exists?
  !empty?
end

#find_file(name, version = default_branch, load_content: true) ⇒ Object 



290
291
292
293
294
295
296
297
298
299
 
# File 'app/models/wiki.rb', line 290

def find_file(name, version = default_branch, load_content: true)
  data_limit = load_content ? -1 : 0
  blobs = capture_git_error(:blob, response_on_error: []) do
    repository.blobs_at([[version, name]], blob_size_limit: data_limit)
  end

  return if blobs.empty?

  Gitlab::Git::WikiFile.new(blobs.first)
end

#find_page(title, version = nil, load_content: true) ⇒ Object

Finds a page within the repository based on a title or slug.

title - The human readable or parameterized title of

the page.

Returns an initialized WikiPage instance or nil



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
 
# File 'app/models/wiki.rb', line 256

def find_page(title, version = nil, load_content: true)
  return unless title.present?

  capture_git_error(:find, response_on_error: nil) do
    create_wiki_repository unless repository_exists?

    version = version.presence || default_branch
    path = find_matched_file(title, version)
    next if path.blank?

    path = Gitlab::EncodingHelper.encode_utf8_no_detect(path)
    blob_options = load_content ? {} : { limit: 0 }
    blob = repository.blob_at(version, path, **blob_options)
    commit = repository.commit(blob.commit_id)
    format = find_page_format(path)

    page = Gitlab::Git::WikiPage.new(
      url_path: strip_extension(path),
      title: canonicalize_filename(path),
      format: format,
      path: path,
      raw_data: blob.data,
      name: canonicalize_filename(path),
      historical: version == default_branch ? false : check_page_historical(path, commit),
      version: Gitlab::Git::WikiPageVersion.new(commit, format)
    )
    WikiPage.new(self, page)
  end
end

#find_sidebar(version = nil) ⇒ Object 



286
287
288
 
# File 'app/models/wiki.rb', line 286

def find_sidebar(version = nil)
  find_page(SIDEBAR, version)
end

#full_path ⇒ Object Also known as: path_with_namespace 



407
408
409
 
# File 'app/models/wiki.rb', line 407

def full_path
  container.full_path + '.wiki'
end

#git_garbage_collect_worker_klass ⇒ Object 



435
436
437
 
# File 'app/models/wiki.rb', line 435

def git_garbage_collect_worker_klass
  Wikis::GitGarbageCollectWorker
end

#has_home_page? ⇒ Boolean

Returns:

  • (Boolean) 


190
191
192
193
194
 
# File 'app/models/wiki.rb', line 190

def has_home_page?
  !!find_page(HOMEPAGE)
rescue StandardError
  false
end

#hashed_storage? ⇒ Boolean

Returns:

  • (Boolean)

Raises:

  • (NotImplementedError) 


402
403
404
 
# File 'app/models/wiki.rb', line 402

def hashed_storage?
  raise NotImplementedError
end

#hook_attrs ⇒ Object 



383
384
385
386
387
388
389
390
391
 
# File 'app/models/wiki.rb', line 383

def hook_attrs
  {
    web_url: web_url,
    git_ssh_url: ssh_url_to_repo,
    git_http_url: http_url_to_repo,
    path_with_namespace: full_path,
    default_branch: default_branch
  }
end

#id ⇒ Object

This is needed in:

  • Storage::Hashed

  • Gitlab::Repositories::RepoType#identifier_for_container

We also need an #id to support build_stubbed in tests, where the value doesn’t matter.

NOTE: Wikis don’t have a DB record, so this ID can be the same for two wikis in different containers and should not be expected to be unique. Use to_global_id instead if you need a unique ID.



167
168
169
 
# File 'app/models/wiki.rb', line 167

def id
  container.id
end

#list_pages(direction: DIRECTION_ASC, load_content: false, size_limit: Gitlab::Git::Blob::MAX_DATA_DISPLAY_SIZE, limit: 0, offset: 0) ⇒ Object

Lists wiki pages of the repository.

limit - max number of pages returned by the method. sort - criterion by which the pages are sorted. direction - order of the sorted pages. load_content - option, which specifies whether the content inside the page

will be loaded.

Returns an Array of GitLab WikiPage instances or an empty Array if this Wiki has no pages.



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
 
# File 'app/models/wiki.rb', line 216

def list_pages(
  direction: DIRECTION_ASC,
  load_content: false,
  size_limit: Gitlab::Git::Blob::MAX_DATA_DISPLAY_SIZE,
  limit: 0,
  offset: 0
)
  capture_git_error(:list, response_on_error: []) do
    create_wiki_repository unless repository_exists?

    paths = list_page_paths(limit: limit, offset: offset)
    next [] if paths.empty?

    pages = paths.map do |path|
      page = Gitlab::Git::WikiPage.new(
        url_path: strip_extension(path),
        title: canonicalize_filename(path),
        format: find_page_format(path),
        path: path,
        raw_data: '',
        name: canonicalize_filename(path),
        historical: false
      )
      WikiPage.new(self, page)
    end
    sort_pages!(pages, direction)
    pages = pages.take(limit) if limit > 0
    fetch_pages_content!(pages, size_limit: size_limit) if load_content

    pages
  end
end

#page_title_and_dir(title) ⇒ Object 



375
376
377
378
379
380
381
 
# File 'app/models/wiki.rb', line 375

def page_title_and_dir(title)
  return unless title

  title_array = title.split("/")
  title = title_array.pop
  [title, title_array.join("/")]
end

#path ⇒ Object 



171
172
173
 
# File 'app/models/wiki.rb', line 171

def path
  container.path + '.wiki'
end

#repository ⇒ Object 



394
395
396
 
# File 'app/models/wiki.rb', line 394

def repository
  @repository ||= Gitlab::GlRepository::WIKI.repository_for(self)
end

#repository_storage ⇒ Object

Raises:

  • (NotImplementedError) 


398
399
400
 
# File 'app/models/wiki.rb', line 398

def repository_storage
  raise NotImplementedError
end

#update_page(page, content:, title: nil, format: :markdown, message: nil) ⇒ Object 



331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
 
# File 'app/models/wiki.rb', line 331

def update_page(page, content:, title: nil, format: :markdown, message: nil)
  with_valid_format(format) do |default_extension|
    title = title.presence || Pathname(page.path).sub_ext('').to_s

    # If the format is the same we keep the former extension. This check is for formats
    # that can have more than one extension like Markdown (.md, .markdown)
    # If we don't do this we will override the existing extension.
    extension = page.format != format.to_sym ? default_extension : File.extname(page.path).downcase[1..]

    capture_git_error(:updated) do
      create_wiki_repository unless repository_exists?
      sanitized_path = sluggified_full_path(title, extension)
      options = multi_commit_options(:updated, message, title)
      new_url_path = sluggified_title(title)
      branch = repository.root_ref || default_branch
      actions =
        repository.update_file_actions(sanitized_path, content, previous_path: page.path) +
        repository.move_dir_files_actions(new_url_path, page.url_path, branch_name: branch) +
        update_redirection_actions(new_url_path, page.url_path)

      repository.commit_files(user, **options.merge(actions: actions))

      after_wiki_activity

      true
    rescue Gitlab::Git::Index::IndexError
      duplicated_page_error(sanitized_path)
    end
  end
end

#wiki_base_path ⇒ Object 



421
422
423
 
# File 'app/models/wiki.rb', line 421

def wiki_base_path
  web_url(only_path: true).sub(%r{/#{Wiki::HOMEPAGE}\z}o, '')
end