webby 0.6.0 → 0.7.0

data/lib/webby/filters/graphviz.rb

@@ -1,4 +1,4 @@
-# $Id: graphviz.rb 61 2007-12-04 05:48:23Z tim_pease $
+# $Id: graphviz.rb 71 2007-12-13 05:45:53Z tim_pease $
 
 require 'hpricot'
 require 'fileutils'
@@ -25,9 +25,9 @@ module Filters
 #     }
 #     </graphviz>
 #
-# If the DOT script contains *URL* or *href* statements on any of the nodes
+# If the DOT script contains *URL* or *href* cursorments on any of the nodes
 # or edges, then an image map will be generated and the image will be
-# "clikcable" in the webpage. If *URL* or *href* statements do not appear in
+# "clikcable" in the webpage. If *URL* or *href* cursorments do not appear in
 # the DOT script, then a regular image will be inserted into the webpage.
 #
 # The image is inserted into the page using an HTML <img /> tag. A
@@ -60,7 +60,6 @@ class Graphviz
   # output string returned by the Graphviz filter.
   #
   def initialize( str, filters = nil )
-    @log = ::Logging::Logger[self]
     @str = str
     @filters = filters
 
@@ -82,11 +81,19 @@ class Graphviz
     doc = Hpricot(@str)
     doc.search('//graphviz') do |gviz|
       
-      text = gviz.inner_html.strip   # the DOT script to process
       path = gviz['path']
       cmd  = gviz['cmd'] || 'dot'
       type = gviz['type'] || 'png'
+      text = gviz.inner_html.strip   # the DOT script to process
+
+      # if we don't have a DOT script, then replace it with
+      # the empty text and move on to the next graphviz tags
+      if text.empty?
+        gviz.swap text
+        next
+      end
 
