wikicloth 0.7.1 → 0.8.0

data/README.textile

@@ -1,4 +1,4 @@
-h2. WikiCloth "!https://secure.travis-ci.org/nricciar/wikicloth.png!":http://travis-ci.org/nricciar/wikicloth
+h1. WikiCloth "!https://secure.travis-ci.org/nricciar/wikicloth.png!":http://travis-ci.org/nricciar/wikicloth
 
 Ruby implementation of the MediaWiki markup language.
 
@@ -16,7 +16,7 @@ h2. Supports
 ** "Tables":https://github.com/nricciar/wikicloth/wiki/Tables 
 ** Table of Contents [<code>__NOTOC__, __FORCETOC__, __TOC__</code>]
 * <code><code>,<nowiki>,<pre></code> (disable wiki markup)
-* <ref> and <references/> support
+* <code><ref></code> and <code><references/></code> support
 * "html sanitization":https://github.com/nricciar/wikicloth/wiki/Html-Sanitization
 
 For more information about the MediaWiki markup see "http://www.mediawiki.org/wiki/Markup_spec":http://www.mediawiki.org/wiki/Markup_spec
@@ -62,7 +62,7 @@ Most features of WikiCloth can be overriden as needed...
 
   @wiki = WikiParser.new({ 
     :params => { "PAGENAME" => "Testing123" }, 
-    :data => "{{hello|world}} From {{ PAGENAME }} -- [www.google.com]&quot; 
+    :data => "{{hello|world}} From {{ PAGENAME }} -- [www.google.com]"; 
   })
 
   @wiki.to_html =>

data/Rakefile

@@ -1,3 +1,4 @@
+require 'rubygems'
 require 'rake'
 require File.join(File.dirname(__FILE__),'init')
 
@@ -10,22 +11,29 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-require 'rcov/rcovtask'
-Rcov::RcovTask.new do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
+if RUBY_VERSION =~ /^1\.9/
+  require 'simplecov'
+  desc "Code coverage detail"
+  task :simplecov do
+    ENV['COVERAGE'] = "true"
+    Rake::Task['spec'].execute
+  end
+else
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
 end
 
 task :default => :test
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "wikicloth #{version}"
+  rdoc.title = "wikicloth #{WikiCloth::VERSION}"
   rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('LICENSE')
+  rdoc.rdoc_files.include('MIT-LICENSE')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/lang/de.yml

@@ -0,0 +1,24 @@
+:de:
+  namespaces:
+    media: "Medium"
+    file: "Datei"
+    category: "Kategorie"
+    template: "Vorlage"
+    special: "Spezial"
+    talk: "Diskussion"
+    help: "Hilfe"
+
+  languages:
+    en: "Englisch"
+    de: "Deutsch"
+
+  behavior_switches:
+    notoc: "KEIN_INHALTSVERZEICHNIS"
+    toc: "INHALTSVERZEICHNIS"
+    forcetoc: "INHALTSVERZEICHNIS_ERZWINGEN"
+    noeditsection: "ABSCHNITTE_NICHT_BEARBEITEN"
+    editsection: "ABSCHNITTE_BEARBEITEN"
+
+  table of contents: "Inhaltsverzeichnis"
+  edit: "Bearbeiten"
+  edit section: "Abschnitt bearbeiten: %{name}"

data/lang/en.yml

@@ -0,0 +1,35 @@
+en:
+  namespaces:
+    media: "Media"
+    file: "File,Image"
+    category: "Category"
+    special: "Special"
+    template: "Template"
+    talk: "Talk"
+    help: "Help"
+
+  languages:
+    en: "English"
+    de: "German"
+
+  behavior_switches:
+    notoc: "NOTOC"
+    toc: "TOC"
+    forcetoc: "FORCETOC"
+    noeditsection: "NOEDITSECTION"
+    editsection: "EDITSECTION"
+
+  table of contents: "Table of Contents"
+  edit: "edit"
+  edit section: "Edit section: %{name}"
+  template loop detected: "Template loop detected: {{%{tree}}}"
+  expression error: "Expression error: %{error}"
+  lang attribute is required: "lang attribute is required"
+  unknown lang: "unknown lang '%{lang}'"
+  unable to parse mathml: "Unable to parse MathML: %{error}"
+  blahtex binary not found: "%{path} binary not found"
+  unknown function: "unknown function '%{function}'"
+  lua disabled: "Lua extension not configured"
+  max lines of code: "Maximum lines of code limit reached"
+  recursion limit reached: "Recursion limit reached"
+  unknown error on line: "Unknown error on line %{line} row %{row}: %{tree}"

