class Gollum::Markup

Attributes

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

Public Class Methods

extensions() click to toggle source
# File lib/gollum-lib/markup.rb, line 38
def extensions
  @extensions
end
formats() click to toggle source

Only use the formats that are specified in config.rb

# File lib/gollum-lib/markup.rb, line 30
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 87
def initialize(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.url_path}")
  @metadata    = nil
end
register(ext, name, options = {}, &block) click to toggle source

Register a file format

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

extensions - Array of valid file extensions, for instance ['md']
enabled - Whether the markup is enabled

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

# File lib/gollum-lib/markup.rb, line 52
      def register(ext, name, options = {}, &block)
        if options[:regexp] then
          STDERR.puts <<-EOS
          Warning: attempted to register a markup (name: #{name.to_s}) by passing the deprecated :regexp option.
          Please pass an Array of valid file extensions (:extensions => ['ext1', 'ext2']) instead.
          EOS
        end
        new_extension = options.fetch(:extensions, [ext.to_s])
        @formats[ext] = { :name => name,
          :extensions => new_extension,
          :reverse_links => options.fetch(:reverse_links, false),
          :skip_filters => options.fetch(:skip_filters, nil),
          :enabled => options.fetch(:enabled, true) }
        @extensions.concat(new_extension)
      end
to_xml_opts() click to toggle source
# File lib/gollum-lib/markup.rb, line 25
def to_xml_opts
  { :save_with => Nokogiri::XML::Node::SaveOptions::DEFAULT_XHTML ^ 1, :indent => 0, :encoding => 'UTF-8' }
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 171
def check_cache(type, id)
end
process_chain(data, filter_chain) { |parse| ... } 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 122
def process_chain(data, filter_chain)
  # First we extract the data through the chain...
  filter_chain.each do |filter|
    data = filter.extract(data)
  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
  yield Nokogiri::HTML::DocumentFragment.parse(data) if block_given?

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

  data
end
render(no_follow = false, encoding = nil, include_levels = 10, &block) click to toggle source

Render the content with Gollum wiki syntax on top of the file's own markup language. Takes an optional block that will be executed after the markup rendering step in the filter chain.

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 150
def render(no_follow = false, encoding = nil, include_levels = 10, &block)
  @historical     = no_follow
  @encoding       = encoding
  @include_levels = include_levels

  data = @data.dup

  filter_chain = @wiki.filter_chain.reject {|filter| skip_filter?(filter)}
  filter_chain.map! do |filter_sym|
    Gollum::Filter.const_get(filter_sym).new(self)
  end

  process_chain(data, filter_chain, &block)
end
skip_filter?(filter) click to toggle source

Whether or not a particular filter should be skipped for this format.

# File lib/gollum-lib/markup.rb, line 106
def skip_filter?(filter)
  if self.class.formats[@format][:skip_filters].respond_to?(:include?)
    self.class.formats[@format][:skip_filters].include?(filter)
  elsif self.class.formats[@format][:skip_filters].respond_to?(:call)
    self.class.formats[@format][:skip_filters].call(filter)
  else
    false
  end
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 181
def update_cache(type, id, data)
end