TwP-webby 0.9.0

data/lib/webby/helpers/coderay_helper.rb

@@ -0,0 +1,69 @@
+if try_require 'coderay'
+require 'enumerator'
+
+module Webby::Helpers
+module CodeRayHelper
+
+  # The +coderay+ method applies syntax highlighting to source code embedded
+  # in a webpage. The CodeRay highlighting engine is used for the HTML
+  # markup of the source code. The page sections to be highlighted are given
+  # as blocks of text to the +coderay+ method.
+  #
+  # Options can be passed to the CodeRay engine via attributes in the
+  # +coderay+ method.
+  #
+  #    <% coderay( :lang => "ruby", :line_numbers => "inline" ) do -%>
+  #    # Initializer for the class.
+  #    def initialize( string )
+  #      @str = stirng
+  #    end
+  #    <% end -%>
+  #    
+  # The supported CodeRay options are the following:
+  #
+  #    :lang               : the language to highlight (ruby, c, html, ...)
+  #    :line_numbers       : include line numbers in 'table', 'inline',
+  #                          or 'list'
+  #    :line_number_start  : where to start with line number counting
+  #    :bold_every         : make every n-th number appear bold
+  #    :tab_width          : convert tab characters to n spaces
+  #
+  def coderay( *args, &block )
+    opts = args.last.instance_of?(Hash) ? args.pop : {}
+
+    text = capture_erb(&block)
+    return if text.empty?
+
+    defaults = ::Webby.site.coderay
+    lang = opts.getopt(:lang, defaults[:lang]).to_sym
+
+    cr_opts = {}
+    %w(line_numbers       to_sym
+       line_number_start  to_i
+       bold_every         to_i
+       tab_width          to_i).each_slice(2) do |key,convert|
+      key = key.to_sym
+      val = opts.getopt(key, defaults[key])
+      next if val.nil?
+      cr_opts[key] = val.send(convert)
+    end
+
+    #cr.swap(CodeRay.scan(text, lang).html(opts).div)
+    out = '<div class="CodeRay"><pre>'
+    out << ::CodeRay.scan(text, lang).html(cr_opts)
+    out << '</pre></div>'
+
+    # put some guards around the output (specifically for textile)
+    out = _guard(out)
+
+    concat_erb(out, block.binding)
+    return
+  end
+end  # module CodeRayHelper
+
+register(CodeRayHelper)
+
+end  # module Webby::Helpers
+end  # try_require
+
+# EOF

data/lib/webby/helpers/graphviz_helper.rb

