zenweb 2.18.0

data/lib/ZenWeb/CalendarRenderer.rb

@@ -0,0 +1,162 @@
+# this is a simple template. Globally replace Calendar with the name of
+# your renderer and then go fill in YYY with the appropriate content.
+
+require 'ZenWeb/GenericRenderer'
+require 'date' # which requires rational
+require 'time'
+
+# class Integer
+#   alias :slowgcd :gcd
+#   def gcd(n)
+#     m = abs
+#     while n != 0
+#       m %= n
+#       tmp = m; m = n; n = tmp
+#     end
+#     m.abs
+#   end
+# end
+
+# require 'tally'
+# class Integer
+#   tally :gcd, true
+# end
+
+=begin
+
+= Class CalendarRenderer
+
+DOC
+
+=== Methods
+
+=end
+
+class CalendarRenderer < GenericRenderer
+
+  DAYS_IN_MONTH = [
+    [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
+    [nil, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
+  ]
+
+=begin
+
+     --- CalendarRenderer#render(content)
+
+     DOC
+
+=end
+
+  def render(content)
+    events = Hash.new { |h,k| h[k] = [] }
+    reverse = false
+    self.scan_region(content, /<cal/i, /<\/cal>/i) do |line, context|
+      case context
+      when :START then
+        reverse = true if line =~ /<cal\s+reverse\s*>/i
+      when :END then
+        self.generate_calendars(events, reverse)
+      else
+        if line =~ /(\d\d\d\d-\d\d-\d\d):\s*(.*)/ then
+          description = $2
+          time = Time.parse($1) # NOT Date! hellishly slow!
+          events[$1] << description
+        end
+      end
+    end
+
+    return self.result
+  end
+
+  def generate_calendar(year, month, events)
+
+    current_events = []
+
+    which_year = Date.leap?(year) ? 1 : 0
+    date_start = Date.civil(year, month,  1)
+    last_day = DAYS_IN_MONTH[which_year][month]
+    date_end   = Date.civil(year, month, -1)
+
+    push "<table class=\"calendar\">"
+    push "<tr>"
+    push "<td valign=\"top\">" # calendar
+
+    m2 = "%02d" % month
+    push "<table class=\"view y#{year} m#{m2}\">\n"
+
+    long_month_name = Date::MONTHNAMES[month]
+    month_name = Date::ABBR_MONTHNAMES[month].downcase
+
+    push "<tr class=\"title\">\n"
+    push "<th colspan=7>#{long_month_name} #{year}</th>\n"
+    push "</tr>\n"
+
+    push "<tr class=\"weektitle\"\n"
+    push Date::ABBR_DAYNAMES.map { |d| "<th class=\"#{d.downcase}\">#{d}</th>" }.join("\n")
+    push "</tr>\n"
+
+    dow_start = date_start.wday
+    push "<tr class=\"days firstweek\">\n"
+    push "<td colspan=#{dow_start}>&nbsp;</td>\n" unless dow_start == 0
+
+    last_sunday = date_end.day - date_end.wday + 1
+
+    week = 1
+    wday = dow_start
+
+    day_last = date_end.day
+
+    1.upto(day_last) do |day|
+
+      event=""
+      cal = Time.local(year, month, day).strftime("%Y-%m-%d")
+      if events.has_key? cal then
+        current_events << "<li>#{cal}:\n<ul>\n"
+        events[cal].each do |description|
+          current_events << "<li>#{description}\n"
+        end
+        current_events << "</ul>\n"
+        event=" event"
+      end
+
+      dow = Date::ABBR_DAYNAMES[(day + dow_start - 1) % 7].downcase
+      d2 = "%02d" % day
+      push "<td class=\"d#{d2} #{dow}#{event}\">#{day}</td>\n"
+
+      if day != day_last and wday == 6 then
+        push "</tr>\n"
+        unless day == last_sunday then
+          push "<tr class=\"days\">\n"
+        else
+          push "<tr class=\"days lastweek\">\n"
+        end
+        week += 1
+      end
+      
+      wday += 1
+      wday = 0 if wday >= 7 # remember 0..6
+    end
+
+    day_count = 7-date_end.wday-1
+    push "<td colspan=#{day_count}>&nbsp;</td>\n" unless day_count == 0
+    push "</tr>\n"
+    push "</table>\n"
+    push "</td>\n" # /calendar
+    push "<td class=\"eventlist\">\n" # events
+    push "<ul>\n"
+    push current_events.join('')
+    push "</ul>\n"
+    push "</td>\n" # /events
+    push "</tr>\n"
+    push "</table>\n"
+  end
+
+  def generate_calendars(events, should_reverse=false)
+    active_months = events.keys.map { |d| d[0..6] }.sort.uniq
+    active_months = active_months.reverse if should_reverse
+    active_months.each do |ym|
+      year, month = ym.split(/-/).map { |n| n.to_i }
+      self.generate_calendar(year, month, events)
+    end
+  end
+end

data/lib/ZenWeb/CompactRenderer.rb

@@ -0,0 +1,45 @@
+# 
+# 
+
+require 'ZenWeb/GenericRenderer'
+
+=begin
+
+= Class CompactRenderer
+
+CompactRenderer compacts HTML whitespace and comments to minimize how much text gets served.
+
+=== Methods
+
+=end
+
+class CompactRenderer < GenericRenderer
+
+=begin
+
+     --- CompactRenderer#render(content)
+
+     Compacts HTML blah blah DOC
+
+=end
+
+  def render(content)
+
+    # protect pre blocks
+    content = content.gsub(/(<pre>)([\s\S]*?)(<\/pre>)/i) do
+      p1 = $1
+      body = $2
+      p2 = $3
+      body = body.gsub(/\n/, 1.chr).gsub(/ /, 2.chr)
+      p1 + body + p2
+    end
+
+    content = content.gsub(/\n\r/, '').gsub(/\s+/, ' ').gsub(/> </, '><').strip
+    content = content.gsub(1.chr, "\n").gsub(2.chr, " ")
+
+    push(content)
+
+    return self.result
+  end
+
+end

data/lib/ZenWeb/CompositeRenderer.rb

@@ -0,0 +1,63 @@
+require 'ZenWeb/GenericRenderer'
+
+=begin
+
+= Class CompositeRenderer
+
+Allows multiple renderers to be plugged into a single renderer.
+
+=== Methods
+
+=end
+
+class CompositeRenderer < GenericRenderer
+
+  attr_reader :renderers
+
+=begin
+
+--- CompositeRenderer#new(document)
+
+    Creates a new CompositeRenderer.
+
+=end
+
+  def initialize(document)
+    super(document)
+    @renderers = []
+  end
+
+=begin
+
+--- CompositeRenderer#render(content)
+
+    Renders by running all of the renderers in sequence.
+
+=end
+
+  def render(content)
+    @renderers.each { | renderer |
+      content = renderer.render(content)
+    }
+    return content
+  end
+
+=begin
+
+--- CompositeRenderer#addRenderer(renderer)
+
+    Adds renderer to the list of renderers used by this composite.
+
+=end
+
+  def addRenderer(renderer)
+
+    if (renderer.nil? or ! renderer.kind_of? GenericRenderer) then
+      raise ArgumentError, "You may only add an instance of GenericRenderer"
+    end
+
+    @renderers.push(renderer)
+  end
+
+end
+

data/lib/ZenWeb/FileAttachmentRenderer.rb

@@ -0,0 +1,57 @@
+# this is a simple template. Globally replace FileAttachment with the name of
+# your renderer and then go fill in YYY with the appropriate content.
+
+require 'ZenWeb/GenericRenderer'
+
+=begin
+
+= Class FileAttachmentRenderer
+
+Finds content between <file name="name">...</file> tags. Writes the
+content to a file of the given name and includes a link to the file.
+
+=== Methods
+
+=end
+
+class FileAttachmentRenderer < GenericRenderer
+
+=begin
+
+     --- FileAttachmentRenderer#render(content)
+
+     YYY
+
+=end
+
+  def render(content)
+
+    start_re = /<file\s+name\s*=\s*\"([\w\.-]+)\"\s*>/i
+    end_re   = /<\/file>/i
+
+    file_content = []
+    name = nil
+    self.scan_region(content, start_re, end_re) do |line, context|
+      case context
+      when :START then
+        name = $1 if line =~ /name\s*=\s*\"([\w\.-]+)\"/i
+      when :END then
+        raise "name is undefined, add name= attribute" if name.nil?
+        dir = File.dirname @document.htmlpath
+        path = File.join(dir, name)
+	push "\n"
+        push "<A HREF=\"#{name}\">Download #{name}</A>\n"
+	File.open(path, "w") do |file|
+	  file.print file_content.join('')
+	end
+        file_content = []
+      else
+        file_content.push line
+        push "  " + line
+      end
+    end
+
+    return self.result.strip
+  end
+
+end

data/lib/ZenWeb/FooterRenderer.rb

@@ -0,0 +1,38 @@
+require 'ZenWeb/GenericRenderer'
+
+=begin
+
+= Class FooterRenderer
+
+Inserts a footer based on metadata.
+
+=== Methods
+
+=end
+
+class FooterRenderer < GenericRenderer
+
+=begin
+
+--- FooterRenderer#render(content)
+
+    Adds a footer if the ((|footer|)) metadata item exists. If the
+    document contains a BODY close HTML tag, then the footer
+    immediately precedes it, otherwise it is simply at the bottom.
+
+=end
+
+  def render(content)
+
+    footer = @document['footer'] || nil
+
+    if footer then
+      content.sub!(/(<\/BODY>|\z)/i) {
+	footer + $1
+      }
+    end
+
+    return content
+  end
+end
+

data/lib/ZenWeb/GenericRenderer.rb

@@ -0,0 +1,143 @@
+$TESTING = FALSE unless defined? $TESTING
+
+=begin
+
+= Class GenericRenderer
+
+A GenericRenderer provides an interface for all renderers. It renders
+nothing itself.
+
+=== Methods
+
+=end
+
+class GenericRenderer
+
+=begin
+
+--- GenericRenderer.new(document)
+
+    Instantiates a generic renderer with a reference to
+    ((|document|)), it\'s website and sitemap.
+
+=end
+
+  # REFACTOR: do not take a document at all
+  def initialize(document)
+    @document = document
+    @website = @document.website
+    @sitemap = @website.sitemap
+    @result = []
+  end
+
+=begin
+
+--- GenericRenderer#push(obj)
+
+    Pushes a string representation of ((|obj|)) onto the result
+    array. If ((|obj|)) is an array, it iterates each item and pushes
+    them (recursively). If it is not an array, it pushes (({obj.to_s})).
+
+=end
+
+  def push(obj)
+    if obj.is_a?(Array) then
+      stuff = obj.flatten
+      @result.push(*stuff) unless stuff.empty?
+    else
+      if false then
+	@result.push(obj.to_s)
+      else
+	@result.push(obj)
+      end	
+    end
+  end
+
+=begin
+
+--- GenericRenderer#unshift(obj)
+
+    Same as ((<GenericRenderer#push>)) but prepends instead of appends.
+
+=end
+
+  def unshift(obj)
+    if obj.is_a?(Array) then
+      obj.reverse.each { | item |
+	self.unshift(item)
+      }
+    else
+      @result.unshift(obj.to_s)
+    end
+
+  end
+
+  # DOC GenericRenderer#result
+  def result(clear=true)
+    result = @result.join('')
+    @result = [] if clear
+    return result
+  end
+
+=begin
+
+--- GenericRenderer#render(content)
+
+    Renders the content. Does nothing in GenericRenderer, but is
+    expected to be overridden by subclasses. ((|content|)) is an array
+    of strings and render must return an array of strings.
+
+    NEW: the argument and result are now a single string!
+
+=end
+
+  # REFACTOR: pass in content and document to render
+  def render(content)
+    return content
+  end
+
+  def each_paragraph(content)
+    content.scan(/.+?(?:#{$/}#{$/}+|\Z)/m) do |block|
+      $stderr.puts "BLOCK = #{block.inspect}" if $DEBUG
+      yield(block)
+    end
+  end
+
+  def each_paragraph_matching(content, pattern)
+    $stderr.puts "CONTENT = #{content.inspect}" if $DEBUG
+    self.each_paragraph(content) do |block|
+      $stderr.puts "PARAGRAPH = #{block.inspect}" if $DEBUG
+      if block =~ pattern then
+        yield(block)
+      else
+	push block
+      end
+    end
+  end
+
+  def scan_region(content, region_start, region_end)
+    matching = false
+    content.scan(/.*#{$/}?/) do |l|
+      # TODO: detect region_end w/o start and freak
+      # TODO: detect nesting and freak
+      if l =~ region_start then
+        matching = true
+	$stderr.puts :START, l.inspect if $DEBUG
+        yield(l, :START)
+        matching = false if l =~ region_end
+      elsif l =~ region_end then
+        matching = false
+	$stderr.puts :END, l.inspect if $DEBUG
+        yield(l, :END)
+      elsif matching then
+	$stderr.puts :MIDDLE, l.inspect if $DEBUG
+        yield(l, :MIDDLE)
+      else
+	$stderr.puts :IGNORED, l.inspect if $DEBUG
+        push l
+      end
+    end
+  end
+
+end
+