zenweb 2.18.0

data/lib/ZenWeb/RelativeRenderer.rb

@@ -0,0 +1,98 @@
+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.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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,88 @@
+# 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 = method.call(line)
+	push(line)
+      }
+    else
+      @result = content.to_a
+    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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,219 @@
+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