zenweb 2.18.1 → 3.0.0.b1

data/lib/ZenWeb/RelativeRenderer.rb

@@ -1,97 +0,0 @@
-require 'ZenWeb/GenericRenderer'
-
-$Uri_Implemented = true
-if RUBY_VERSION =~ /1.6.(\d+)/ then
-  $Uri_Implemented = $1.to_i >= 7
-end
-
-if $Uri_Implemented then
-  require 'uri'
-else
-  if $TESTING then
-    $stderr.puts "WARNING: RelativeRenderer can not be implemented in ruby versions < 1.6.7."
-    $stderr.puts "Some unit tests will fail as a result"
-  end
-end
-
-=begin
-
-= Class RelativeRenderer
-
-Converts urls to relative urls if possible...
-
-=== Methods
-
-=end
-
-class RelativeRenderer < GenericRenderer
-
-=begin
-
---- RelativeRenderer.new(document)
-
-    Instantiates RelativeRenderer.
-
-=end
-
-  def initialize(document)
-    super(document)
-
-    if $Uri_Implemented then
-      # fake, since we don't know the domain (or care), but necessary for URI#-
-      # it bombs otherwise... fun.
-      @base = URI.parse("http://www.domain.com/")
-      
-      # @base + url will == url if url is not relative...
-      @docurl = @base + URI.parse(@document.url)
-    end
-  end
-
-=begin
-
---- RelativeRenderer#render(content)
-
-    Converts urls that look like they can be made relative to be so...
-
-=end
-
-  def render(content)
-    if $Uri_Implemented then
-      content.each_line { | line |
-        line.gsub!(%r%(href=\")([^\"]+)(\")%i) { |url|
-          front  = $1
-          oldurl = $2
-          back   = $3
-          newurl = convert(oldurl)
-
-          front + newurl + back
-        }
-
-        push(line)
-      }
-
-      return self.result
-    else
-      return content
-    end
-  end
-
-  def convert(u)
-
-    if $Uri_Implemented and (u[0].chr != '#') then
-      oldurl = URI.parse(u)
-
-      if oldurl.relative? then
-	oldurl = @base + oldurl
-	scheme = oldurl.scheme
-	newurl = oldurl - @docurl
-      else
-	newurl = u
-      end
-      return newurl.to_s
-    else
-      return u
-    end
-  end
-end
-

data/lib/ZenWeb/RubyCodeRenderer.rb

@@ -1,56 +0,0 @@
-require 'ZenWeb/GenericRenderer'
-
-=begin
-
-= Class RubyCodeRenderer
-
-Finds paragraphs prefixed with "!" and evaluates them with xmp
-
-=== Methods
-
-=end
-
-class RubyCodeRenderer < GenericRenderer
-
-=begin
-
---- RubyCodeRenderer#render(content)
-
-    Finds paragraphs prefixed with "!" and evaluates them with xmp
-
-=end
-
-  def render(content)
-
-    text = content.split($PARAGRAPH_RE)
-    
-    text.each do | p |
-
-      if p =~ /^\s*\!/m then
-        p.gsub!(/^\s*\!\s*/, '')
-        
-        begin
-          cmd = "irb --prompt xmp --noreadline 2>/dev/null"
-          puts "Running irb for code:\n#{p}" unless $TESTING
-          IO.popen(cmd, "r+") do |xmp|
-            xmp.puts(p + "\nexit")
-            result = xmp.read
-            result.gsub!(/\s+>> exit\s*\Z/, '')
-            result.gsub!(/=>(.*)\Z/m, '=><EM>\1</EM>')
-            push result
-          end
-        rescue Exception => something
-          $stderr.puts "xmp: #{something}\nTrace =\n" + $@.join("\n") + "\n"
-        end
-      else
-        push p
-      end
-      push ''
-    end
-    
-    # put it back into line-by-line format
-    @result = @result.join("\n").scan(/^.*[\n\r]+/)
-
-    return self.result
-  end
-end

data/lib/ZenWeb/SitemapRenderer.rb

@@ -1,56 +0,0 @@
-require 'ZenWeb/GenericRenderer'
-
-=begin
-
-= Class SitemapRenderer
-
-Converts a sitemap file into output suitable for
-((<Class TextToHtmlRenderer>)).
-
-=== Methods
-
-=end
-
-class SitemapRenderer < GenericRenderer
-
-=begin
-
---- SitemapRenderer#render(content)
-
-    Converts a sitemap file into output suitable for ((<Class TextToHtmlRenderer>)).
-
-=end
-
-  def render(content)
-
-    # used for /~user/blah.html pages
-    # basically, we need to strip off whatever the base of the sitemap is to
-    # make sure we indent everything to the right level.
-    base = @sitemap.url
-    base = base.sub(%r%/[^/]*$%, '/')
-
-    urls = @sitemap.doc_order.clone
-
-    @document['subtitle'] ||= "There are #{urls.size} pages in this website."
-    urls.each { | url |
-
-      indent = url.sub(/\.html$/, "")
-      indent.sub!(/#{base}/, "")
-      indent.sub!(/\/index$/, "")
-      indent.sub!(/^\//, "")
-      indent.gsub!(/[^\/]+\//, "\t")
-
-      if indent =~ /^(\t*).*/ then
-	indent = $1
-      end
-
-      doc      = @website[url]
-      title    = doc.fulltitle
-
-      push("#{indent}+ <A HREF=\"#{url}\">#{title}</A>\n")
-    }
-
-    return self.result
-  end
-end
-

data/lib/ZenWeb/StandardRenderer.rb

@@ -1,40 +0,0 @@
-require 'ZenWeb/CompositeRenderer'
-require 'ZenWeb/SubpageRenderer'
-require 'ZenWeb/MetadataRenderer'
-require 'ZenWeb/TextToHtmlRenderer'
-require 'ZenWeb/HtmlTemplateRenderer'
-require 'ZenWeb/FooterRenderer'
-
-=begin
-
-= Class StandardRenderer
-
-Creates a fairly standard webpage using several different renderers.
-
-=== Methods
-
-=end
-
-class StandardRenderer < CompositeRenderer
-
-=begin
-
---- StandardRenderer#new(document)
-
-    Creates a new StandardRenderer.
-
-=end
-
-  def initialize(document)
-    super(document)
-
-    # TODO: make this a metadata variable
-    self.addRenderer(SubpageRenderer.new(document))
-    self.addRenderer(MetadataRenderer.new(document))
-    self.addRenderer(TextToHtmlRenderer.new(document))
-    self.addRenderer(HtmlTemplateRenderer.new(document))
-    self.addRenderer(FooterRenderer.new(document))
-  end
-
-end
-

data/lib/ZenWeb/StupidRenderer.rb

@@ -1,91 +0,0 @@
-# this is a simple template. Globally replace Stupid with the name of
-# your renderer and then go fill in YYY with the appropriate content.
-
-require 'ZenWeb/GenericRenderer'
-
-=begin
-
-= Class StupidRenderer
-
-Maniplates the text as a whole, in really stupid ways.  Currently, as
-a fun demo of metadata, we have it using the variable 'stupidmethod'
-to determine what it does. There are two actions possible:
-
-+ strip - strips vowels from the text. Good compression! :)
-+ leet  - does a horrid job of making the text 7337. Scary.
-
-=== Methods
-
-=end
-
-$Transcode = {
-  'a' => '4', 'b' => '|3', 'c' => '<', 'd' => '|)', 'e' => '3',
-  'f' => 'F', 'g' => 'G', 'h' => ']-[', 'i' => '|', 'j' => 'J',
-  'k' => ']<', 'l' => 'L', 'm' => '/\/\\', 'n' => '/\/', 'o' => '0',
-  'p' => 'P', 'q' => 'Q', 'r' => '/~', 's' => '$', 't' => '+',
-  'u' => '|_|', 'v' => '\/', 'w' => '\/\/', 'x' => '><', 'y' => '`/',
-  'z' => 'Z',
-}
-
-class StupidRenderer < GenericRenderer
-
-=begin
-
---- StupidRenderer#render(content)
-
-    Strips vowells
-
-=end
-
-  def render(content)
-
-    methodname = @document['stupidmethod'] || nil
-    if methodname then
-      method = self.method(methodname)
-
-      content.each_line { |line|
-        line = method.call(line)
-        push(line)
-      }
-    else
-      @result = []
-      content.each_line { |line|
-        @result << line
-      }
-    end
-
-
-    return self.result
-  end
-
-  def strip(s)
-    s = s.gsub(/[aeiou]/i, '')
-    return s
-  end
-
-  def leet(s)
-
-    # this is a lot more complicated than it needs to be. Basically,
-    # we didn't want variable interpolation chunks (eg #{blah}) to
-    # become 7337, so we split on #{}s, work on the other parts, and
-    # then fit it all back together. This should probably be moved up
-    # to render.
-
-    result = []
-    new_s = s.clone
-    re = /(\#\{[^\}]+\})/
-    new_s.split(re).each { |chunk|
-      if (chunk =~ re) then
-	result.push(chunk)
-      else
-	chunk.gsub!(/./) { |char|
-	  $Transcode[char.downcase] || char
-	}
-	result.push(chunk)
-      end
-    }
-
-    return result.join('')
-  end
-
-end

data/lib/ZenWeb/SubpageRenderer.rb

@@ -1,45 +0,0 @@
-require 'ZenWeb/GenericRenderer'
-
-=begin
-
-= Class SubpageRenderer
-
-Generates a list of known subpages in a format compatible with
-TextToHtmlRenderer.
-
-=== Methods
-
-=end
-
-class SubpageRenderer < GenericRenderer
-
-=begin
-
-     --- SubpageRenderer#render(content)
-
-     Renders a list of known subpages in a format compatible with
-     TextToHtmlRenderer. Adds the list to the end of the content.
-
-=end
-
-  def render(content)
-    skip = @document['skipsubpages'] || (@document['includesubpages'] || '') =~ /false/
-
-    subpages = @document.subpages.clone
-    if (not skip and subpages.length > 0) then
-      push("\n\n")
-      push("** Subpages:\n\n")
-      subpages.each_index { | index |
-	url      = subpages[index]
-	doc      = @website[url]
-	title    = doc.fulltitle
-
-	push("+ <A HREF=\"#{url}\">#{title}</A>\n")
-      }
-      push("\n")
-    end
-
-    return content + self.result
-  end
-end
-

data/lib/ZenWeb/TextToHtmlRenderer.rb

@@ -1,219 +0,0 @@
-require 'ZenWeb/HtmlRenderer'
-
-=begin
-
-= Class TextToHtmlRenderer
-
-Converts a fairly plain text format into styled HTML.
-
-=== Methods
-
-=end
-
-class TextToHtmlRenderer < HtmlRenderer
-
-=begin
-
---- TextToHtmlRenderer#render(content)
-
-    Converts a simple plaintext format into formatted HTML. Includes
-    paragraphing, embedded variables, lists, rules, preformatted
-    blocks, and embedded HTML. See the demo pages for a complete
-    description on how to use this.
-
-=end
-
-  def render(content)
-
-    text = content.split($PARAGRAPH_RE)
-
-    table = div = false
-
-    text.each { | p |
-
-      # massage a little
-      p = p.sub($PARAGRAPH_END_RE, '')
-      p.chomp!
-
-      p.gsub!(/\\&/, "&amp;")
-      p.gsub!(/\\</, "&lt;")
-      p.gsub!(/\\>/, "&gt;")
-      p.gsub!(/\\\"/, "&quot;")
-
-      p.gsub!(/\\\{/, "{")
-      p.gsub!(/\\:/, "&#58;")
-
-      # WARN Not sure if I want to do this or not... thinking about it.
-      # p.gsub!(/\\(.)/) { | c | sprintf("&#%04X#;", $1[0]) }
-
-      # url substitutions
-      p.gsub!(/([^=\"])((http|ftp|mailto):(\S+))/) {
-	pre = $1
-	url = $2
-	txt = $4
-
-	txt.gsub!(/\//, " ")
-	txt.strip!
-	txt.gsub!(/ /, " /")
-
-	"#{pre}<A HREF=\"#{url}\">#{txt}</A>"
-      }
-
-      case p
-      when /^(\*\*+)\s*(.*)$/ then
-	level = $1.length
-	push("<H#{level}>#{$2}</H#{level}>\n\n")
-      when /^---+$/ then
-	push("<HR>\n\n")
-      when /^===+$/ then
-	push("<HR CLASS=\"thick\">\n\n")
-      when /^%%%\s*(.*)/ then # TODO: I'm not fond of this
-        rest = $1
-        close = (rest.empty? or (rest.downcase == "end"))
-        push "</div></div>\n" if div
-        push "\n" if div unless table
-        push "</td><td>\n" if table and div
-        
-        push "<div #{rest}><div>\n\n" unless close
-        div = ! close
-      when /^%%\s*$/ then
-        if div then
-          push "</div></div>\n"
-          div = false
-        end
-        if table then
-          push "</td></tr></table>\n\n"
-        else
-          push "<table><tr><td>\n\n"
-        end
-        table = ! table
-      when /^%[=-]/ then
-        hash, order = self.createHash(p)
-        push(self.hash2html(hash, order) + "\n") if hash
-      when /^\t*([\+=])/ then
-        ordered = $1 == "="
-	list = self.createList(p)
-        push(self.array2html(list, ordered)) if list
-      when /^\ \ / then # and p !~ /^[^\ ]/ then
-	p.gsub!(/^\ \ /, '')
-	push("<PRE>" + p + "</PRE>\n\n")
-      when /^\s*<\//, /^\s*<(?:DIV|FORM|P|TABLE|BLOCKQUOTE|H[1-7])\b/i then
-        push p
-        push "\n\n"
-      else
-        push("<P>" + p + "</P>")
-        push "\n\n"
-      end
-    }
-
-    # TODO: need to extend: ordered lists
-
-    # FIX: xmp makes this slow
-    # put it back into line-by-line format
-    # I use scan instead of split so I can keep the EOLs.
-    # @result = @result.join("\n").scan(/^.*[\n\r]+/)
-
-    return self.result
-
-  end
-
-=begin
-
---- ZenDocument#createList
-
-    Convert a string composed of lines prefixed by plus signs into an
-    array of those strings, sans plus signs. If a line is indented
-    with tabs, then the lines at that indention level will become an
-    array of their own, to be added to the encompassing array.
-
-=end
-
-  def createList(data)
-
-    if (data.is_a?(String)) then
-      # TODO: at some time we'll want to support different types of lists
-      data = data.gsub(/^(\t*)([\+=])\s*(.*)$/) { type=$2; $1 + $3 }
-      data = data.split($/)
-    end
-
-    min = -1
-    i = 0
-    len = data.size
-
-    while (i < len)
-      if (min == -1) then
-
-	# looking for initial match:
-	if (data[i] =~ /^\t(\t*.*)/) then
-
-	  # replace w/ one less tab, and record that we have a match
-	  data[i] = $1
-	  min = i
-	end
-      else
-
-	# found match, looking for mismatch
-	if (data[i] !~ /^\t(\t*.*)/ or i == len) then
-
-	  # found mismatch, replacing w/ sublist
-	  data[min..i-1] = [ createList(data[min..i-1]) ]
-	  # resetting appropriate values
-	  len = data.size
-	  i = min
-	  min = -1
-	else
-	  data[i] = $1
-	end
-      end
-      i += 1
-    end
-
-    if (i >= len - 1 and min != -1) then
-      data[min..i-1] = [ createList(data[min..i-1]) ]
-    end
-
-    return data
-  end
-
-=begin
-
---- ZenDocument#createHash
-
-    Convert a string composed of lines prefixed one of two delimiters
-    into a hash. If the delimiter is "%-", then that string is used
-    as the key to the hash. If the delimiter is "%=", then that
-    string is used as the value to the hash.
-
-=end
-
-  def createHash(data)
-
-    result = {}
-    order = []
-
-    if (data.is_a?(String)) then
-      data = data.split($/)
-    end
-
-    key = nil
-    data.each { |line|
-      if (line =~ /^\s*%-\s*(.*)/) then
-	key = $1
-      elsif (line =~ /^\s*%=\s*(.*)/) then
-	val = $1
-
-	if (key) then
-	  # WARN: maybe do something if already defined?
-	  result[key] = val
-	  order << key
-	end
-
-      else
-	# nothing
-      end
-    }
-
-    return result, order
-  end
-
-end