giraffesoft-webby 0.9.5

data/lib/webby/filters/wiki_words.rb

@@ -0,0 +1,14 @@
+
+Webby::Filters.register :wikiwords do |input, cursor|
+
+  renderer = cursor.renderer
+  input.gsub %r/\[\[([^\]]+)\]\]/ do
+    name = $1
+    renderer.link_to_page(name) {
+      %Q(<a class="missing internal">#{name}</a>)
+    }
+  end
+
+end
+
+# EOF

data/lib/webby/helpers.rb

@@ -0,0 +1,30 @@
+require Webby.libpath(*%w[webby renderer])
+
+module Webby
+
+# The Helpers module is used to register helper modules that provide extra
+# functionality to the Webby renderer. The most notable example is the
+# UrlHelpers module that provides methods to link to another page in a
+# Webby webiste.
+#
+# Helpers are registered with the Webby framework by calling:
+#
+#    Webby::Helpers.register( MyHelper )
+#
+module Helpers
+
+  # call-seq:
+  #    Helpers.register( module )
+  #
+  # Register the given _module_ as a helper module for the Webby framework.
+  #
+  def self.register( helper )
+    ::Webby::Renderer.__send__( :include, helper )
+  end
+
+end  # module Helper
+end  # module Webby
+
+Webby.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/webby/helpers/capture_helper.rb

@@ -0,0 +1,141 @@
+
+module Webby::Helpers
+
+# Based on code from Rails and Merb.
+#
+module CaptureHelper
+
+  # Called in pages and partials to store up content for later use. Takes a
+  # string and/or a block. First, the string is evaluated, and then the
+  # block is captured using the capture() helper provided by the template
+  # languages. The two are concatenated together.
+  #
+  # Content is retrieved by calling the method without a string or a block.
+  #
+  # ==== Parameters
+  # obj<Object>:: The key in the conetnt_for hash.
+  # string<String>:: Textual content. Defaults to nil.
+  # &block:: A block to be evaluated and concatenated to string.
+  #
+  # ==== Returns
+  # Any content associated with the key (or nil).
+  #
+  # ==== Example
+  #   content_for(:foo, "Foo")
+  #   content_for(:foo)             #=> "Foo"
+  #   content_for(:foo, "Bar")
+  #   content_for(:foo)             #=> "FooBar"
+  #
+  def content_for( obj, string = nil, &block )
+    return @_content_for[obj] unless string || block_given?
+
+    cur = @_content_for[obj].to_s
+    new = string.to_s + (block_given? ? capture_erb(&block) : "")
+    @_content_for[obj] = cur + new
+  end
+
+  # Returns true if there is content for the given key. Otherwise returns
+  # false.
+  #
+  # ==== Parameters
+  # obj<Object>:: The key in the conetnt_for hash.
+  #
+  # ==== Example
+  #   content_for(:foo, "Foo")
+  #   content_for?(:foo)            #=> true
+  #   content_for?(:bar)            #=> false
+  #
+  def content_for?( obj )
+    @_content_for.key?(obj)
+  end
+
+  # Deletes any content associated with the given object in the content_for
+  # hash.
+  #
+  # ==== Parameters
+  # obj<Object>:: The key in the conetnt_for hash.
+  #
+  # ==== Returns
+  # Any content associated with the key (or nil).
+  #
+  # ==== Example
+  #   content_for(:foo, "Foo")
+  #   content_for?(:foo)            #=> true
+  #   delete_content_for(:foo)
+  #   content_for?(:foo)            #=> false
+  #
+  def delete_content_for( obj )
+    @_content_for.delete(obj)
+  end
+
+  # This method is used to capture content from an ERB filter evaluation. It
+  # is useful to helpers that need to process chunks of data during ERB filter
+  # processing.
+  #
+  # ==== Parameters
+  # *args:: Arguments to pass to the block.
+  # &block:: The ERB block to call.
+  #
+  # ==== Returns
+  # String:: The output of the block.
+  #
+  # ==== Examples
+  # Capture being used in an ERB page:
+  # 
+  #   <% @foo = capture_erb do %>
+  #     <p>Some Foo content!</p> 
+  #   <% end %>
+  #
+  def capture_erb( *args, &block )
+    # get the buffer from the block's binding
+    buffer = _erb_buffer(block.binding) rescue nil
+
+    # If there is no buffer, just call the block and get the contents
+    if buffer.nil?
+      block.call(*args)
+    # If there is a buffer, execute the block, then extract its contents
+    else
+      pos = buffer.length
+      block.call(*args)
+
+      # extract the block
+      data = buffer[pos..-1]
+
+      # replace it in the original with empty string
+      buffer[pos..-1] = ""
+
+      data
+    end
+  end
+
+  # This method is used to concatenate content into the ERB output buffer.
+  # It is usefule to helpers that need to insert transformed text back into
+  # the ERB output buffer.
+  #
+  # ==== Parameters
+  # string<String>:: The string to insert into the ERB output.
+  # the_binding<Binding>:: The binding to pass to the buffer.
+  #
+  def concat_erb( string, the_binding )
+    _erb_buffer(the_binding) << string
+  end
+
+  # Provides direct acccess to the ERB buffer in the conext of the binding.
+  #
+  # ==== Parameters
+  # the_binding<Binding>:: The binding to pass to the buffer.
+  #
+  # ==== Returns
+  # The current ERB output buffer.
+  #
+  def _erb_buffer( the_binding )
+    eval("_erbout", the_binding, __FILE__, __LINE__)
+  end
+
+end  # module CaptureHelper
+
+register(CaptureHelper)
+
+end  # module Webby::Helpers
+
+# EOF

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 = %Q{<div class="CodeRay">\n<pre>}
+    out << ::CodeRay.scan(text, lang).html(cr_opts)
+    out << %Q{</pre>\n</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