ruwiki 0.9.0

data/lib/ruwiki/utils/servletrunner.rb

@@ -0,0 +1,295 @@
+#!/usr/bin/env ruby
+#--
+# Ruwiki
+#   Copyright � 2002 - 2004, Digikata and HaloStatue
+#   Alan Chen (alan@digikata.com)
+#   Austin Ziegler (ruwiki@halostatue.ca)
+#
+# Licensed under the same terms as Ruby.
+#
+# This file may be renamed to change the URI for the wiki.
+#
+# $Id: servletrunner.rb,v 1.8 2004/11/26 12:18:47 austin Exp $
+#++
+
+  # Customize this if you put the RuWiki files in a different location.
+require 'webrick'
+
+require 'ruwiki/utils'
+require 'ruwiki/exportable'
+require 'ruwiki/servlet'
+require 'ruwiki/lang/en'
+require 'ruwiki/lang/de'
+require 'ruwiki/lang/es'
+
+require 'optparse'
+require 'ostruct'
+
+module Ruwiki::Utils::ServletRunner
+  COPYRIGHT = <<-"COPYRIGHT"
+Ruwiki #{Ruwiki::VERSION}
+  Copyright � 2002 - 2004, Digikata and HaloStatue
+
+  http://rubyforge.org/projects/ruwiki/
+
+  Alan Chen (alan@digikata.com)
+  Austin Ziegler (ruwiki@halostatue.ca)
+
+Licensed under the same terms as Ruby.
+
+$Id: servletrunner.rb,v 1.8 2004/11/26 12:18:47 austin Exp $
+COPYRIGHT
+
+  class WEBrickConfig
+    include Ruwiki::Exportable
+
+    exportable_group 'webrick-config'
+    attr_accessor :port
+    exportable    :port
+    attr_accessor :addresses
+    exportable    :addresses
+    attr_accessor :mount
+    exportable    :mount
+    attr_accessor :do_log
+    exportable    :do_log
+    attr_accessor :log_dest
+    exportable    :log_dest
+    attr_accessor :threads
+    exportable    :threads
+
+    def export
+      hash = super
+      sc = hash['webrick-config']
+      sc['addresses'] = sc['addresses'].join(";")
+      sc['do-log']    = (sc['do-log'] ? 'true' : 'false')
+      hash
+    end
+
+      # Because the servlet can be started from the command-line, provide
+      # defaults for all possible configuration options.
+    def initialize(exported = {})
+      sc = exported['webrick-config'] || {}
+      @port         = sc['port']      || 8808
+      @mount        = sc['mount']     || '/'
+      @addresses    = sc['addresses']
+      @do_log       = ((sc['do-log'] == 'false') ? false : true)
+      @log_dest     = sc['log-dest']
+      @threads      = sc['threads']   || 1
+
+      if @addresses.nil? or @addresses.empty?
+        @addresses  = []
+      else
+        @addresses  = @addresses.split(/;/)
+      end
+
+      if @log_dest.nil? or @log_dest.empty?
+        @log_dest   = "<STDERR>"
+      end
+    end
+  end
+
+  def self.message=(lang)
+    if lang.kind_of?(Hash)
+      @message = lang
+    elsif "constant" == defined?(lang::Message)
+      @message = lang::Message
+    else
+      raise ArgumentError
+    end
+  end
+  def self.message(id)
+    @message[id]
+  end
+
+  class << self
+      # This is for the WEBrick version of Ruwiki. This has been abstracted to
+      # accept a Config global variable to reconfigure Ruwiki after initial
+      # creation.
+    def read_config(filename)
+      ch = {}
+      if File.exists?(filename)
+        File.open(filename, 'rb') { |ff| ch = Ruwiki::Exportable.load(ff.read) }
+      end
+
+      @sc = WEBrickConfig.new(ch)
+      @rc = Ruwiki::Config.new(ch)
+
+      if @rc.webmaster.nil? or @rc.webmaster.empty?
+        @rc.webmaster = "webmaster@domain.tld"
+      end
+    end
+
+    def run(argv, input = $stdin, output = $stdout, error = $stderr)
+      read_config(Ruwiki::Config::CONFIG_NAME)
+
+      save_config = nil
+
+      language = 'en'
+      find_lang = argv.grep(%r{^--language})
+      find_lang.each do |ee|
+        if ee =~ %r{^--language=}
+          language = ee.sub(%r{^--language=}, '')
+        else
+          language = argv[argv.index(ee).succ]
+        end
+      end
+
+      require "ruwiki/lang/#{language.downcase}"
+      @rc.language = Ruwiki::Lang.const_get(language.upcase)
+      self.message = @rc.language
+
+      argv.options do |oo|
+        oo.banner = self.message(:runner_usage) % [ File.basename($0) ]
+        oo.separator self.message(:runner_general_options)
+        oo.on('--save-config [FILENAME]', *([ self.message(:runner_saveconfig_desc), Ruwiki::Config::CONFIG_NAME ].flatten)) { |fname|
+          save_config = fname || Ruwiki::Config::CONFIG_NAME
+        }
+        oo.on('--config FILENAME', *self.message(:runner_config_desc)) { |fn|
+          read_config(fn)
+        }
+        oo.separator ""
+        oo.separator self.message(:runner_webrick_options)
+        oo.on('-P', '--port PORT', Numeric, *self.message(:runner_port_desc)) { |port|
+          @sc.port = port
+        }
+        oo.on('-A', '--accept ADDRESS,ADDRESS,ADDRESS', Array, *self.message(:runner_address_desc)) { |address|
+          @sc.addresses += address
+        }
+        oo.on('-L', '--local', *self.message(:runner_local_desc)) {
+          @sc.addresses = ["127.0.0.1"]
+        }
+        oo.on('-M', '--mount MOUNT-POINT', *self.message(:runner_mountpoint_desc)) { |mp|
+          @sc.mount = mp
+        }
+        oo.on('--[no-]log', *self.message(:runner_log_desc)) { |log|
+          @sc.do_log = log
+        }
+        oo.on('--logfile LOGFILE', *self.message(:runner_logfile_desc)) { |lf|
+          @sc.log_dest = lf
+        }
+        oo.on('-T', '--threads THREADS', Integer, *self.message(:runner_threads_desc)) { |tc|
+          @sc.threads = tc
+        }
+        oo.separator ""
+        oo.separator self.message(:runner_ruwiki_options)
+        oo.on('--language=LANGUAGE', *self.message(:runner_language_desc)) { |lang|
+          nil
+        }
+        oo.on('--webmaster WEBMASTER', *self.message(:runner_webmaster_desc)) { |wm|
+          @rc.webmaster = wm
+        }
+        oo.on('--[no-]debug', *self.message(:runner_debug_desc)) { |dd|
+          @rc.debug = dd
+        }
+        oo.on('--title TITLE', *self.message(:runner_title_desc)) { |tt|
+          @rc.title = tt
+        }
+        oo.on('--default-page PAGENAME', *self.message(:runner_defaultpage_desc)) { |dp|
+          @rc.default_page = dp
+        }
+        oo.on('--default-project PAGENAME', *self.message(:runner_defaultproject_desc)) { |dp|
+          @rc.default_project = dp
+        }
+        oo.on('--template-path TEMPLATE_PATH', *self.message(:runner_templatepath_desc)) { |tp|
+          @rc.template_path = tp
+        }
+        oo.on('--templates TEMPLATES', *self.message(:runner_templatename_desc)) { |tp|
+          @rc.template_set = tp
+        }
+        oo.on('--css CSS_NAME', *self.message(:runner_cssname_desc)) { |css|
+          @rc.css = css
+        }
+        oo.on('--storage-type TYPE', Ruwiki::KNOWN_BACKENDS, *([self.message(:runner_storage_desc), Ruwiki::KNOWN_BACKENDS.join(", ")].flatten)) { |st|
+          @rc.storage_type = st
+          @rc.storage_options[@rc.storage_type]['data-path'] ||= "./data/"
+          @rc.storage_options[@rc.storage_type]['extension'] ||= "ruwiki"
+        }
+        oo.on('--data-path PATH', *self.message(:runner_datapath_desc)) { |fdp|
+          @rc.storage_options['flatfiles']['data-path'] = fdp
+        }
+        oo.on('--extension EXT', *self.message(:runner_extension_desc)) { |ext|
+          @rc.storage_options['flatfiles']['data-path'] = fdp
+        }
+        if defined?(Gem::Cache)
+          oo.separator ""
+          oo.on('--central', *self.message(:runner_central_desc)) {
+            gempath = Gem::Cache.from_installed_gems.search("ruwiki", "=#{Ruwiki::VERSION}").last.full_gem_path
+            @rc.storage_type    = 'flatfiles'
+            @rc.storage_options['flatfiles']['data-path'] = "#{gempath}/data"
+            @rc.storage_options['flatfiles']['extension'] = "ruwiki"
+            @rc.storage_options['flatfiles']['format'] = "exportable"
+            @rc.template_path   = "#{gempath}/templates"
+            @rc.template_set    = "sidebar"
+          }
+        end
+
+          # TODO: Add options for time, date, and datetime formats.
+        oo.separator ""
+        oo.separator self.message(:runner_general_info)
+        oo.on_tail('--help', *self.message(:runner_help_desc)) {
+          error << oo << "\n"
+          return 0
+        }
+        oo.on_tail('--version', *self.message(:runner_version_desc)) {
+          error << COPYRIGHT << "\n"
+          return 0
+        }
+        oo.parse!
+      end
+
+      if save_config
+        sc = @sc.export
+        rc = @rc.export
+        cf = sc.merge(rc)
+
+        File.open(save_config, 'wb') { |ff| ff.puts Ruwiki::Exportable.dump(cf) }
+        return 0
+      end
+
+        # If the list of accepted addresses is not empty, provide IP-based
+        # restrictions.
+      if not @sc.addresses.empty?
+        localonly = lambda do |sock|
+          if not @sc.addresses.include?(sock.peeraddr[3])
+            raise WEBrick::ServerError, self.message(:runner_rejected_address) % [ sock.peeraddr[3], @sc.addresses.join(", ") ]
+          end
+        end
+      else
+        localonly = nil
+      end
+
+      if @sc.do_log
+        if "<STDERR>" == @sc.log_dest
+          dest = $stderr
+        else
+          dest = File.open(@sc.log_dest, "wb+")
+        end
+        logger = WEBrick::Log.new(dest, WEBrick::Log::DEBUG)
+      else
+        logger = nil
+      end
+
+      banner = self.message(:runner_banner) %
+        [ Ruwiki::Utils::ServletRunner::COPYRIGHT, @sc.port,
+          @sc.addresses.join(", "), @sc.mount, @sc.do_log, @sc.log_dest,
+          @sc.threads, @rc.webmaster, @rc.debug, @rc.title,
+          @rc.default_project, @rc.default_page, @rc.template_path,
+          @rc.template_set, @rc.css, @rc.storage_type,
+          @rc.storage_options[@rc.storage_type]['data-path'],
+          @rc.storage_options[@rc.storage_type]['extension'] ]
+
+      banner.each { |bb| logger.info(bb) } unless logger.nil?
+
+      server = WEBrick::HTTPServer.new(:Port            => @sc.port.to_i,
+                                       :StartThreads    => @sc.threads.to_i,
+                                       :AcceptCallback  => localonly,
+                                       :Logger          => logger)
+      @rc.logger = logger
+      Ruwiki::Servlet.config = @rc
+
+      server.mount(@sc.mount, Ruwiki::Servlet)
+      trap("INT") { server.shutdown; return }
+      server.start
+    end
+  end
+end

