class Kramdown::Converter::Base

Have a look at the Base::convert method for additional information!
converters do the transformation.
method per element type is a straight forward way to do it - this is how the Html and Latex
The actual transformation of the document tree can be done in any way. However, writing one
code for converting an element and has to return the conversion result.
properly). Then you need to implement the #convert method which has to contain the conversion
it in the Kramdown::Converter module (the latter is only needed if auto-detection should work
Implementing a new converter is rather easy: just derive a new class from this class and put
== Implementing a converter
directly but only use the Base::convert method.
state information during conversion. Therefore one can’t instantiate a converter object
A converter object is used as a throw-away object, i.e. it is only used for storing the needed
automatically applied to the result (for example, embedding the output into a template).
used by all converters (like #generate_id) as well as common functionality that is
This class serves as base class for all converters. It provides methods that can/should be
== Base class for converters

def self.apply_template(converter, body) # :nodoc:

:nodoc:
Apply the +template+ using +body+ as the body string. 
def self.apply_template(converter, body) # :nodoc:
  erb = ERB.new(get_template(converter.options[:template]))
  obj = Object.new
  obj.instance_variable_set(:@converter, converter)
  obj.instance_variable_set(:@body, body)
  erb.result(obj.instance_eval{binding})
end

def self.convert(tree, options = {})

directory.
3. Append +.convertername+ to the template name and look for it in the kramdown data

file in the current working directory.
2. Append +.convertername+ (e.g. +.html+) to the template name and look for the resulting

1. Look in the current working directory for the template.

rendered into the specified template. The template resolution is done in the following way:
+tree+ as parameter. If the +template+ option is specified and non-empty, the result is
Initializes a new instance of the calling class and then calls the #convert method with

options that should be used.
string) and an array with warning messages. The parameter +options+ specifies the conversion
Convert the element tree +tree+ and return the resulting conversion object (normally a 
def self.convert(tree, options = {})
  converter = new(tree, ::Kramdown::Options.merge(options.merge(tree.options[:options] || {})))
  result = converter.convert(tree)
  result = apply_template(converter, result) if !converter.options[:template].empty?
  result.encode!(tree.options[:encoding]) if result.respond_to?(:encode!)
  [result, converter.warnings]
end

def self.get_template(template) # :nodoc:

:nodoc:
Return the template specified by +template+. 
def self.get_template(template) # :nodoc:
  format_ext = '.' + self.name.split(/::/).last.downcase
  shipped = File.join(::Kramdown.data_dir, template + format_ext)
  if File.exist?(template)
    File.read(template)
  elsif File.exist?(template + format_ext)
    File.read(template + format_ext)
  elsif File.exist?(shipped)
    File.read(shipped)
  else
    raise "The specified template file #{template} does not exist"
  end
end

def convert(el)

This is the only method that has to be implemented by sub-classes!

Convert the element +el+ and return the resulting object. 
def convert(el)
  raise NotImplementedError
end

def extract_code_language(attr)

Extract the code block/span language from the attributes. 
def extract_code_language(attr)
  if attr['class'] && attr['class'] =~ /\blanguage-\w+\b/
    attr['class'].scan(/\blanguage-(\w+)\b/).first.first
  end
end

def extract_code_language!(attr)

*Warning*: This version will modify the given attributes if a language is present.

See #extract_code_language 
def extract_code_language!(attr)
  lang = extract_code_language(attr)
  attr['class'] = attr['class'].sub(/\blanguage-\w+\b/, '').strip if lang
  attr.delete('class') if lang && attr['class'].empty?
  lang
end

def generate_id(str)

ID.
Uses the option +auto_id_prefix+: the value of this option is prepended to every generated

Generate an unique alpha-numeric ID from the the string +str+ for use as a header ID. 
def generate_id(str)
  str = ::Kramdown::Utils::Unidecoder.decode(str) if @options[:transliterated_header_ids]
  gen_id = str.gsub(/^[^a-zA-Z]+/, '')
  gen_id.tr!('^a-zA-Z0-9 -', '')
  gen_id.tr!(' ', '-')
  gen_id.downcase!
  gen_id = 'section' if gen_id.length == 0
  @used_ids ||= {}
  if @used_ids.has_key?(gen_id)
    gen_id += '-' << (@used_ids[gen_id] += 1).to_s
  else
    @used_ids[gen_id] = 0
  end
  @options[:auto_id_prefix] + gen_id
end

def in_toc?(el)

specified by the +toc_levels+ option).
Return +true+ if the header element +el+ should be used for the table of contents (as 
def in_toc?(el)
  @options[:toc_levels].include?(el.options[:level]) and ((not el.attr['class'].split.include?('no_toc')) rescue true)
end

def initialize(root, options)

Initialize the converter with the given +root+ element and +options+ hash. 
def initialize(root, options)
  @options = options
  @root = root
  @data = {}
  @warnings = []
end

def output_header_level(level)

Uses the +header_offset+ option for adjusting the header level.

Return the output header level given a level. 
def output_header_level(level)
  [[level + @options[:header_offset], 6].min, 1].max
end

def smart_quote_entity(el)

Return the entity that represents the given smart_quote element. 
def smart_quote_entity(el)
  res = @options[:smart_quotes][SMART_QUOTE_INDICES[el.value]]
  ::Kramdown::Utils::Entities.entity(res)
end

def warning(text)

Add the given warning +text+ to the warning array. 
def warning(text)
  @warnings << text
end