@@ -0,0 +1,136 @@
+require 'fileutils'
+require 'tempfile'
+
+module Webby::Helpers
+module GraphvizHelper
+
+  # call-seq:
+  #    GraphvizHelper.error_check( file )
+  #
+  # Check the temporary error file to see if it contains any error messages
+  # from the graphviz program. If it is not empty, then read the contents
+  # and log an error message and raise an exception.
+  #
+  def self.error_check( file )
+    if ::File.size(file.path) != 0
+      msg = "\n" << ::File.read(file.path).strip
+      raise ::Webby::Error, msg
+    end
+  end
+
+  # The +graphviz+ method processes DOT scripts in a webpage and replaces them
+  # with generated image files. The page sections to be processed are given
+  # as blocks of text to the +graphviz+ method.
+  #
+  # Options can be passed to the Graphviz program using attributes in the
+  # +graphviz+ method.
+  #
+  #     <% graphviz( :path => "images", :type => "gif", cmd => "dot" ) do %>
+  #     digraph graph_1 {
+  #       graph [URL="default.html"]
+  #       a [URL="a.html"]
+  #       b [URL="b.html"]
+  #       c [URL="c.html"]
+  #       a -> b -> c
+  #       a -> c
+  #     }
+  #     <% end %>
+  #
+  # If the DOT script contains *URL* or *href* attributes 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* attributes 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
+  # corresponding <map>...</map> element will be inserted if needed.
+  #
+  # The supported Graphviz options are the following:
+  #
+  #    :path     : where generated images will be stored
+  #                [default is "/"]
+  #    :type     : the type of image to generate (png, jpeg, gif)
+  #                [default is png]
+  #    :cmd      : the Graphviz command to use when generating images
+  #                (dot, neato, twopi, circo, fdp) [default is dot]
+  #
+  #    the following options are passed as-is to the generated <img /> tag
+  #    :style    : CSS styles to apply to the <img />
+  #    :class    : CSS class to apply to the <img />
+  #    :id       : HTML identifier
+  #    :alt      : alternate text for the <img />
+  #
+  def graphviz( *args, &block )
+    opts = args.last.instance_of?(Hash) ? args.pop : {}
+
+    text = capture_erb(&block)
+    return if text.empty?
+
+    # create a temporary file for holding any error messages
+    # from the graphviz program
+    err = Tempfile.new('graphviz_err')
+    err.close
+
+    defaults = ::Webby.site.graphviz
+    path = opts.getopt(:path, defaults[:path])
+    cmd  = opts.getopt(:cmd, defaults[:cmd])
+    type = opts.getopt(:type, defaults[:type])
+
+    # pull the name of the graph|digraph out of the DOT script
+    name = text.match(%r/\A\s*(?:strict\s+)?(?:di)?graph\s+([A-Za-z_][A-Za-z0-9_]*)\s+\{/o)[1]
+
+    # see if the user includes any URL or href attributes
+    # if so, then we need to create an imagemap
+    usemap = text.match(%r/(?:URL|href)\s*=/o) != nil
+
+    # 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 = ::File.join('', image_fn) << '.' << type
+
+    # create the HTML img tag
+    out = "<img src=\"#{image_fn}\""
+
+    %w[class style id alt].each do |atr|
+      val = opts.getopt(atr)
+      next if val.nil?
+      out << " %s=\"%s\"" % [atr, val]
+    end
+
+    out << " usemap=\"\##{name}\"" if usemap
+    out << " />\n"
+
+    # generate the image map if needed
+    if usemap
+      IO.popen("#{cmd} -Tcmapx 2> #{err.path}", 'r+') do |io|
+        io.write text
+        io.close_write
+        out << io.read
+      end
+      GraphvizHelper.error_check(err)
+    end
+
+    # generate the image using graphviz -- but first ensure that the
+    # path exists
+    out_dir = ::Webby.site.output_dir
+    out_file = ::File.join(out_dir, image_fn)
+    FileUtils.mkpath(::File.join(out_dir, path)) unless path.nil?
+    cmd = "#{cmd} -T#{type} -o #{out_file} 2> #{err.path}"
+
+    IO.popen(cmd, 'w') {|io| io.write text}
+    GraphvizHelper.error_check(err)
+
+    # put some guards around the output (specifically for textile)
+    out = _guard(out)
+
+    concat_erb(out, block.binding)
+    return
+  end
+end  # module GraphvizHelper
+
+if cmd_available? %w[dot -V]
+  register(GraphvizHelper)
+end
+
+end  # module Webby::Helpers
+
+# EOF

data/lib/webby/helpers/tag_helper.rb

@@ -0,0 +1,65 @@
+require 'erb'
+require 'set'
+
+# :stopdoc:
+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
+# :startdoc:
+
+module Webby::Helpers
+
+# 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
+
+register(TagHelper)
+
+end  # module Webby::Helpers
+
+# EOF

data/lib/webby/helpers/tex_img_helper.rb

@@ -0,0 +1,133 @@
+require Webby.libpath(*%w[webby stelan mktemp])
+require 'fileutils'
+
+module Webby::Helpers
+module TexImgHelper
+
+  # The +tex2img+ method converts a a section of mathematical TeX script
+  # into an image and embeds the resulting image into the page. The TeX
+  # engine must be installed on your system along with the ImageMagick
+  # +convert+ program.
+  #
+  # Options can be passed to the TeX engine via attributes in the
+  # +tex2img+ method.
+  #
+  #    <% tex2img( "wave_eq", :path => "images", :alt => "wave equation" ) do -%>
+  #      $\psi_{tot}(x,-t_0,r) = \frac{1}{(2\pi)^2} \int\!\!\!\int
+  #      \tilde\Psi_{tot}\left(k_x,\frac{c}{2}\sqrt{k_x^2 + k_r^2},r=0\right)$
+  #    <% end -%>
+  #    
+  # The supported TeX options are the following:
+  #
+  #    :path         : where generated images will be stored
+  #                    [default is "/"]
+  #    :type         : the type of image to generate (png, jpeg, gif)
+  #                    [default is png]
+  #    :bg           : the background color of the image (color name,
+  #                    TeX color spec, or #aabbcc) [default is white]
+  #    :fg           : the foreground color of the image (color name,
+  #                    TeX color spec, or #aabbcc) [default is black]
+  #    :resolution   : the desired resolution in dpi (HxV)
+  #                    [default is 150x150]
+  #
+  #    the following options are passed as-is to the generated <img /> tag
+  #    :style    : CSS styles to apply to the <img />
+  #    :class    : CSS class to apply to the <img />
+  #    :id       : HTML identifier
+  #    :alt      : alternate text for the <img />
+  #
+  def tex2img( *args, &block )
+    opts = args.last.instance_of?(Hash) ? args.pop : {}
+    name = args.first
+    raise 'TeX graphics must have a name' if name.nil?
+
+    text = capture_erb(&block)
+    return if text.empty?
+
+    defaults = ::Webby.site.tex2img
+    path = opts.getopt(:path, defaults[:path])
+    type = opts.getopt(:type, defaults[:type])
+    bg   = opts.getopt(:bg, defaults[:bg])
+    fg   = opts.getopt(:fg, defaults[:fg])
+    res  = opts.getopt(:resolution, defaults[:resolution])
+
+    # fix color escaping
+    fg = fg =~ %r/^[a-zA-Z]+$/ ? fg : "\"#{fg}\""
+    bg = bg =~ %r/^[a-zA-Z]+$/ ? bg : "\"#{bg}\""
+
+    # 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 = ::File.join('', image_fn) << '.' << type
+
+    # generate the image using convert -- but first ensure that the
+    # path exists
+    out_dir = ::Webby.site.output_dir
+    out_file = ::File.join('..', out_dir, image_fn)
+    FileUtils.mkpath(::File.join(out_dir, path)) unless path.nil?
+
+    tex = <<-TEX
+      \\nonstopmode
+      \\documentclass{article}
+      \\usepackage[T1]{fontenc}
+      \\usepackage{amsmath,amsfonts,amssymb,wasysym,latexsym,marvosym,txfonts}
+      \\usepackage[pdftex]{color}
+      \\pagestyle{empty}
+      \\begin{document}
+      \\fontsize{12}{24}
+      \\selectfont
+      \\color{white}
+      \\pagecolor{black}
+      \\[
+      #{text}
+      \\]
+      \\end{document}
+    TEX
+    tex.gsub!(%r/\n\s+/, "\n").strip!
+
+    # make a temporarty directory to store all the TeX files
+    pwd = Dir.pwd
+    tmpdir = ::Webby::MkTemp.mktempdir('tex2img_XXXXXX')
+
+    begin
+      Dir.chdir(tmpdir)
+      File.open('out.tex', 'w') {|fd| fd.puts tex}
+      dev_null = test(?e, "/dev/null") ? "/dev/null" : "NUL:"
+
+      %x[pdflatex -interaction=batchmode out.tex &> #{dev_null}]
+
+      convert =  "\\( -density #{res} out.pdf -trim +repage \\) "
+      convert << "\\( -clone 0 -negate -background #{fg} -channel A -combine \\) "
+      convert << "\\( -clone 0 -background #{bg} -channel A -combine \\) "
+      convert << "-delete 0 -compose dst-over -composite #{out_file}"
+      %x[convert #{convert} &> #{dev_null}]
+    ensure
+      Dir.chdir(pwd)
+      FileUtils.rm_rf(tmpdir) if test(?e, tmpdir)
+    end
+
+    # generate the HTML img tag to insert back into the document
+    out = "<img src=\"#{image_fn}\""
+    %w[class style id alt].each do |atr|
+      val = opts.getopt(atr)
+      next if val.nil?
+      out << " %s=\"%s\"" % [atr, val]
+    end
+    out << " />\n"
+
+    # put some guards around the output (specifically for textile)
+    out = _guard(out)
+
+    concat_erb(out, block.binding)
+    return
+  end
+end  # module TexImgHelper
+
+if  cmd_available?(%w[pdflatex --version]) \
+and cmd_available?(%w[convert --help])
+  register(TexImgHelper)
+end
+
+end  # module Webby::Helpers
+
+# EOF

data/lib/webby/helpers/ultraviolet_helper.rb

@@ -0,0 +1,63 @@
+# This code was provided by Guillaume Carbonneau -- http://radr.ca/
+# Many thanks for his support of Webby!
+
+if try_require 'uv'
+
+module Webby::Helpers
+module UltraVioletHelper
+
+  # The +uv+ method applies syntax highlighting to source code embedded
+  # in a webpage. The UltraViolet highlighting engine is used for the HTML
+  # markup of the source code. The page sections to be highlighted are given
+  # as blocks of text to the +uv+ method.
+  #
+  # Options can be passed to the UltraViolet engine via attributes in the
+  # +uv+ method.
+  #
+  #    <% uv( :lang => "ruby", :line_numbers => true ) do -%>
+  #    # Initializer for the class.
+  #    def initialize( string )
+  #      @str = string
+  #    end
+  #    <% end -%>
+  #    
+  # The supported UltraViolet options are the following:
+  #
+  #    :lang           : the language to highlight (ruby, c, html, ...)
+  #                      [defaults to 'ruby']
+  #    :line_numbers   : true or false [defaults to false]
+  #    :theme          : see list of available themes in ultraviolet
+  #                      [defaults to 'mac_classic']
+  #
+  # The defaults can be overridden for an entire site by changing the SITE.uv
+  # options hash in the Rakefile.
+  #
+  def uv( *args, &block )
+    opts = args.last.instance_of?(Hash) ? args.pop : {}
+
+    text = capture_erb(&block)
+    return if text.empty?
+    
+    defaults = ::Webby.site.uv
+    lang = opts.getopt(:lang, defaults[:lang])
+    line_numbers = opts.getopt(:line_numbers, defaults[:line_numbers])
+    theme = opts.getopt(:theme, defaults[:theme])
+    
+    out = '<div class="UltraViolet">'
+    out << Uv.parse(text, "xhtml", lang, line_numbers, theme)
+    out << '</div>'
+
+    # put some guards around the output (specifically for textile)
+    out = _guard(out)
+
+    concat_erb(out, block.binding)
+    return
+  end
+end  # module UltraVioletHelper
+
+register(UltraVioletHelper)
+
+end  # module Webby::Helpers
+end  # try_require
+
+# EOF

data/lib/webby/helpers/url_helper.rb

@@ -0,0 +1,235 @@
+module Webby::Helpers
+
+#
+#
+module UrlHelper
+
+  # call-seq:
+  #    url_for( name, opts = {} ) 
+  #
+  # Creates a URL for the given _name_ and _opts_. If _name_ is a string
+  # then it is used as the URL base. If _name_ is a Resource then it is
+  # converted to a URL by calling its +url+ method.
+  #
+  # ==== Options
+  # 
+  # * <tt>:escape</tt> -- determines whether the returned URL will be HTML escaped or not (+true+ by default)
+  # * <tt>:anchor</tt> -- specifies the anchor name to be appended to the path
+  #
+  # ==== Examples
+  #
+  #    <%= url_for('/some/page.html') %>
+  #    # => /some/page
+  #
+  #    <%= url_for('/some/page.html', :anchor => 'tidbit') %>
+  #    # => /some/page#tidbit
+  #
+  #    <%= url_for(@page) %>
+  #    # => /current/page.html
+  #
+  #    <%= url_for(@page, :anchor => 'this&that') %>
+  #    # => /current/page.html#this&amp;that
+  #
+  def url_for( *args )
+    opts = Hash === args.last ? args.pop : {}
+    obj = args.first
+
+    anchor = opts.delete(:anchor)
+    escape = opts.has_key?(:escape) ? opts.delete(:escape) : true
+
+    url = Webby::Resources::Resource === obj ? obj.url : obj.to_s
+    url = escape_once(url) if escape
+    url << "#" << anchor if anchor
+
+    return url
+  end
+
+  # call-seq:
+  #    url_for_page( :key => value, :url => {} )
+  #
+  # Creates a URL for the page identified by the set of <em>:key /
+  # value</em> pairs. The <em>:url</em> options are passed to the url_for
+  # method for final URL creation; see the url_for method for
+  # documentation on those options.
+  #
+  # The Resources::DB#find method is used to locate the page; see the find
+  # method for the available options.
+  #
+  # ==== Examples
+  #
+  #    <%= url_for_page(:title => 'Funny Story', :anchor => 'punchline') %>
+  #    # => /humor/funny_story.html#punchline
+  #
+  def url_for_page( opts = {} )
+    opts = opts.symbolize_keys
+    url_opts = opts.delete(:url)
+
+    p = @pages.find(opts)
+    raise ::Webby::Error,
+          "could not find requested page: #{opts.inspect}" if p.nil?
+
+    self.url_for(p, url_opts)
+  end
+
+  # call-seq:
+  #    link_to( name, url, :attrs => {} )
+  #
+  # Create an HTTP anchor tag with 
+  #
+  # url can be a url string, a page, :back, or nothing
+  #
+  # :attrs are used to generate HTML anchor tag attributes
+  #
+  # ==== Examples
+  #
+  #    <%= link_to('Google', 'http://www.google.com/', :attrs => {:name => 'google'}) %>
+  #    # => <a href="http://www.google.com/" name="google">Google</a>
+  #
+  #    <%= link_to('A Page', @page, :anchor => 'blah') %>
+  #    # => <a href="/a/page.html#blah">A Page</a>
+  #
+  def link_to( name, *args )
+    opts = Hash === args.last ? args.pop : {}
+    obj = args.first
+    attrs = opts.delete(:attrs)
+
+    url = case obj
+      when String, Webby::Resources::Resource
+        self.url_for(obj, opts)
+      when ::Webby::Paginator::Page
+        self.url_for(obj.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 || h(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. Unless changed by the user, the default +find_by+ attribute
+  # is the page title.
+  #
+  # 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
+  #
+  #    <%= link_to_page('Funny Story', :url => {:anchor => 'punchline'}) %>
+  #    # => <a href="/humor/funny_story.html#punchline">Funny Story</a>
+  #
+  #    <%= link_to_page('Hilarious', :title => 'Funny Story') %>
+  #    # => <a href="/humor/funn_story.html">Hilarious</a>
+  #
+  def link_to_page( *args )
+    self.link_to(*_find_page(args))
+  end
+
+  # call-seq:
+  #    link_to_page_unless_current( name )
+  #    link_to_page_unless_current( :key => value )
+  #    link_to_page_unless_current( name, :key => value )
+  #    link_to_page_unless_current( page )
+  #
+  # This function operates in the same fashion as the +link_to_page+ fuction
+  # with the exception that if the page to be linked to is the current page,
+  # then only the _name_ is rendered without an HTML anchor tag.
+  #
+  # ==== Examples
+  #
+  #    <%= link_to_page_unless_current('Funny Story') %>
+  #    # => <a href="/humor/funny_story.html">Funny Story</a>
+  #
+  #    <%= link_to_page_unless_current(@page) %>
+  #    # => This Page
+  #
+  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]. 
+  #
+  # ==== Options
+  # 
+  # * <tt>:url</tt> -- hash of options for the +url_for+ method
+  # * <tt>:attrs</tt> -- hash of options for the +link_to+ method
+  #
+  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::Resources::Resource === name
+      p, name = name, nil
+    elsif opts.empty? && name
+      opts[Webby.site.find_by.to_sym] = name
+      p = @pages.find(opts)
+    else
+      p = @pages.find(opts)
+    end
+
+    raise ::Webby::Error,
+          "could not find requested page: #{opts.inspect}" if p.nil?
+
+    name = p.title || p.filename if name.nil?
+    return [h(name), p, link_opts]
+  end
+
+end  # module UrlHelper
+
+register(UrlHelper)
+
+end  # module Webby::Helpers
+
+# EOF