+      # ensure the requested graphviz command actually exists
       %x[#{cmd} -V 2>&1]
       unless 0 == $?.exitstatus
         raise NameError, "'#{cmd}' not found on the path"
@@ -102,7 +109,7 @@ class Graphviz
       # generate the image filename based on the path, graph name, and type
       # of image to generate
       image_fn = path.nil? ? name.dup : File.join(path, name)
-      image_fn << '.' << type
+      image_fn = File.join('', image_fn) << '.' << type
 
       # create the HTML img tag
       out = "<img src=\"#{image_fn}\""
@@ -163,12 +170,19 @@ class Graphviz
   #
   def error_check
     if File.size(@err.path) != 0
-      @log.error File.read(@err.path).strip
-      raise Error
+      msg = "\n" << File.read(@err.path).strip
+      raise Error, msg
     end
   end
 
 end  # class Graphviz
+
+# Render text into iamges via the Graphviz programs.
+#
+register :graphviz do |input, cursor|
+  Filters::Graphviz.new(input, cursor.remaining_filters).to_html
+end
+
 end  # module Filters
 end  # module Webby
 

data/lib/webby/filters/haml.rb

@@ -0,0 +1,16 @@
+# $Id: haml.rb 68 2007-12-09 07:45:37Z tim_pease $
+
+try_require 'haml'
+
+# Render text via the Haml library
+Webby::Filters.register :haml do |input, cursor|
+  opts = cursor.page.haml_options || {}
+  opts[:locals] ||= {}
+  opts[:locals].merge!(
+    :page => cursor.renderer.page,
+    :pages => cursor.renderer.pages
+  )
+  Haml::Engine.new(input, opts).to_html
+end
+
+# EOF

data/lib/webby/filters/markdown.rb

@@ -0,0 +1,10 @@
+# $Id: markdown.rb 68 2007-12-09 07:45:37Z tim_pease $
+
+try_require 'bluecloth'
+
+# Render text via markdown using the BlueCloth library.
+Webby::Filters.register :markdown do |input|
+  BlueCloth.new(input).to_html
+end
+
+# EOF

data/lib/webby/filters/sass.rb

@@ -0,0 +1,11 @@
+# $Id: sass.rb 68 2007-12-09 07:45:37Z tim_pease $
+
+try_require 'sass'
+
+# Render text via the Sass library (part of Haml)
+Webby::Filters.register :sass do |input, cursor|
+  opts = cursor.page.sass_options || {}
+  Sass::Engine.new(input, opts).render
+end
+
+# EOF

data/lib/webby/filters/textile.rb

@@ -0,0 +1,10 @@
+# $Id: textile.rb 71 2007-12-13 05:45:53Z tim_pease $
+
+try_require 'redcloth'
+
+# Render text via textile using the RedCloth library.
+Webby::Filters.register :textile do |input|
+  RedCloth.new(input, %w(no_span_caps)).to_html
+end
+
+# EOF

data/lib/webby/filters/tidy.rb

@@ -1,4 +1,4 @@
-# $Id: tidy.rb 61 2007-12-04 05:48:23Z tim_pease $
+# $Id: tidy.rb 68 2007-12-09 07:45:37Z tim_pease $
 
 require 'fileutils'
 require 'tempfile'
@@ -65,6 +65,13 @@ class Tidy
   end
 
 end  # class Tidy
+
+# Render html into html/xhtml via the Tidy program
+#
+register :tidy do |input|
+  Filters::Tidy.new(input).process
+end
+
 end  # module Filters
 end  # module Webby
 

data/lib/webby/filters.rb

@@ -0,0 +1,90 @@
+# $Id: filters.rb 68 2007-12-09 07:45:37Z tim_pease $
+
+module Webby
+module Filters
+   
+  class << self
+    
+    # Register a handler for a filter
+    def register( filter, &block )
+      handlers[filter.to_s] = block
+    end
+    
+    # Process input through filters
+    def process( renderer, page, input )
+      # Start a new cursor for this page
+      Cursor.new(renderer, page).start_for(input)
+    end
+    
+    # Access a filter handler
+    def []( name )
+      handlers[name]
+    end
+      
+    #######
+    private
+    #######
+
+    # The registered filter handlers
+    def handlers
+      @handlers ||= {}
+    end
+    
+    # Instances of this class handle processing a set of filters
+    # for a given renderer and page.
+    # Note: The instance is passed as the second argument to filters
+    #       that require two parameters and can be used to access 
+    #       information on the renderer, page, or filters being
+    #       processed.
+    class Cursor
+      
+      attr_reader :renderer, :page, :filters
+      def initialize(renderer, page)
+        @renderer, @page = renderer, page
+        @filters = Array(page.filter)
+        @log = Logging::Logger[Webby::Renderer]
+        @processed = 0
+      end
+      
+      def start_for(input)
+        filters.inject(input) do |result, filter|
+          handler = Filters[filter]
+          args = [result, self][0, handler.arity]
+          handle(filter, handler, *args)
+        end
+      end
+      
+      # The list of filters yet to be processed
+      def remaining_filters
+        filters[@processed..-1]
+      end
+      
+      # The name of the current filter
+      def current_filter
+        filters[@processed]
+      end
+      
+      #######
+      private
+      #######
+
+      # Process arguments through a single filter
+      def handle(filter, handler, *args)
+        result = handler.call(*args)
+        @processed += 1
+        result
+      rescue NameError => e
+        @log.fatal "Name error in filter `#{filter}' (missing dependency?): #{e.message}"
+        exit 1
+      rescue => e
+        @log.fatal "Error in filter `#{filter}': #{e.message}"
+        exit 1
+      end
+      
+    end  # class Cursor
+  end  # class << self
+    
+end  # module Filters
+end  # module Webby
+
+# EOF

data/lib/webby/helpers/tag_helper.rb

@@ -0,0 +1,61 @@
+require 'erb'
+require 'set'
+
+class ERB
+  module Util
+    HTML_ESCAPE = { '&' => '&amp;', '"' => '&quot;', '>' => '&gt;', '<' => '&lt;' }
+
+    def html_escape(s)
+      s.to_s.gsub(/[&\"><]/) { |special| HTML_ESCAPE[special] }
+    end
+  end
+end
+
+module Webby
+module Helpers #:nodoc:
+
+# Provides methods to generate HTML tags programmatically.
+# By default, they output XHTML compliant tags.
+#
+module TagHelper
+  include ERB::Util
+
+  BOOLEAN_ATTRIBUTES = Set.new(%w(disabled readonly multiple))
+
+  # Returns an escaped version of +html+ without affecting existing escaped
+  # entities.
+  #
+  # ==== Examples
+  #   escape_once("1 > 2 &amp; 3")
+  #   # => "1 &lt; 2 &amp; 3"
+  #
+  #   escape_once("&lt;&lt; Accept & Checkout")
+  #   # => "&lt;&lt; Accept &amp; Checkout"
+  #
+  def escape_once( html )
+    html.to_s.gsub(/[\"><]|&(?!([a-zA-Z]+|(#\d+));)/) { |special| ERB::Util::HTML_ESCAPE[special] }
+  end
+
+  private
+    def tag_options( options, escape = true )
+      unless options.empty?
+        attrs = []
+        if escape
+          options.each do |key, value|
+            next if value.nil?
+            key = key.to_s
+            value = BOOLEAN_ATTRIBUTES.include?(key) ? key : escape_once(value)
+            attrs << %Q(#{key}="#{value}")
+          end
+        else
+          attrs = options.map {|key, value| %Q(#{key}="#{value}")}
+        end
+        %Q( #{attrs.sort * ' '}) unless attrs.empty?
+      end
+    end
+
+end  # module TagHelper
+end  # module Helpers
+end  # module Webby
+
+# EOF

data/lib/webby/helpers/url_helper.rb

@@ -0,0 +1,162 @@
+# $Id: url_helper.rb 75 2007-12-20 23:10:19Z tim_pease $
+
+module Webby
+module Helpers #:nodoc:
+
+#
+#
+module UrlHelper
+
+  # call-seq:
+  #    url_for( string, opts = {} ) 
+  #    url_for( page, opts ={} )
+  #
+  # Options
+  # 
+  #    :escape  => determins whether the returned URL will be HTML escaped
+  #                or not (+true+ by default)
+  #    :anchor  => specifies the anchor name to be appended to the path
+  #
+  def url_for( *args )
+    opts = Hash === args.last ? args.pop : {}
+    obj = args.first
+
+    anchor = opts.delete(:anchor)
+    escape = opts.has_key?(:escape) ? opts.delte(:escape) : true
+
+    url = Webby::Resource === obj ? obj.url : obj.to_s
+    url = escape_once(url) if escape
+    url << "#" << anchor if anchor
+
+    return url
+  end
+
+  def url_for_page( opts = {} )
+    opts = opts.symbolize_keys
+    url_opts = opts.delete(:url)
+
+    p = @pages.find(opts)
+    raise Webby::Renderer::Error,
+          "could not find requested page: #{opts.inspect}" if p.nil?
+
+    self.url_for(p, url_opts)
+  end
+
+  #
+  #
+  def link_to( name, *args )
+    opts = Hash === args.last ? args.pop : {}
+    url = args.first
+    attrs = opts.delete(:attrs)
+
+    url = case url
+      when String
+        url
+      when Webby::Resource
+        self.url_for(url, opts)
+      when :back
+        'javascript:history.back()'
+      else
+        self.url_for(name, opts)
+      end
+
+    if attrs
+      html_opts = attrs.stringify_keys
+      href = html_opts.has_key? 'href'
+      attrs = tag_options(html_opts)
+    else
+      href = false
+      attrs = nil
+    end
+
+    href_attr = href ? nil : %Q(href="#{url}")
+    "<a #{href_attr}#{attrs}>#{name || url}</a>"
+  end
+
+  # call-seq:
+  #    link_to_page( name )
+  #    link_to_page( :key => value )
+  #    link_to_page( name, :key => value )
+  #    link_to_page( page )
+  #
+  # Creates a link tag of the given _name_ using a URL created by finding
+  # the associated page from the key/value pairs. If the key/value pairs are
+  # omitted, the _name_ is used in conjunction with the default site +find_by+
+  # attribute. If the _name_ is omitted, then either the page +title+
+  # attribute or the page +filename+ attribute is used as the name (in that
+  # order of preference).
+  #
+  # Pages are found using key/value pairs. The key is any of the page
+  # attributes, and the value is what that attribute should be. Any number
+  # of key/value pairs can be included, but all values must equal the
+  # corresponding page attributes for a match to be found -- i.e. the
+  # comparisons are joined by AND operations to determine a match.
+  #
+  # In the absence of any key/value pairs -- just a name was given -- then
+  # the default site +find_by+ attribute is used, and the name is compared
+  # against this attribute from the page. The default +find_by+ attribue is
+  # set in the Rakefile or in the <tt>Webby.site.find_by</tt> parameter.
+  #
+  # Several options can be passed to the method to determin how URLs are
+  # created and to specify any HTML attributes on the returned link tag. The
+  # URL options are given as a hash to the <tt>:url</tt> key. The HTML
+  # attributes are given as a hash to the <tt>:attrs</tt> key.
+  #
+  # See the +url_for+ method for a desciption of the <tt>:url</tt> options.
+  # See the +link_to+ method for a description of the <tt>:attrs</tt>
+  # options.
+  #
+  # ==== Examples
+  #
+  def link_to_page( *args )
+    self.link_to(*_find_page(args))
+  end
+
+  #
+  #
+  def link_to_page_unless_current( *args )
+    name, page, link_opts = _find_page(args)
+    return name if @page == page
+
+    self.link_to(name, page, link_opts)
+  end
+
+  
+  private
+
+  # call-seq:
+  #    _find_page( name, opts = {}  )
+  #    _find_page( :key => value, [:key => value, ...], opts = {}  )
+  #    _find_page( name, :key => value, [:key => value, ...], opts = {} )
+  #    _find_page( page, opts = {} )
+  #
+  # Returns an array of the [name, page, options]. 
+  #
+  def _find_page( args )
+    raise ArgumentError, 'wrong number of arguments (0 for 1)' if args.empty?
+
+    opts = Hash === args.last ? args.pop : {}
+    name = args.first
+    link_opts = opts.delete(:url) || {}
+    link_opts[:attrs] = opts.delete(:attrs)
+
+    if Webby::Resource === name
+      p, name = name, nil
+    elsif opts.empty? && name
+      p = @pages.find(Webby.site.find_by.to_sym => name)
+    else
+      p = @pages.find(opts)
+    end
+
+    raise Webby::Renderer::Error,
+          "could not find requested page: #{opts.inspect}" if p.nil?
+
+    name = h(p.title || p.filename) if name.nil?
+    return [name, p, link_opts]
+  end
+
+end  # module UrlHelper
+end  # module Helpers
+end  # module Webby
+
+# EOF

data/lib/webby/pages_db.rb

@@ -1,4 +1,4 @@
-# $Id: pages_db.rb 46 2007-11-27 03:31:29Z tim_pease $
+# $Id: pages_db.rb 67 2007-12-09 00:49:26Z tim_pease $
 
 module Webby
 
@@ -78,7 +78,7 @@ class PagesDB
   #
   # Options include:
   #
-  #    :all          => true
+  #    :all
   #    :in_directory => 'directory'
   #
   # Examples:
@@ -87,19 +87,18 @@ class PagesDB
   #    pages_db.find( :filename => 'index', :in_directory => 'foo/bar' )
   #
   #    # find all resources named "widgets" whose color is "blue"
-  #    pages_db.find( :name => 'widgets', :color => 'blue', :all => true )
+  #    pages_db.find( :all, :name => 'widgets', :color => 'blue' )
   #
   #    # find all resources created in the past week
-  #    pages_db.find( :all => true ) do |resource|
+  #    pages_db.find( :all ) do |resource|
   #      resource.created_at > Time.now - (7 * 24 * 3600)
   #    end
   #
-  def find( opts = {}, &block )
-    find_all = if opts.has_key?(:all) then opts.delete(:all)
-               else false end
+  def find( *args, &block )
+    opts = Hash === args.last ? args.pop : {}
+    find_all = args.include? :all
 
-    dir = if opts.has_key?(:in_directory) then opts.delete(:in_directory)
-          else nil end
+    dir = opts.has_key?(:in_directory) ? opts.delete(:in_directory) : nil
     if dir && !@db.has_key?(dir)
       raise RuntimeError, "unknown directory '#{dir}'"
     end

data/lib/webby/renderer.rb

@@ -1,4 +1,4 @@
-# $Id: renderer.rb 61 2007-12-04 05:48:23Z tim_pease $
+# $Id: renderer.rb 68 2007-12-09 07:45:37Z tim_pease $
 
 require 'erb'
 try_require 'bluecloth'
@@ -22,6 +22,10 @@ module Webby
 #
 class Renderer
   include ERB::Util
+  include Webby::Helpers::TagHelper
+  include Webby::Helpers::UrlHelper
+
+  class Error < StandardError; end    # :nodoc:
 
   # call-seq:
   #    Renderer.write( page )
@@ -37,7 +41,7 @@ class Renderer
       ::File.open(page.destination, 'w') do |fd|
         fd.write renderer.layout_page
       end
-      break unless renderer.next_page
+      break unless renderer.__send__(:next_page)
     }
   end
 
@@ -79,11 +83,7 @@ class Renderer
       break if lyt.nil?
 
       @content, str = str, ::Webby::File.read(lyt.path)
-
-      Array(lyt.filter).each do |filter|
-        str = self.send(filter + '_filter', str)
-      end
-
+      str = Filters.process(self, lyt, str)
       @content, obj = nil, lyt
     end
 
@@ -97,13 +97,7 @@ class Renderer
   # determined from the page's meta-data.
   #
   def render_page
-    str = ::Webby::File.read(@page.path)
-
-    Array(@page.filter).each do |filter|
-      str = self.send(filter + '_filter', str)
-    end
-
-    str
+    Filters.process(self, @page, ::Webby::File.read(@page.path))
   end
 
   # call-seq:
@@ -128,6 +122,18 @@ class Renderer
     @pager.each &block
   end
 
+  # call-seq:
+  #    get_binding    => binding
+  #
+  # Returns the current binding for the renderer.
+  #
+  def get_binding
+    binding
+  end
+
+
+  private
+
   # call-seq:
   #    next_page    => true or false
   #
@@ -149,105 +155,6 @@ class Renderer
     true
   end
 
-  # Render text via ERB using the built in ERB library.
-  #
-  def erb_filter( str )
-    b = binding
-    ERB.new(str, nil, '-').result(b)
-  end
-
-  # Render text via markdown using the BlueCloth library.
-  #
-  def markdown_filter( str )
-    BlueCloth.new(str).to_html
-  rescue NameError => err
-    @log.error 'markdown filter failed (BlueCloth not installed?)'
-    @log.debug err
-    exit
-  end
-
-  # Render text via textile using the RedCloth library.
-  #
-  def textile_filter( str )
-    RedCloth.new(str).to_html
-  rescue NameError => err
-    @log.error 'textile filter failed (RedCloth not installed?)'
-    @log.debug err
-    exit
-  end
-
-  # Render text via the CodeRay syntax highlighter library.
-  #
-  def coderay_filter( str )
-    filters = nil
-
-    if Array === @page.filter
-      idx = @page.filter.index('coderay') + 1
-      filters = @page.filter.slice(idx..-1)
-    end
-
-    Filters::CodeRay.new(str, filters).to_html
-  rescue NameError => err
-    @log.error 'coderay filter failed (CodeRay not installed?)'
-    @log.debug err
-    exit
-  end
-
-  # Render text into iamges via the Graphviz programs.
-  #
-  def graphviz_filter( str )
-    filters = nil
-
-    if Array === @page.filter
-      idx = @page.filter.index('graphviz') + 1
-      filters = @page.filter.slice(idx..-1)
-    end
-
-    Filters::Graphviz.new(str, filters).to_html
-  rescue NameError => err
-    @log.error 'graphviz filter failed (Graphviz not installed?)'
-    @log.debug err
-    exit
-  rescue Filters::Graphviz::Error
-    exit
-  end
-
-  # Render html into html/xhtml via the Tidy program
-  #
-  def tidy_filter( str )
-    Filters::Tidy.new(str).process
-  rescue NameError => err
-    @log.error 'tidy filter failed (Tidy not installed?)'
-    @log.debug err
-    exit
-  rescue Filters::Tidy::Error
-    exit
-  end
-
-  # Render text via the Haml library
-  #
-  def haml_filter( str )
-    opts = @page.haml_options || {}
-    opts[:locals] ||= {}
-    opts[:locals].merge!({:page => @page, :pages => @pages})
-    Haml::Engine.new(str, opts).to_html
-  rescue NameError => err
-    @log.error 'haml filter failed (Haml not installed?)'
-    @log.debug err
-    exit
-  end
-
-  # Render text via the Sass library (part of Haml)
-  #
-  def sass_filter( str )
-    opts = @page.sass_options || {}
-    Sass::Engine.new(str, opts).render
-  rescue NameError => err
-    @log.error 'sass filter failed (Haml not installed?)'
-    @log.debug err
-    exit
-  end
-
 end  # class Renderer
 end  # module Webby