active4d

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

all_hallows_eve

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

amy

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

blackboard

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

brilliance_black

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

brilliance_dull

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

cobalt

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

dawn

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

eiffel

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

espresso_libre

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

idle

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

iplastic

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

lazy

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

mac_classic

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

magicwb_amiga

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

pastels_on_dark

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

slush_poppies

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

spacecadet

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

sunburst

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

twilight

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end

zenburnesque

   1  module Uv
   2     def Uv.parse text, output = "xhtml", syntax_name = nil, line_numbers = false, render_style = "classic"
   3        init_syntaxes unless @syntaxes
   4        renderer = File.join( File.dirname(__FILE__), '..',"render", output,"#{render_style}.render")
   5        css_class = render_style
   6        render_options = YAML.load( File.open(  renderer ) )
   7        if output == "xhtml"
   8           render_processor = HtmlProcessor.new( render_options, line_numbers )
   9           @syntaxes[syntax_name].parse( text,  render_processor )
  10           "<pre class =\"#{css_class}\">#{render_processor.string}</pre>"
  11        else
  12           raise( ArgumentError, "Output for #{output} is not yet implemented" )
  13        end
  14     end
  15  end