data/lib/ruwiki/wiki.rb

@@ -0,0 +1,147 @@
+#--
+# Ruwiki
+#   Copyright � 2002 - 2004, Digikata and HaloStatue
+#   Alan Chen (alan@digikata.com)
+#   Austin Ziegler (ruwiki@halostatue.ca)
+#
+# Licensed under the same terms as Ruby.
+#
+# $Id: wiki.rb,v 1.14 2004/11/28 05:27:32 austin Exp $
+#++
+  # Ruwiki's Wiki markup class. This will convert the Wiki markup known by
+  # Ruwiki (defined by Token classes). The algorithm is as follows:
+  #
+  # 1.  For each known Token class, match each instance of it in the content
+  #     stream. Replace each instance in the content stream with a Token
+  #     marker: TOKEN_x or \TOKEN_x, where x is a digit representing the Token.
+  #     (\TOKEN_x is a special case of token matching. See
+  #     Ruwiki::Markup::Token for more information.) Store the Token for later
+  #     processing.
+  # 2.  Go back through the content, replacing each instance of \TOKEN_x with
+  # the Token's defined restore value (which should be the same value as was
+  # originally matched).
+  # 3.  Go through the content, replacing each instance of TOKEN_x with the
+  # Token's defined replacement value.
+  # 4.  Go through the tokens, in reverse, and execute the post replacement
+  # routine defined by the Token. (This may be necessary to collapse
+  # consecutive HTML structures.)
+  # 5.  Return the parsed content and the collected metadata.
+  #
+  # == Tokens
+  # Look at Ruwiki::Markup::Token describes how to create Token objects.
+class Ruwiki::Wiki
+  def parse(content, project)
+    content = clean(content)
+    tokens  = []
+    project ||= @default_project
+
+    Token.tokenlist.each do |token|
+      content.gsub!(token.regexp) do |mm|
+        match = Regexp.last_match
+        tc = token.new(match, project, @backend, @script, @message, @title)
+        tokens << tc
+        if mm[0, 1] == '\\'
+          "\\TOKEN_#{tokens.size - 1}"
+        else
+          "TOKEN_#{tokens.size - 1}"
+        end
+      end
+    end
+
+    replaced = []
+    ss = true
+    loop do
+      break if replaced.size >= tokens.size
+      break if ss.nil?
+      ss = content.gsub!(/\\TOKEN_(\d+)/) { |mm|
+        match   = Regexp.last_match
+        itoken  = match[1].to_i
+        replaced << itoken
+        tokens[itoken].restore
+      }
+
+      ss = content.gsub!(/TOKEN_(\d+)/) { |mm|
+        match   = Regexp.last_match
+        itoken  = match[1].to_i
+        replaced << itoken
+        tokens[itoken].replace
+      }
+    end
+
+    token_classes = tokens.map { |token| token.class }.sort_by { |token| token.rank }
+    token_classes.uniq.each { |tc| tc.post_replace(content) }
+
+    content
+  end
+
+  attr_accessor :default_project
+  attr_accessor :script
+  attr_accessor :backend
+  attr_accessor :message
+
+    # Creates the markup class.
+  def initialize(default_project, script, title)
+    @default_project  = default_project
+    @script           = script
+    @title            = title
+  end
+
+private
+    # Find HTML tags
+  SIMPLE_TAG_RE = %r{<[^<>]+?>}   # Ensure that only the tag is grabbed.
+  HTML_TAG_RE   = %r{\A<          # Tag must be at start of match.
+                        (/)?      # Closing tag?
+                        ([\w:]+)  # Tag name
+                        (?:\s+    # Space
+                         ([^>]+)  # Attributes
+                         (/)?     # Singleton tag?
+                        )?        # The above three are optional
+                       >}x
+  ATTRIBUTES_RE = %r{([\w:]+)(=(?:\w+|"[^"]+?"|'[^']+?'))?}x
+  STYLE_NOVD_RE = %r{(?:\s?(visibility|display):[^'";]+;?)}x
+  ALLOWED_ATTR  = %w(style title type lang dir class id cite datetime abbr) +
+                  %w(colspan rowspan compact start media)
+  ALLOWED_HTML  = %w(abbr acronym address b big blockquote br caption cite) +
+                  %w(code col colgroup dd del dfn dir div dl dt em h1 h2 h3) +
+                  %w(h4 h5 h6 hr i ins kbd li menu ol p pre q s samp small) +
+                  %w(span strike strong style sub sup table tbody td tfoot) +
+                  %w(th thead tr tt u ul var)
+
+    # Clean the content of unsupported HTML and attributes. This includes
+    # XML namespaced HTML. Sorry, but there's too much possibility for
+    # abuse.
+  def clean(content)
+    content = content.gsub(SIMPLE_TAG_RE) do |tag|
+      tagset = HTML_TAG_RE.match(tag)
+
+      if tagset.nil?
+        tag = Ruwiki.clean_entities(tag)
+      else
+        closer, name, attributes, single = tagset.captures
+
+        if ALLOWED_HTML.include?(name.downcase)
+          unless closer or attributes.nil?
+            attributes = attributes.scan(ATTRIBUTES_RE).map do |set|
+              if ALLOWED_ATTR.include?(set[0].downcase)
+                if set[0] == 'style'
+                  set[1].gsub!(STYLE_NOVD_RE, '')
+                end
+                set.join
+              else
+                nil
+              end
+            end.compact.join(" ")
+            tag = "<#{closer}#{name} #{attributes}#{single}>"
+          else
+            tag = "<#{closer}#{name}>"
+          end
+        else
+          tag = Ruwiki.clean_entities(tag)
+        end
+      end
+      tag.gsub(%r{((?:href|src)=["'])(#{Ruwiki::Wiki::RE_URI_SCHEME})}) { "#{$1}\\#{$2}" }
+    end
+  end
+end
+
+require 'ruwiki/wiki/tokens'

data/lib/ruwiki/wiki/tokens.rb

@@ -0,0 +1,136 @@
+#--
+# Ruwiki
+#   Copyright � 2002 - 2004, Digikata and HaloStatue
+#   Alan Chen (alan@digikata.com)
+#   Austin Ziegler (ruwiki@halostatue.ca)
+#
+# Licensed under the same terms as Ruby.
+#
+# $Id: tokens.rb,v 1.8 2004/11/26 12:18:47 austin Exp $
+#++
+class Ruwiki
+  class Wiki
+      # The base Token class. All Token classes must inherit from Token and
+      # *must* implement the following methods:
+      #
+      # [self.regexp]   The regular expression that the Token will be
+      #                 replacing.
+      # [replace]       The mechanism for replacing the Token with the desired
+      #                 results.
+      #
+      # Token classes <i>should</i> implement the following method:
+      # [self.rank]          Default: <tt>5000</tt>. Affects the sort order.
+      #                      Must return an integer.
+      #
+      # Token classes <i>may</i> implement the following methods:
+      # [restore]            Restores the token without replacement.
+      #                      Implements the results of the escape character.
+      #                      NOTE: each Token class is responsible for its own
+      #                      restore. Tokens that are anchored to the
+      #                      beginning of a line are the most likely to need
+      #                      to reimplement this.
+      # [self.post_replace]  Performs any necessary massaging of the data. See
+      #                      the implementation of Ruwiki::Wiki::Lists for
+      #                      more information.
+    class Token
+      @@tokenlist = []
+      @@sorted    = false
+
+      class << self
+          # Tokens should define rank if they must be first or last in
+          # processing. Otherwise, they are sorted in the order defined.
+        def rank
+          5000
+        end
+
+          # The Wiki parsing routine uses Token.tokenlist to determine the
+          # tokens that are processed, and the order in which they are
+          # processed. See Token.rank for more information.
+        def tokenlist
+          unless @@sorted
+            head = @@tokenlist.shift
+            @@tokenlist.sort! { |aa, bb| aa.rank <=> bb.rank }
+            @@tokenlist.unshift(head)
+            sorted = true
+          end
+          @@tokenlist
+        end
+
+        def inherited(child_class) #:nodoc:
+          @@tokenlist << Token if @@tokenlist.empty?
+
+            # Make the child class post_replace a blank function because we
+            # don't want to propogate the currently defined post_replace.
+            # The current post_replace is specific to Token_Base only.
+          class << child_class
+            def self.post_replace(content)
+              content
+            end
+          end
+
+          @@tokenlist << child_class
+          @@sorted = false
+        end
+
+          # The replacement regular expression.
+        def regexp
+          /TOKEN_(\d*)/
+        end
+      end
+
+        # All Token classes must match this header signature if they define
+        # #initialize.
+        #
+        # [match]     The MatchData object for this Token.
+        # [project]   The project being processed.
+        # [backend]   The backend for the wiki. This is used to determine if
+        #             the page or project exists. The object passed must
+        #             respond to #project_exists?(project) and
+        #             #page_exists?(page, project).
+        # [script]    The URI to the script.
+        # [message]   The message hash for localized messages.
+        # [title]     The title of the Wiki.
+      def initialize(match, project, backend, script, message, title)
+        @match    = match
+        @project  = project
+        @backend  = backend
+        @script   = script
+        @message  = message
+        @title    = title
+      end
+
+        # The replacement method. Uses @match to replace the token with the
+        # appropriate values.
+      def replace
+        "TOKEN_#{@match[1]}"
+      end
+
+        # Restores the token without replacement. By default, replaces
+        # "dangerous" HTML characters.
+      def restore
+        Ruwiki.clean_entities(@match[0])
+      end
+
+        # The content may need massaging after processing.
+      def self.post_replace(content)
+        content
+      end
+    end
+  end
+end
+
+  # Load the tokens from the ruwiki/wiki/tokens directory.
+tokens_dir = 'ruwiki/wiki/tokens'
+
+$LOAD_PATH.each do |path|
+  target = "#{path}/#{tokens_dir}"
+  if File.exists?(target) and File.directory?(target)
+    Dir::glob("#{target}/*.rb") do |token|
+      begin
+        require token
+      rescue LoadError
+        nil
+      end
+    end
+  end
+end