data/lib/wikicloth.rb

@@ -1,12 +1,20 @@
+require 'rubygems' if RUBY_VERSION < '1.9'
 require 'jcode' if RUBY_VERSION < '1.9'
-require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "core_ext")
+require 'builder'
+# if i18n gem loaded use it instead
+require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "i18n") unless defined?(I18n)
+I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks) if defined?(I18n::Backend::Simple)
+I18n.load_path += Dir[File.join(File.expand_path(File.dirname(__FILE__)), "../lang/*.yml")].collect { |f| f }
+
 require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "version")
+require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "core_ext")
+require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "namespaces")
+require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "extension")
+require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "section")
 require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "wiki_buffer")
 require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "wiki_link_handler")
 require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "parser")
-require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "section")
-require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "token")
-require File.join(File.expand_path(File.dirname(__FILE__)), "wikicloth", "lexer")
+
 String.send(:include, ExtendedString)
 
 module WikiCloth
@@ -14,6 +22,8 @@ module WikiCloth
   class WikiCloth
 
     def initialize(opt={})
+      self.options.merge!(opt)
+      self.options[:extensions] ||= []
       self.options[:link_handler] = opt[:link_handler] unless opt[:link_handler].nil?
       self.load(opt[:data],opt[:params]) unless opt[:data].nil?
       @current_line = 1
@@ -49,15 +59,13 @@ module WikiCloth
       self.params = p
     end
 
-    def sections
-      @sections ||= [Section.new]
-    end
-
     def render(opt={})
-      noedit = false
-      self.params.merge!({ 'WIKI_VERSION' => ::WikiCloth::VERSION, 'RUBY_VERSION' => RUBY_VERSION })
-      self.options = { :fast => true, :output => :html, :link_handler => self.link_handler, :params => self.params, :sections => self.sections }.merge(opt)
+      self.options = { :noedit => false, :locale => I18n.default_locale, :fast => true, :output => :html, :link_handler => self.link_handler, 
+	:params => self.params, :sections => self.sections }.merge(self.options).merge(opt)
       self.options[:link_handler].params = options[:params]
+
+      I18n.locale = self.options[:locale]
+
       data = self.sections.collect { |s| s.render(self.options) }.join
       data.gsub!(/<!--(.|\s)*?-->/,"")
       data << "\n" if data.last(1) != "\n"
@@ -83,25 +91,20 @@ module WikiCloth
         end
       rescue => err
         debug_tree = buffer.buffers.collect { |b| b.debug }.join("-->")
-        puts "Unknown error on line #{@current_line} row #{@current_row}: #{debug_tree}"
+        puts I18n.t("unknown error on line", :line => @current_line, :row => @current_row, :tree => debug_tree)
         raise err
       end
 
       buffer.eof()
-      buffer.to_s
+      buffer.send("to_#{self.options[:output]}")
     end
 
-    def add_current_char(buffer,c)
-      if c == "\n"
-        @current_line += 1
-        @current_row = 1
-      else
-        @current_row += 1
-      end
-      buffer.add_char(c)
+    def sections
+      @sections ||= [Section.new]
     end
+
     def to_html(opt={})
-      self.render(opt)
+      self.render(opt.merge(:output => :html))
     end
 
     def link_handler
@@ -112,7 +115,29 @@ module WikiCloth
       @page_params ||= {}
     end
 
+    def options
+      @options ||= {}
+    end
+
+    def method_missing(method, *args)
+      if self.link_handler.respond_to?(method)
+        self.link_handler.send(method, *args)
+      else
+        super(method, *args)
+      end
+    end
+
     protected
+    def add_current_char(buffer,c)
+      if c == "\n"
+        @current_line += 1
+        @current_row = 1
+      else
+        @current_row += 1
+      end
+      buffer.add_char(c)
+    end
+
     def sections=(val)
       @sections = val
     end
@@ -129,10 +154,6 @@ module WikiCloth
       @options = val
     end
 
