class Gollum::Markup

Attributes

dir[R]
encoding[R]
format[R]
include_levels[R]
metadata[RW]
name[R]
page[R]
parent_page[R]
sanitize[R]
sub_page[R]
to_xml_opts[R]
toc[RW]
wiki[R]

Public Class Methods

formats() click to toggle source

Only use the formats that are specified in config.rb

# File lib/gollum-lib/markup.rb, line 26
def formats
  if defined? Gollum::Page::FORMAT_NAMES
    @formats.select { |_, value| Gollum::Page::FORMAT_NAMES.values.include? value[:name] }
  else
    @formats
  end
end
new(page) click to toggle source

Initialize a new Markup object.

page - The Gollum::Page.

Returns a new Gollum::Markup object, ready for rendering.

# File lib/gollum-lib/markup.rb, line 70
def initialize(page)
  if page
    @wiki        = page.wiki
    @name        = page.filename
    @data        = page.text_data
    @version     = page.version.id if page.version
    @format      = page.format
    @sub_page    = page.sub_page
    @parent_page = page.parent_page
    @page        = page
    @dir         = ::File.dirname(page.path)
  end
  @metadata    = nil
  @to_xml_opts = { :save_with => Nokogiri::XML::Node::SaveOptions::DEFAULT_XHTML ^ 1, :indent => 0, :encoding => 'UTF-8' }
end
register(ext, name, options = {}, &block) click to toggle source

Register a file extension and associated markup type

ext - The file extension name - The name of the markup type options - Hash of options:

regexp - Regexp to match against.
         Defaults to exact match of ext.

If given a block, that block will be registered with GitHub::Markup to render any matching pages

# File lib/gollum-lib/markup.rb, line 44
def register(ext, name, options = {}, &block)
  @formats[ext] = { :name => name,
    :regexp => options.fetch(:regexp, Regexp.new(ext.to_s)),
    :reverse_links => options.fetch(:reverse_links, false) }
end

Public Instance Methods

check_cache(type, id) click to toggle source

Hook for getting the formatted value of extracted tag data.

type - Symbol value identifying what type of data is being extracted. id - String SHA1 hash of original extracted tag data.

Returns the String cached formatted data, or nil.

# File lib/gollum-lib/markup.rb, line 187
def check_cache(type, id)
end
find_file(name, version=@version) click to toggle source

Find the given file in the repo.

name - The String absolute or relative path of the file.

Returns the Gollum::File or nil if none was found.

# File lib/gollum-lib/markup.rb, line 172
def find_file(name, version=@version)
  if name =~ /^\//
    @wiki.file(name[1..-1], version)
  else
    path = @dir == '.' ? name : ::File.join(@dir, name)
    @wiki.file(path, version)
  end
end
process_chain(data, filter_chain) click to toggle source

Process the filter chain

data - the data to send through the chain filter_chain - the chain to process

Returns the formatted data

# File lib/gollum-lib/markup.rb, line 117
def process_chain(data, filter_chain)
  # First we extract the data through the chain...
  filter_chain.each do |filter|
    data = filter.extract(data)
  end

  # Then we process the data through the chain *backwards*
  filter_chain.reverse.each do |filter|
    data = filter.process(data)
  end

  # Finally, a little bit of cleanup, just because
  data.gsub!(/<p><\/p>/) do
    ''
  end

  data
end
render(no_follow = false, encoding = nil, include_levels = 10) { |parse| ... } click to toggle source

Render the content with Gollum wiki syntax on top of the file's own markup language.

no_follow - Boolean that determines if rel=“nofollow” is added to all

<a> tags.

encoding - Encoding Constant or String.

Returns the formatted String content.

# File lib/gollum-lib/markup.rb, line 144
def render(no_follow = false, encoding = nil, include_levels = 10)
  @sanitize = no_follow ?
      @wiki.history_sanitizer :
      @wiki.sanitizer

  @encoding       = encoding
  @include_levels = include_levels

  data         = @data.dup
  filter_chain = @wiki.filter_chain.map do |r|
    Gollum::Filter.const_get(r).new(self)
  end

  # Since the last 'extract' action in our chain *should* be the markup
  # to HTML converter, we now have HTML which we can parse and yield, for
  # anyone who wants it
  if block_given?
    yield Nokogiri::HTML::DocumentFragment.parse(data)
  end

  process_chain data, filter_chain
end
render_default(data, format=:markdown, name='render_default.md') click to toggle source

Render data using default chain in the target format.

data - the data to render format - format to use as a symbol name - name using the extension of the format

Returns the processed data

# File lib/gollum-lib/markup.rb, line 97
def render_default(data, format=:markdown, name='render_default.md')
  # set instance vars so we're able to render data without a wiki or page.
  @format = format
  @name   = name

  chain = [:Metadata, :PlainText, :Emoji, :TOC, :RemoteCode, :Code, :Sanitize, :WSD, :Tags, :Render]

  filter_chain = chain.map do |r|
    Gollum::Filter.const_get(r).new(self)
  end

  process_chain data, filter_chain
end
update_cache(type, id, data) click to toggle source

Hook for caching the formatted value of extracted tag data.

type - Symbol value identifying what type of data is being extracted. id - String SHA1 hash of original extracted tag data. data - The String formatted value to be cached.

Returns nothing.

# File lib/gollum-lib/markup.rb, line 197
def update_cache(type, id, data)
end