rote 0.3.0.2 → 0.3.2

data/doc/res/stylesheets/normal.css

@@ -12,6 +12,7 @@ body {
 	margin: 0px 0px 0px 0px;
 }
 
+/* * linky links *** */
 a:link {
 	color: #cc3030;
 	text-decoration: none;
@@ -60,8 +61,9 @@ a.nav:visited {
 	background: auto;
 }
 
-/* outer div top bar on pages */
+/* * outer layout ** */
 table.topbar {
+	/* outer div top bar on pages */
 	background: #f5f5f5;
 	color: #000000;
 	width: 100%;
@@ -92,8 +94,6 @@ img.navicon {
 	height: 22px;
 }
 
-/* ***************** */
-
 div.frontcopyright {
 	/* Copyright bit on front page */
 	color: #909090;
@@ -120,6 +120,8 @@ div.main {
 	margin: 50px 12% 50px 8%;
 }
 
+/* * layout imgs *** */
+
 img.smallrpotlogo {
 	width: 210px;
 	height: 47px;
@@ -140,6 +142,8 @@ img.smalllogo {
 	height: 68px;
 }
 
+/* * page styles *** */
+
 h3 {
 	border-bottom: thin #959595 solid;
 }
@@ -148,7 +152,24 @@ h4 {
 	border-bottom: thin #b8c8c8 solid;
 }
 
-/* syntax */
+h6 {
+	border-bottom: thin #c0c0d8 solid;
+}
+
+div.note {
+	background: #e8e8fa;
+	border: thin dashed #3e5972;
+	position: relative;
+	width: 90%;
+	left: 5%;
+	right: 5%;
+	text-align: right;
+	font-size: 10pt;	
+	padding: 5px;
+	margin-bottom: 5px;
+}
+
+/* * syntax ******** */
 pre.ruby {
 	background: #f5f5f5;
 	border: thin dashed #3e5972;
@@ -156,6 +177,10 @@ pre.ruby {
 	margin-left: 2em;
 }
 
+pre.ruby span.normal {
+	color: #000000;
+}
+
 pre.ruby span.comment {
 	color: #789a86;
 	text-decoration: oblique;
@@ -188,6 +213,15 @@ pre.ruby span.string {
 	color: #2020f0;	
 }
 
+pre.ruby span.char {
+	color: #2020f0;	
+	font-weight: bold;
+}
+
+pre.ruby span.number {
+	color: #aa1010;	
+}
+
 pre.ruby span.regex {
 	color: #552090;	
 }
@@ -210,3 +244,11 @@ pre.ruby span.method {
 	color: #aa1010;
 }
 
+pre.ruby span.attribute {
+	color: #3e5972;
+}
+
+pre.ruby span.escape { 
+	color: #2020f0;	
+	font-weight: bold;
+}

data/lib/rote.rb

@@ -1,6 +1,6 @@
 # rote.rb - main Rote module  
 # Copyright (c) 2005 Ross Bamford (and contributors)
-# $Id: rote.rb,v 1.22 2005/12/14 19:19:58 roscopeco Exp $
+# $Id: rote.rb 145 2005-12-14 19:19:58 +0000 (Wed, 14 Dec 2005) roscopeco $
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy of
 # this software and associated documentation files (the "Software"), to deal in 
@@ -41,7 +41,7 @@ end
 require 'rake'
 
 # Master Rote version. Manage this from the Rake release support.
-ROTEVERSION = '0.3.0.2'
+ROTEVERSION = '0.3.2'
 
 #####
 ## *Rote* is a Rake (http://rake.rubyforge.org) based build tool for static

data/lib/rote/app.rb

@@ -2,7 +2,7 @@
 # (c)2005 Ross Bamford (and contributors)
 #
 # See 'rote.rb' or LICENSE for licence information.
-# $Id: app.rb,v 1.6 2005/12/12 02:45:24 roscopeco Exp $
+# $Id: app.rb 128 2005-12-12 02:45:24 +0000 (Mon, 12 Dec 2005) roscopeco $
 require 'getoptlong'
 
 module Rote

data/lib/rote/cache.rb

@@ -0,0 +1,144 @@
+# Dependency caching / memoize to disk for Rake / Rote
+# Contributed by Jonathan Paisley (very slightly modified)
+#--
+# (c)2005, 2006 Ross Bamford (and contributors)
+#
+# See 'rote.rb' or LICENSE for licence information.
+# $Id: cache.rb 150 2006-01-02 00:39:41 +0000 (Mon, 02 Jan 2006) roscopeco $
+#++
+# This file adds dynamic dependency tracking and caching for 
+# incremental builds, by adding methods to the Rake module 
+# and Task class. The primary intention is to allow pages
+# to register layout files, and other dynamic dependencies
+# to allow them to be checked on the next incremental build.
+# To use, simply require this in your Rakefile, and call 
+# Rake.register_dependency from your page (e.g. when applying
+# layout). 
+#
+# Eventually this registration may become implicit with layout.
+
+require 'md5'
+require 'yaml'
+require 'pathname'
+require 'rake'
+
+module Rake
+  class << self
+    # Directory for storing Rake dependency cache
+    def cache_dir=(val); @cache_dir = val; end
+    def cache_dir; @cache_dir ||= ".rake_cache"; end
+    def dependencies_file; File.join(cache_dir,"dependencies.yaml"); end
+    # Hash of current cached dependencies
+    def cached_dependencies; @cached_dependencies ||= {}; end
+    # Array representing current tasks being executed
+    def task_stack; @tasks ||= []; end
+    # Reference to current task being executed
+    def current_task; task_stack.last; end
+
+    # Use this method to dynamically register one or more files
+    # as dependencies of the currently executing task.
+    def register_dependency(deps, t = nil)
+      t = (current_task.name if current_task) unless t
+      if t then
+        file t => deps
+        (cached_dependencies[t] ||= []) << deps
+      end
+    end
+  end
+  
+  class Task
+    alias :pre_autodep_invoke :invoke
+    
+    # Invoke the task, loading cached dependencies if not already
+    # loaded, and handling the task stack. The argument controls
+    # whether or not cached dependencies are loaded and should not
+    # be set false except in testing.
+    def invoke(do_cache = true)
+      # Invoke patched to record task stack and
+      # load cached dependencies on first go.
+      Rake.load_cached_dependencies if do_cache && !$CACHEDEPS_LOADED
+      
+      begin
+        Rake.task_stack << self
+        
+        # TODO what's going on here?
+        # Rake.cached_dependencies[name] = [] if Rake.cached_dependencies[name] 
+        
+        pre_autodep_invoke
+      ensure
+        Rake.task_stack.pop
+      end
+    end
+
+    # Memoize the result of the block with respect to the 
+    # file-based dependencies. Specify a description and
+    # dependencies like a Task:
+    #
+    #   Rake::Task.memoize :task_name => [fn1,fn2] { ... }
+    #
+    # If the cached result is up-to-date with respect to the
+    # dependencies then the block will not be executed. Instead,
+    # the result will be unmarshalled from disk.
+    def self.memoize(args, &block)
+      task_name, deps = resolve_args(args)
+      fn = File.join(Rake.cache_dir, MD5.new(deps.inspect).to_s + "." + task_name)
+      Rake.register_dependency(deps)
+      
+      result = nil
+      # This file task isn't ever used other than manually below with t.invoke
+      t = file fn => deps do
+        result = block.call
+        mkdir_p Rake.cache_dir unless File.exists?(Rake.cache_dir)
+        File.open(fn,"w") { |fp| Marshal.dump(result,fp) }
+      end
+      if t.needed? then
+        t.invoke
+        result
+      else
+        Marshal.load(File.read(fn))
+      end
+    end
+  end
+  
+  protected
+  
+  # Load cached dependencies, unless they're already
+  # loaded. This method is called during task invocation,
+  # with the effect that cached deps are loaded from yaml
+  # on the first invoke.
+  #
+  # An at_exit handler is installed to save the dependencies
+  # when rake exits.
+  def self.load_cached_dependencies
+    at_exit { self.save_cached_dependencies }
+
+    return unless File.exists?(dependencies_file)
+    YAML.load(File.read(dependencies_file)).each do |task,deps|
+      deps.each do |dep|
+        register_dependency(dep, task)
+      end
+    end
+    
+    $CACHEDEPS_LOADED = true
+  end
+  
+  def self.save_cached_dependencies
+    return if cached_dependencies.empty?
+    mkdir_p cache_dir unless File.exists?(cache_dir)
+    deps = {}
+    cached_dependencies.each do |k,v|
+      deps[k] = v.flatten.uniq
+    end
+    File.open(dependencies_file,"w") { |fp| fp.write YAML.dump(deps) }
+  end
+end
+  
+task :clean => :clean_cached_dependencies
+task :clean_cached_dependencies do
+  
+  # careful now...
+  rm_rf Rake.cache_dir unless Rake.cache_dir == '.'
+  
+  Rake.cached_dependencies.clear
+end
+

data/lib/rote/filters.rb

@@ -1,10 +1,26 @@
 #--
 # Require all filters
-# (c)2005 Ross Bamford (and contributors)
+# (c)2005, 2006 Ross Bamford (and contributors)
 #
 # See 'rote.rb' or LICENSE for licence information.
-# $Id: filters.rb,v 1.2 2005/12/12 02:45:24 roscopeco Exp $
+# $Id: filters.rb 128 2005-12-12 02:45:24 +0000 (Mon, 12 Dec 2005) roscopeco $
 #++
 
-# will require 'base' but it'd get required anyway...
-Dir[File.join(File.dirname(__FILE__), 'filters/*.rb')].each { |f| require f }
+# Everyone requires this, we need to get it loaded first.
+require 'rote/filters/base'
+
+# This now requires conservatively, ignoring any filters that
+# throw a LoadError. This allows a simple 'require rote/filters' to
+# be used to load all filters _for which dependencies are
+# available_.
+Dir[File.join(File.dirname(__FILE__), 'filters/*.rb')].each do |fn|
+  begin
+    require fn unless fn =~ /[\\\/]base.rb$/
+  rescue LoadError
+
+    # ignore, different filters require different library
+    # support.
+
+  end
+end
+

data/lib/rote/filters/base.rb

@@ -3,7 +3,7 @@
 # (c)2005 Ross Bamford (and contributors)
 #
 # See 'rote.rb' or LICENSE for licence information.
-# $Id: base.rb,v 1.3 2005/12/14 19:17:21 roscopeco Exp $
+# $Id: base.rb 144 2005-12-14 19:17:21 +0000 (Wed, 14 Dec 2005) roscopeco $
 #++
 module Rote
   module Filters

data/lib/rote/filters/bluecloth.rb

@@ -0,0 +1,40 @@
+#--
+# Rote filter for BlueCloth
+# (c)2006 Ross Bamford (and contributors)
+#
+# See 'rote.rb' or LICENSE for licence information.
+# $Id: bluecloth.rb 155 2006-01-05 00:50:32 +0000 (Thu, 05 Jan 2006) roscopeco $
+#++
+
+require 'bluecloth'
+require 'rote/filters/base'
+
+module Rote
+  module Filters
+    #####
+    ## Page filter that converts markdown formatting to HTML using 
+    ## BlueCloth.
+    class BlueCloth < TextFilter
+    
+      # Create a new filter instance. The supplied restrictions (if any)
+      # are passed directly to BlueCloth. See BlueCloth docs for 
+      # details of supported restrictions.
+      #
+      # If a block is supplied, it will be passed the BlueCloth string
+      # at render time, along with the page being rendered. It is 
+      # expected to return the rendered content.
+      # If no block is supplied, to_html is called implicitly.
+      def initialize(*restrictions, &blk)
+        super()  
+        @restrictions = restrictions
+        @blk = blk || lambda { |bc, page| bc.to_html }
+      end      
+      
+      def handler(text,page)
+        bc = ::BlueCloth.new(text)
+        @blk.call(bc, page)
+      end      
+    end    
+  end
+end
+    

data/lib/rote/filters/eval.rb

@@ -0,0 +1,58 @@
+#--
+# Rote filter that runs macro body as code.
+# (c)2005, 2006 Ross Bamford (and contributors)
+#
+# See 'rote.rb' or LICENSE for licence information.
+# $Id: syntax.rb 135 2005-12-12 15:01:07 +0000 (Mon, 12 Dec 2005) roscopeco $
+#++
+
+require 'stringio'
+require 'rote/filters/base'
+
+module Rote
+  module Filters
+    
+    #####
+    ## Page filter that evaluates Ruby code in it's body in the
+    ## current interpreter. The code is directly evaluated, and
+    ## anything it writes to standard out becomes the macro
+    ## replacement.
+    ## 
+    ## Obviously you can place Ruby code directly in your pages,
+    ## using ERB, and for many cases that is the route you should
+    ## take. There is a (somewhat) subtle difference between the
+    ## to alternatives however: ERB is always evaluated right 
+    ## at the start of rendering, before any Text Filters are
+    ## run, whereas #:eval# code is executed during the page filter
+    ## stage, which happens after ERB and text filtering, but
+    ## before layout is applied.
+    ## 
+    class Eval < MacroFilter
+      def initialize(macro_re = MACRO_RE)
+        super([],macro_re)
+      end      
+      
+      def macro_eval(cmd,body,raw)
+        # no need to fiddle with $SAFE here is there?
+        
+        # FIXME this is a hack.
+        
+        # Utility is still limited I guess, since current Page isn't
+        # readily available to the macro code. We can probably fix
+        # that though.
+        
+        # If thread safety becomes an issue, this'll probably need 
+        # to be critical sectioned.
+        
+        begin
+          oldsio, $stdout = $stdout, StringIO.new
+          eval body        
+          $stdout.rewind
+          $stdout.read
+        ensure
+          $stdout = oldsio
+        end
+      end      
+    end      
+  end 
+end

data/lib/rote/filters/exec.rb

@@ -0,0 +1,42 @@
+#--
+# Rote filter that passes body to an external command
+# (c)2005, 2006 Ross Bamford (and contributors)
+#
+# See 'rote.rb' or LICENSE for licence information.
+# $Id: syntax.rb 135 2005-12-12 15:01:07 +0000 (Mon, 12 Dec 2005) roscopeco $
+#++
+  
+require 'rote/filters/base'
+
+module Rote
+  module Filters
+    
+    #####
+    ## Page filter that runs it's body through the specified
+    ## command, and captures the output. E.g.:
+    ##
+    ##   #:exec#python#
+    ##     print "Hello, World!"
+    ##   #:exec#
+    ## 
+    ## Although this filter can be used to execute Ruby code,
+    ## you must bear in mind that this will happen in a separate
+    ## interpreter process, so no variables or requires from the
+    ## current environment will be available.
+    ## If you wish to evaluate Ruby code in your pages, you should
+    ## use either ERB (evaluated at the beginning of the render),
+    ## or the Eval filter (evaluated near the end).
+    class Exec < MacroFilter
+      def initialize(macro_re = MACRO_RE)
+        super([],macro_re)
+      end      
+      
+      def macro_exec(cmd,body,raw)
+        res = IO.popen(cmd, 'w+') do |io|
+          Thread.new { io.write body; io.close_write }
+          io.read
+        end
+      end      
+    end      
+  end 
+end