-    def options
-      @options ||= {}
-    end
-
     def params=(val)
       @page_params = val
     end

data/lib/wikicloth/core_ext.rb

@@ -38,6 +38,10 @@ module ExtendedString
     respond_to?(:empty?) ? empty? : !self
   end
 
+  def addslashes
+    self.gsub(/['"\\\x0]/,'\\\\\0');
+  end
+
   def to_slug
     self.gsub(/\W+/, '-').gsub(/^-+/,'').gsub(/-+$/,'').downcase
   end

data/lib/wikicloth/extension.rb

@@ -0,0 +1,60 @@
+module WikiCloth
+  class Extension
+
+    def initialize(options={})
+      @options = options
+    end
+
+    class << self
+
+      def html_elements
+        @@html_elements ||= {}
+      end
+
+      def functions
+        @@functions ||= {}
+      end
+
+      def element(*args,&block)
+        options  = args.last.is_a?(Hash) ? args.pop : {}
+        key      = args.shift
+
+        html_elements[key] = { :klass => self, :block => block, :options => { 
+          :skip_html => false, :run_globals => true }.merge(options) }
+      end
+
+      def skip_html?(elem)
+        return true if !element_exists?(elem)
+        html_elements[elem][:options][:skip_html]
+      end
+
+      def run_globals?(elem)
+        return false if !element_exists?(elem)
+        html_elements[elem][:options][:run_globals]
+      end
+
+      def element_exists?(elem)
+        html_elements.has_key?(elem)
+      end
+
+      def function(name,&block)
+        functions[name] = { :klass => self, :block => block }
+      end
+
+      def function_exists?(name)
+        functions.has_key?(name)
+      end
+
+      protected
+      def html_elements=(val)
+        @@html_elements = val
+      end
+
+      def functions=(val)
+        @@functions = val
+      end
+
+    end
+
+  end
+end

data/lib/wikicloth/extensions/lua.rb

@@ -0,0 +1,82 @@
+begin
+  require 'rubyluabridge'
+  DISABLE_LUA = false
+rescue LoadError
+  DISABLE_LUA = true
+end
+
+module WikiCloth
+  class LuaExtension < Extension
+
+    # <lua var1="value" ...>lua code</lua>
+    #
+    element 'lua', :skip_html => true, :run_globals => false do |buffer|
+      init_lua
+      unless @options[:disable_lua]
+        begin
+          arglist = ''
+          buffer.element_attributes.each do |key,value|
+            arglist += "#{key} = '#{value.addslashes}';"
+          end
+          lua_eval("#{arglist}\n#{buffer.element_content}").to_s
+        rescue => err
+          "<span class=\"error\">#{err.message}</span>"
+        end
+      else
+        "<!-- #{I18n.t('lua disabled')} -->"
+      end
+    end
+
+    # {{#luaexpr:lua expression}}
+    #
+    function '#luaexpr' do |params|
+      init_lua
+      unless @options[:disable_lua]
+        begin
+          lua_eval("print(#{params.first})").to_s
+        rescue => err
+          "<span class=\"error\">#{err.message}</span>"
+        end
+      else
+        "<!-- #{I18n.t('lua disabled')} -->"
+      end
+    end
+
+    protected
+    def init_lua
+      if @options[:disable_lua].nil?
+        begin
+          @options[:disable_lua] ||= DISABLE_LUA
+          lua_max_lines = @options[:lua_max_lines] || 1000000
+          lua_max_calls = @options[:lua_max_calls] || 20000
+
+          unless @options[:disable_lua]
+            @options[:luabridge] = Lua::State.new
+            @options[:luabridge].eval(File.read(File.join(File.expand_path(File.dirname(__FILE__)), "lua", "luawrapper.lua")))
+            @options[:luabridge].eval("wrap = make_wrapper(#{lua_max_lines},#{lua_max_calls})")
+          end
+        rescue
+          @options[:disable_lua] = true
+        end
+      end
+    end
+
+    def lua_eval(code)
+      @options[:luabridge]['chunkstr'] = code
+      @options[:luabridge].eval("res, err = wrap(chunkstr, env, hook)")
+      unless @options[:luabridge]['err'].nil?
+        if @options[:luabridge]['err'] =~ /LOC_LIMIT/
+          "<span class=\"error\">#{I18n.t("max lines of code")}</span>"
+        elsif @options[:luabridge]['err'] =~ /RECURSION_LIMIT/
+          "<span class=\"error\">#{I18n.t("recursion limit reached")}</span>"
+        else
+          "<span class=\"error\">#{@options[:luabridge]['err']}</span>"
+        end
+        nil
+      else
+        @options[:luabridge]['res']
+      end
+    end
+
+  end
+end

data/lib/wikicloth/extensions/lua/COPYING

@@ -0,0 +1,18 @@
+Lua parser extensions for MediaWiki
+Copyright (C) 2008 Fran Rogers
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.

data/lib/wikicloth/extensions/lua/luawrapper.lua

@@ -0,0 +1,245 @@
+-- Lua parser extensions for MediaWiki - Wrapper for Lua interpreter
+-- (c) 2008 Fran Rogers - see 'COPYING' for license
+
+-- Creates a new sandbox environment for scripts to safely run in.
+function make_sandbox()
+  -- Dummy function that returns nil, to quietly replace unsafe functions
+  local function dummy(...)
+    return nil
+  end
+
+  -- Deep-copy an object; optionally replace all its leaf members with the
+  -- value 'override' if it's non-nil
+  local function deepcopy(object, override)
+    local lookup_table = {}
+    local function _copy(object, override)
+      if type(object) ~= "table" then
+	return object
+      elseif lookup_table[object] then
+	return lookup_table[object]
+      end
+      local new_table = {}
+      lookup_table[object] = new_table
+      for index, value in pairs(object) do
+	if override ~= nil then
+	  value = override
+	end
+	new_table[_copy(index)] = _copy(value, override)
+      end
+      return setmetatable(new_table, _copy(getmetatable(object), override))
+    end
+    return _copy(object, override)
+  end
+
+  -- Our new environment
+  local env = {}
+
+  -- "_OUTPUT" will accumulate the results of print() and friends
+  env._OUTPUT = ""
+
+  -- _OUTPUT wrapper for io.write()
+  local function writewrapper(...)
+    local out = ""
+    for n = 1, select("#", ...) do
+      if out == "" then
+	out = tostring(select(n, ...))
+      else
+	out = out .. tostring(select(n, ...))
+      end
+    end
+    env._OUTPUT = env._OUTPUT .. out
+  end
+
+  -- _OUTPUT wrapper for io.stdout:output()
+  local function outputwrapper(file)
+    if file == nil then
+      local file = {}
+      file.close = dummy
+      file.lines = dummy
+      file.read = dummy
+      file.flush = dummy
+      file.seek = dummy
+      file.setvbuf = dummy
+      function file:write(...) writewrapper(...); end
+      return file
+    else
+      return nil
+    end
+  end
+
+  -- _OUTPUT wrapper for print()
+  local function printwrapper(...)
+    local out = ""
+    for n = 1, select("#", ...) do
+      if out == "" then
+	out = tostring(select(n, ...))
+      else
+	out = out .. '\t' .. tostring(select(n, ...))
+      end
+    end
+    env._OUTPUT =env._OUTPUT .. out .. "\n"
+  end
+
+  -- Safe wrapper for loadstring()
+  local oldloadstring = loadstring
+  local function safeloadstring(s, chunkname)
+    local f, message = oldloadstring(s, chunkname)
+    if not f then
+      return f, message
+    end
+    setfenv(f, getfenv(2))
+    return f
+  end
+
+  -- Populate the sandbox environment
+  env.assert = _G.assert
+  env.error = _G.error
+  env._G = env
+  env.ipairs = _G.ipairs
+  env.loadstring = safeloadstring
+  env.next = _G.next
+  env.pairs = _G.pairs
+  env.pcall = _G.pcall
+  env.print = printwrapper
+  env.write = writewrapper
+  env.select = _G.select
+  env.tonumber = _G.tonumber
+  env.tostring = _G.tostring
+  env.type = _G.type
+  env.unpack = _G.unpack
+  env._VERSION = _G._VERSION
+  env.xpcall = _G.xpcall
+  env.coroutine = deepcopy(_G.coroutine)
+  env.string = deepcopy(_G.string)
+  env.string.dump = nil
+  env.table = deepcopy(_G.table)
+  env.math = deepcopy(_G.math)
+  env.io = {}
+  env.io.write = writewrapper
+  env.io.flush = dummy
+  env.io.type = typewrapper
+  env.io.output = outputwrapper
+  env.io.stdout = outputwrapper()
+  env.os = {}
+  env.os.clock = _G.os.clock
+  -- env.os.date = _G.os.date
+  env.os.difftime = _G.os.difftime
+  env.os.time = _G.os.time
+
+  -- Return the new sandbox environment
+  return env
+end
+
+-- Creates a new debug hook that aborts with 'error("LOC_LIMIT")' after 
+-- 'maxlines' lines have been passed, or 'error("RECURSION_LIMIT")' after 
+-- 'maxcalls' levels of recursion have been entered.
+function make_hook(maxlines, maxcalls, diefunc)
+  local lines = 0
+  local calls = 0
+  function _hook(event, ...)
+    if event == "line" then
+      lines = lines + 1
+      if lines > maxlines then
+	error("LOC_LIMIT")
+      end
+    elseif event == "call" then
+      calls = calls + 1
+      if calls > maxcalls then
+	error("RECURSION_LIMIT")
+      end
+    elseif event == "return" then
+      calls = calls - 1
+    end
+  end
+  return _hook
+end
+
+-- Creates and returns a function, 'wrap(input)', which reads a string into 
+-- a Lua chunk and executes it in a persistent sandbox environment, returning 
+-- 'output, err' where 'output' is the combined output of print() and friends 
+-- from within the chunk and 'err' is either nil or an error incurred while 
+-- executing the chunk; or halting after 'maxlines' lines or 'maxcalls' levels 
+-- of recursion.
+function make_wrapper(maxlines, maxcalls)
+  -- Create the debug hook and sandbox environment.
+  local hook = make_hook(maxlines, maxcalls)
+  local env = make_sandbox()
+  
+  -- The actual 'wrap()' function.
+  -- All of the above variables will be bound in its closure.
+  function _wrap(chunkstr)
+    local chunk, err, done
+    -- Clear any leftover output from the last call
+    env._OUTPUT = ""
+    err = nil
+    
+    -- Load the string into a chunk; fail on error
+    chunk, err = loadstring(chunkstr)
+    if err ~= nil then
+      return nil, err
+    end
+    
+    -- Set the chunk's environment, enable the debug hook, and execute it
+    setfenv(chunk, env)
+    co = coroutine.create(chunk)
+    debug.sethook(co, hook, "crl")
+    done, err = coroutine.resume(co)
+    
+    if done == true then
+      err = nil
+    end
+    
+    -- Collect and return the results
+    return env._OUTPUT, err
+  end
+  return _wrap
+end
+
+-- Listen on stdin for Lua chunks, parse and execute them, and print the 
+-- results of each on stdout.
+function main(arg)
+  if #arg ~= 2 then
+    io.stderr:write(string.format("usage: %s MAXLINES MAXCALLS\n", arg[0]))
+    os.exit(1)
+  end
+
+  -- Create a wrapper function, wrap()
+  local wrap = make_wrapper(tonumber(arg[1]), tonumber(arg[2]))
+
+  -- Turn off buffering, and loop through the input
+  io.stdout:setvbuf("no")
+  while true do
+    -- Read in a chunk
+    local chunkstr = ""
+    while true do
+      local line = io.stdin:read("*l")
+      if chunkstr == "" and line == nil then
+	-- On EOF, exit.
+	os.exit(0)
+      elseif line == "." or line == nil then
+	-- Finished this chunk; move on to the next step
+	break
+      elseif chunkstr ~= "" then
+	chunkstr = chunkstr .. "\n" .. line
+      else
+	chunkstr = line
+      end
+    end
+
+    -- Parse and execute the chunk
+    local res, err
+    res, err = wrap(chunkstr, env, hook)
+
+    -- Write out the results
+    if err == nil then
+      io.stdout:write("'", res, "', true\n.\n")
+    else
+      io.stdout:write("'", err, "', false\n.\n")
+    end
+  end
+end
+
+-- If called as a script instead of imported as a library, run main().
+if arg ~= nil then
+  main(arg)
+end