rote 0.2.4.1 → 0.3.0

data/doc/res/stylesheets/normal.css

@@ -147,3 +147,66 @@ h3 {
 h4 {
 	border-bottom: thin #b8c8c8 solid;
 }
+
+/* syntax */
+pre.ruby {
+	background: #f5f5f5;
+	border: thin dashed #3e5972;
+	padding: 10px;
+	margin-left: 2em;
+}
+
+pre.ruby span.comment {
+	color: #789a86;
+	text-decoration: oblique;
+}
+
+pre.ruby span.ident {
+	color: #0b0202;
+}
+
+pre.ruby span.punct {
+	color: #8a7070;
+}
+
+pre.ruby span.symbol {
+	color: #aa1010;
+	font-weight: bold;
+}
+
+pre.ruby span.keyword {
+	color: #903030;
+	font-weight: bold;
+}
+
+pre.ruby span.constant {
+	color: #3e5972;
+	font-weight: bold;
+}
+
+pre.ruby span.string {
+	color: #2020f0;	
+}
+
+pre.ruby span.regex {
+	color: #552090;	
+}
+
+pre.ruby span.expr {
+	color: #101080;
+	font-weight: bold;
+}
+
+pre.ruby span.global {
+	color: #557462;
+}
+
+pre.ruby span.class {
+	color: #3e5972;
+	font-weight: bold;
+}
+
+pre.ruby span.method {
+	color: #aa1010;
+}
+

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.18.2.1 2005/12/07 16:22:21 roscopeco Exp $
+# $Id: rote.rb,v 1.21 2005/12/12 02:47:47 roscopeco Exp $
 #
 # 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 
@@ -38,11 +38,10 @@ rescue LoadError
   nil   # just try without then...
 end  
 
-require 'net/ftp'
 require 'rake'
 
 # Master Rote version. Manage this from the Rake release support.
-ROTEVERSION = '0.2.4.1'
+ROTEVERSION = '0.3.0'
 
 #####
 ## *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.4.4.1 2005/12/07 16:21:39 roscopeco Exp $
+# $Id: app.rb,v 1.6 2005/12/12 02:45:24 roscopeco Exp $
 require 'getoptlong'
 
 module Rote

data/lib/rote/builtin.rf

@@ -14,35 +14,8 @@ require 'rake'
 require 'rake/clean'
 require 'rote'
 
-# Create a set of tasks with the prefix 'doc' to  build the
-# documentation set. The directory layout is as for the
-# command-line wrapper (but can be changed of course).
-#
-# This creates the following tasks:
-#
-#   * doc           - transform/copy all modified pages / resources
-#   * doc_pages     - transform all modified pages
-#   * doc_res       - copy all modified resources
-#   * doc_monitor   - Start monitor mode, transform changed files automatically
-#
-#   * [html/**/*]   - Transform single page / resource unconditionally
-#
-#   * clobber_doc   - Remove output (hooks into main 'clobber' task)
-#
-# In addition to these tasks, you may also wish to define a 'doc_refresh' task
-# to be run whenever modified resources are processed in monitor mode.
-ws = Rote::DocTask.new(:doc) { |site| 
-  site.output_dir = 'html'
-  site.layout_dir = 'doc/layouts'
-  
-  site.pages.dir = 'doc/pages'
-  site.pages.include('**/*')  
-  
-  site.res.dir = 'doc/res'
-  site.res.include('**/*')
-}
-
-task :default => [:doc]
+# Import the standard doc task
+import File.join(File.dirname(__FILE__),('/project/Rakefile'))
 
 #################### CREATE NEW PROJECT FROM TEMPLATE ###############
 #
@@ -59,6 +32,7 @@ task :default => [:doc]
 #
 # Also need a way to display error message if the rule isn't 
 # invoked at least once...
+desc "Bootstrap a new documentation project"
 task :create do
 	rule '' do |t|
 		fail "'#{t.name}' already exists" if File.exists?(t.name)
@@ -73,10 +47,6 @@ task :create do
 	end
 end
 
-# import user-level tasks
-import "#{ENV['HOME']}/.rotetasks.rf" if File.exists?("#{ENV['HOME']}/.rotetasks.rf")
-import 'local.rf' if File.exists?('local.rf')
-
 # DEPRECATED - publish.rf will be unsupported. 			vv0.2.3		v-0.5   1
 import 'publish.rf' if File.exists?('publish.rf')
 

data/lib/rote/filters.rb

@@ -0,0 +1,10 @@
+#--
+# Require all filters
+# (c)2005 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 $
+#++
+
+# will require 'base' but it'd get required anyway...
+Dir[File.join(File.dirname(__FILE__), 'filters/*.rb')].each { |f| require f }

data/lib/rote/filters/base.rb

@@ -0,0 +1,135 @@
+#--
+# Baseclass for Rote filters
+# (c)2005 Ross Bamford (and contributors)
+#
+# See 'rote.rb' or LICENSE for licence information.
+# $Id: base.rb,v 1.2 2005/12/12 02:45:24 roscopeco Exp $
+#++
+module Rote
+  module Filters
+  
+    # Match/extract 
+    #
+    #   #:code#args# 
+    #   ... body ... 
+    #   #code# 
+    #
+    # to :code, args, body
+    MACRO_RE = /^\s*\#\:([a-z]+)(?:\#([a-z]*))?\#\s*^(.*?)$\s*\#\:\1\#(?:\2\#)?\s*$/m
+    
+    #####
+    ## Baseclass from which Rote filters can be derived if
+    ## they want to process text without macros. This class
+    ## replaces macro tags/bodies with simple placeholders,
+    ## containing only characters [a-z0-9] before passing
+    ## it the text to the block. On return, macro markers 
+    ## are replaced with the corresponding (numbered) original
+    ## macro body. 
+    class TextFilter
+      attr_accessor :handler_blk, :macro_data
+      
+      # Create a new TextFilter. The supplied block will be called
+      # with the text to be rendered, with all macros replaced
+      # by plain-text macro markers:
+      #
+      #   { |text, page| "replacement" }
+      def initialize(&handler)
+        @handler_blk = handler
+        @macro_data = []
+      end
+    
+      def filter(text, page)
+        # we need to remove any macros to stop them being touched
+        n = -1        
+        tmp = text.gsub(MACRO_RE) do
+          macro_data << $&
+          # we need make the marker a 'paragraph'
+          "\nxmxmxmacro#{n += 1}orcamxmxmx\n"
+        end
+        
+        tmp = handler(tmp,page)
+      
+        # Match the placeholder, including any (and greedily all) markup that's
+        # been placed before or after it, and put the macro text back.
+        tmp.gsub(/(?:<.*>)?xmxmxmacro(\d+)orcamxmxmx(?:<.*>)?/) { @macro_data[$1.to_i] }      
+      end  
+      
+      protected
+            
+      # Calls the handler block. Subclasses may override this rather
+      # than use a block.
+      def handler(tmp,page)
+        handler_blk[tmp,page] if handler_blk
+      end  
+    end
+    
+    #####
+    ## Baseclass from which Rote filters can be derived if
+    ## you want some help with macro replacement.
+    class MacroFilter
+    
+      # An array of macro names supported by this filter.
+      # This can be used to selectively disable individual
+      # macro support.
+      attr_accessor :macros
+      
+      # Block that will be called for each supported macro
+      # in the filtered text. Like:
+      #
+      #   { |macro, args, body| "replacement" }
+      #
+      # The presence of a block precludes the use of any
+      # +macro_xxxx+ methods on the subclass.      
+      attr_accessor :handler_blk
+      
+      # Create a new macro filter. If a three-arg block is passed,
+      # it will be called for each macro with a name that exists
+      # in the +macros+ array. Otherwise, macros will be sought
+      # as methods (e.g. +macro_code+). If an array of names isn't
+      # passed, a search such methods will be used to populate
+      # the names array.
+      def initialize(macros = nil, code_re = MACRO_RE, &handler_blk)
+        @handler_blk = handler_blk
+        @macros = macros || reflect_macro_names
+        @code_re = code_re
+      end      
+           
+      def filter(text,page)
+        # Just go through, subbing with block if this is
+        # our macro, or with the original match if not.
+        text.gsub(@code_re) do
+          if macros.detect { |it| it.to_s == $1 }
+            # Handler might refuse the macro (bad args, etc)
+            handler($1,$2,$3) || $&
+          else
+            $&
+          end        
+        end
+      end
+      
+      protected
+      
+      # Calls the handler block, or attempts to call a method named
+      # 'macro_XXXX' where 'XXXX' is the name of the macro.
+      # Macro methods take two arguments -args and body. 
+      # Name is implied by method that is invoked.
+      def handler(macro,args,body)
+        if handler_blk
+          handler_blk[macro,args,body] 
+        elsif respond_to?(meth = "macro_#{macro}")
+          send(meth, args, body)            # name implied by method
+        end          
+      end
+      
+      private
+      
+      # inits the macro array from defined 'macro_' methods if no array is passed.
+      def reflect_macro_names
+        [methods, private_methods, singleton_methods, protected_methods].inject([]) do |arr,m|
+          arr += m.grep(/macro_([a-z0-9]+)/) { $1 } 
+        end
+      end
+    end
+  end
+end
+      

data/lib/rote/filters/rdoc.rb

@@ -0,0 +1,25 @@
+#--
+# Rote page class
+# (c)2005 Ross Bamford (and contributors)
+#
+# See 'rote.rb' or LICENSE for licence information.
+# $Id: rdoc.rb,v 1.2 2005/12/12 02:45:24 roscopeco Exp $
+#++
+
+require 'rdoc/markup/simple_markup'
+require 'rdoc/markup/simple_markup/to_html'
+
+module Rote
+  module Filters
+  
+    #####
+    ## Page filter supporting RDoc markup.     
+    class RDoc < TextFilter
+      def initialize(markup = SM::SimpleMarkup.new, output = SM::ToHtml.new)
+        @markup = markup
+        @output = output
+        self.handler_blk = proc { |text,page| @markup.convert(text, @output) }
+      end      
+    end
+  end
+end 

data/lib/rote/filters/redcloth.rb

@@ -0,0 +1,40 @@
+#--
+# Rote filter for RedCloth
+# (c)2005 Ross Bamford (and contributors)
+#
+# See 'rote.rb' or LICENSE for licence information.
+# $Id: redcloth.rb,v 1.2 2005/12/12 02:45:24 roscopeco Exp $
+#++
+
+require 'redcloth'
+require 'rote/filters/base'
+
+module Rote
+  module Filters
+    #####
+    ## Page filter that converts plain-text formatting to HTML using 
+    ## RedCloth. This allows both Textile and Markdown formatting
+    ## to be used with any page.
+    class RedCloth < TextFilter
+    
+      # Create a new filter instance. The supplied options are passed
+      # directly to RedCloth. The most common are :textile and
+      # :markdown - See RedCloth docs for a full list.
+      #
+      # If no options are supplied, :textile is assumed.
+      def initialize(*redcloth_opts)
+        super()  
+        @redcloth_opts = redcloth_opts
+        raise "RedCloth is not available" unless defined?(RedCloth)        
+      end      
+      
+      def handler(text,page)
+        rc = ::RedCloth.new(text)        
+        # hack around a RedCloth warning
+        rc.instance_eval { @lite_mode = false }  
+        rc.to_html(*@redcloth_opts) 
+      end      
+    end    
+  end
+end
+    

data/lib/rote/filters/syntax.rb

@@ -0,0 +1,38 @@
+#--
+# Rote filter with syntax highlighting
+# (c)2005 Ross Bamford (and contributors)
+#
+# See 'rote.rb' or LICENSE for licence information.
+# $Id: syntax.rb,v 1.2 2005/12/12 02:45:24 roscopeco Exp $
+#++
+  
+require 'syntax'
+require 'syntax/convertors/html'
+require 'rote/filters/base'
+
+module Rote
+  module Filters
+    
+    #####
+    ## Page filter that supports syntax highlighting for Ruby code
+    ## via the +Syntax+ library. Code is expected to be in the 
+    ## following format:
+    ##
+    ##   #:code#ruby#
+    ##     def amethod(arg)
+    ##       puts arg
+    ##     end
+    ##   #:code#
+    ##  
+    class Syntax < MacroFilter
+      def initialize(macro_re = MACRO_RE)
+        super([:code],macro_re)
+      end      
+      
+      def macro_code(lang,body)
+        converter = ::Syntax::Convertors::HTML.for_syntax(lang)
+        "<pre class='#{lang}'><code>#{converter.convert(body,false)}</code></pre>"
+      end      
+    end      
+  end 
+end

data/lib/rote/filters/tidy.rb

@@ -0,0 +1,55 @@
+#--
+# Rote filter for HTML Tidy
+# (c)2005 Ross Bamford (and contributors)
+#
+# See 'rote.rb' or LICENSE for licence information.
+# $Id: tidy.rb,v 1.2 2005/12/12 02:45:24 roscopeco Exp $
+#++
+
+module Rote
+  module Filters  
+  
+    #####
+    ## Post filter that runs HTML Tidy on the laid-out page to correct and
+    ## clean up HTML in the output. This filter can be used with any of
+    ## the _asXXXX_ formats supported by Tidy. 
+    ##
+    ## Note that this filter requires the 'tidy' command, and should be 
+    ## added to the +post_filters+ array, in contrast to most of the 
+    ## other filters which are page filters.
+    ##
+    ## If 'tidy' isn't in your path you'll need to specify it here or
+    ## via a TIDYCMD environment variable.
+    class Tidy
+    
+      # Create a new filter instance, using the specified output format,
+      # and optionally a custom 'tidy' command and options.    
+      def initialize(format = :xhtml, tidycmd = nil, tidyopts = '-q') 
+        @tidycmd = tidycmd || ENV['TIDYCMD'] || (PLATFORM =~ /mswin/ ? 'tidy.exe' : 'tidy')
+          # TODO windows 'tidy.exe' correct?
+          
+        @tidyopts = tidyopts
+        @format = format
+      end
+      
+      attr_accessor :format, :tidyopts, :tidycmd
+      
+      def filter(text, page)
+        # TODO need to properly capture and log warnings here
+        result = IO.popen("#{@tidycmd} #{self.tidyopts} -f tidy.log -as#{self.format}","r+") do |fp|
+           Thread.new { fp.write(text); fp.close_write }
+           fp.read
+        end
+        
+        if $?.exitstatus < 2
+          result
+        else
+          warn 'Tidy command failed (exitstatus: $?)'
+          text
+        end
+      end
+      
+    end
+  end
+end
+