TwP-webby 0.9.0

data/lib/webby/filters/outline.rb

@@ -0,0 +1,309 @@
+require 'hpricot'
+
+module Webby
+module Filters
+
+# The Outline filter is used to insert outline numbering into HTML heading
+# tags (h1, h2, h3, etc.) and to generate a table of contents based on the
+# heading tags. The table of contents is inserted into the page at the
+# location of the <toc /> tag. If there is no <toc /> tag, then a table of
+# contents will not be created but outline numbering will still take place.
+#
+# If a table of contents is desired without outline number being inserted
+# into the heading tags, this can be specified in the attibutes of the
+# <toc /> tag itself.
+#
+#    <toc numbering="off" />
+#
+# This will generate a table of contents, but not insert outline numbering
+# into the heading tags.
+#
+# The Outline filter will only work on valid HTML or XHTML pages. Therefore
+# it should be used after any markup langauge filters (textile, markdown,
+# etc.).
+#
+# The following attributes can be specified in the <toc /> tag itself to
+# control how outline numbering is performed by the filter. The attributes
+# can be used in combination with one another.
+#
+# === numbering
+#
+# If set to "off", this will prevent numbers from being inserted into the
+# page. The default is "on".
+#
+#    <toc numbering="off" />
+#
+# === numbering_start
+#
+# This is the number to start with when inserting outline numbers into a
+# page. The default is 1.
+#
+#    <toc numbering_start="3" />
+#
+# === toc_style
+#
+# The style of the Table of Contents list to generated. This will be
+# either "ol" for an ordered list or "ul" for an unordered list. The
+# default is an ordered list.
+#
+#    <toc toc_style="ul" />
+#
+# === toc_range
+#
+# This limits the numbering to only a subset of the HTML heading tags. The
+# defaul is to number all the heading tags.
+#
+#    <toc toc_range="h1-h3" />
+#
+# In this example, only the heading tags h1, h2, and h3 will be numbered
+# and included in the table of contents listing.
+#
+# ==== Example
+#
+# Generate a table of contents using an unordered list, starting with the
+# number 2, and only numbering heading levels 2, 3, and 4.
+#
+#    <toc numbering_start="2" toc_style="ul" toc_range="h2-h4" />
+#
+class Outline
+  include ERB::Util
+
+  # call-seq:
+  #    Outline.new( html )
+  #
+  # Creates a new outline filter that will operate on the given
+  # _html_ string.
+  #
+  def initialize( str )
+    @str = str
+
+    @cur_level, @base_level, @cur_depth = nil
+    @level = [0] * 6
+    @h_rgxp = %r/^h(\d)$/o
+
+    @numbering = true
+    @numbering_start = 1
+
+    @toc = []
+    @toc_style = 'ol'
+    @toc_range = 'h1-h6'
+    @list_opening = nil
+  end
+
+  # call-seq:
+  #    filter    => html
+  #
+  # Process the original html document passed to the filter when it was
+  # created. The document will be scanned for heading tags (h1, h2, etc.)
+  # and outline numbering and id attributes will be inserted. A table of
+  # contents will also be created and inserted into the page if a <toc />
+  # tag is found.
+  #
+  # For example, if there is a heading tag
+  #
+  #    <h3>Get Fuzzy</h3>
+  #
+  # somewhere in a page about comic strips, the tag might be altered as such
+  #
+  #    <h3 id="h2_2_1"><span class="heading-num">2.2.1</span>Get Fuzzy</h3>
+  # 
+  # The id attribute is used to generate a linke from the table of contents
+  # to this particular heading tag. The original text of the tag is used in
+  # the table of contents -- "Get Fuzzy" in this example.
+  #
+  def filter
+    doc = Hpricot.XML(@str)
+
+    # extract directives from the "toc" tag
+    toc_elem = doc.search('toc').first
+
+    unless toc_elem.nil?
+      @numbering = toc_elem['numbering'] !~ %r/off/i
+      @numbering_start = Integer(toc_elem['numbering_start']) if toc_elem.has_attribute? 'numbering_start'
+      @toc_style = toc_elem['toc_style'] if toc_elem.has_attribute? 'toc_style'
+      @toc_range = toc_elem['toc_range'] if toc_elem.has_attribute? 'toc_range'
+    end
+
+    unless %w[ul ol].include? @toc_style
+      raise ArgumentError, "unknown ToC list type '#{@toc_style}'"
+    end
+
+    m = %r/h(\d)\s*-\s*h(\d)/i.match @toc_range
+    @toc_range = Integer(m[1])..Integer(m[2])
+    @list_opening = build_list_opening(toc_elem)
+
+    headers = @toc_range.map {|x| "h#{x}"}
+    doc.traverse_element(*headers) do |elem|
+      text, id = heading_info(elem)
+      add_to_toc(text, id) if @toc_range.include? current_level
+    end
+
+    toc_elem.swap(toc) unless toc_elem.nil?
+    doc.to_html
+  end
+
+
+  private
+
+  def build_list_opening( elem )
+    lo = "<#{@toc_style}"
+    unless elem.nil?
+      %w[class style id].each do |atr|
+        next unless elem.has_attribute? atr
+        lo << " %s=\"%s\"" % [atr, elem[atr]]
+      end
+    end
+    if @toc_style == 'ol' and @numbering_start != 1
+      lo << " start=\"#{@numbering_start}\""
+    end
+    lo << ">"
+  end
+
+  # Returns information for the given heading element. The information is
+  # returned as a two element array: [text, id].
+  #
+  # This method will also insert outline numbering and an id attribute. The
+  # outline numbering can be disabled, but the id attribute must be present
+  # for TOC generation.
+  #
+  def heading_info( elem )
+    m = @h_rgxp.match(elem.name)
+    level = Integer(m[1])
+
+    self.current_level = level
+    text = elem.inner_text
+
+    lbl = label
+    if numbering?
+      elem.children.first.before {tag!(:span, lbl, :class => 'heading-num')}
+    end
+    elem['id'] = "h#{lbl.tr('.','_')}" if elem['id'].nil?
+
+    return [text, elem['id']]
+  end
+
+  # Set the current heading level. This will set the label and depth as
+  # well. An error will be raised if the _level_ is less than the base
+  # heading level.
+  #
+  # The base heading level will be set to the _level_ if it has not already
+  # been set. Therefore, the first heading tag encountered defines the base
+  # heading level.
+  #
+  def current_level=( level )
+    if @base_level.nil?
+      @base_level = @cur_level = level
+      @level[@base_level-1] = @numbering_start-1
+    end
+
+    if level < @base_level
+      raise ::Webby::Error, "heading tags are not in order, cannot outline"
+    end
+
+    if level == @cur_level
+      @level[level-1] += 1
+    elsif level > @cur_level
+      @cur_level.upto(level-1) {|ii| @level[ii] += 1}
+    else
+      @cur_level.downto(level+1) {|ii| @level[ii-1] = 0}
+      @level[level-1] += 1
+    end
+
+    @cur_level = level
+  end
+
+  # Returns the current heading level number.
+  #
+  def current_level
+    @cur_level
+  end
+
+  # Return the label string for the current heading level.
+  #
+  def label
+    rv = @level.dup
+    rv.delete(0)
+    rv.join('.')
+  end
+
+  # Return the nesting depth of the current heading level with respect to the
+  # base heading level. This is a one-based number.
+  #
+  def depth
+    @cur_level - @base_level + 1
+  end
+
+  # Add the given text and id reference to the table of contents.
+  #
+  def add_to_toc( text, id )
+    a = "<a href=\"##{id}\">#{h(text)}</a>"
+    @toc << [depth, a]
+  end
+
+  # Returns the table of contents as a collection of nested ordered lists.
+  # This is fully formatted HTML.
+  #
+  def toc
+    ary = []
+
+    lopen = "<#@toc_style>"
+    lclose = "</#@toc_style>"
+    prev_depth = open = 0
+
+    @toc.each do |a|
+      cur = a.first
+
+      # close out the previous list item if we're at the same level
+      if cur == prev_depth
+        ary << "</li>"
+
+      # if we are increasing the level, then start a new list
+      elsif cur > prev_depth
+        ary << if ary.empty? then @list_opening else lopen end
+        open += 1
+
+      # we are decreasing the level; close out tags but ensure we don't
+      # close out all the tags (leave one open)
+      else
+        (prev_depth - cur).times {
+          ary << "</li>" << lclose
+          open -= 1
+          break if open <= 0
+        }
+        if open > 0
+          ary << "</li>"
+        else
+          ary << lopen
+          open += 1
+        end
+      end
+
+      # add the current element
+      ary << "<li>" << a.last
+      prev_depth = cur
+    end
+
+    # close out the remaingling tags
+    ary << "</li>" << lclose
+    ary.join("\n")
+  end
+
+  # Returns +true+ if outline numbering should be inserted into the heading
+  # tags. Returns +false+ otherwise.
+  #
+  def numbering?
+    @numbering
+  end
+end  # class Outline
+
+# Generate a outline numbering and/or a table of contents in the input HTML
+# text.
+#
+register :outline do |input|
+  Outline.new(input).filter
+end
+
+end  # module Filters
+end  # module Webby
+
+# EOF

data/lib/webby/filters/sass.rb

@@ -0,0 +1,17 @@
+
+# Render text via the Sass library (part of Haml)
+if try_require('sass', 'haml')
+
+  Webby::Filters.register :sass do |input, cursor|
+    opts = ::Webby.site.sass_options.merge(cursor.page.sass_options || {})
+    Sass::Engine.new(input, opts).render
+  end
+
+# Otherwise raise an error if the user tries to use sass
+else
+  Webby::Filters.register :sass do |input, cursor|
+    raise Webby::Error, "'haml' must be installed to use the sass filter"
+  end
+end
+
+# EOF

data/lib/webby/filters/slides.rb

@@ -0,0 +1,56 @@
+module Webby
+module Filters
+
+# The Slides filter is used to generate an S5 presentation from HTML input
+# text. The input HTML is scanned for <h1> tags and slide divs are inserted
+# before each <h1> tag found.
+#
+# When the HTML is rendered into the presentation layout, the result is an
+# S5 presentation -- provided that the layout includes the appropriate S5
+# javascript and CSS files.
+#
+class Slides
+
+  START_SLIDE = %{<div class="slide">#$/}
+  END_SLIDE   = %{</div>#$/#$/}
+
+  # call-seq:
+  #    Slides.new( html )
+  #
+  # Creates a new slides filter that will operate on the given
+  # _html_ string.
+  #
+  def initialize( str )
+    @str = str
+    @open = false
+  end
+
+  # call-seq:
+  #    filter    => html
+  #
+  # Process the original html document passed to the filter when it was
+  # created. The document will be scanned for H1 heading tags and slide
+  # divs will be inserted into the page before each H1 tag that is found.
+  #
+  def filter
+    result = []
+
+    @str.split(%r/\<h1\>/i).each do |slide|
+      next if slide.strip.empty?
+      result << START_SLIDE << '<h1>' << slide << END_SLIDE
+    end
+
+    result.join
+  end
+end  # class Slides
+
+# Insert slide divs into the input HTML text.
+#
+register :slides do |input|
+  Slides.new(input).filter
+end
+
+end  # module Filters
+end  # module Webby
+
+# EOF

data/lib/webby/filters/textile.rb

@@ -0,0 +1,16 @@
+
+# If RedCloth is installed, then configure the textile filter
+if try_require('redcloth', 'RedCloth')
+
+  Webby::Filters.register :textile do |input|
+    RedCloth.new(input, %w(no_span_caps)).to_html
+  end
+
+# Otherwise raise an error if the user tries to use textile
+else
+  Webby::Filters.register :textile do |input|
+    raise Webby::Error, "'RedCloth' must be installed to use the textile filter"
+  end
+end
+
+# EOF

data/lib/webby/filters/tidy.rb

@@ -0,0 +1,76 @@
+require 'fileutils'
+require 'tempfile'
+
+module Webby
+module Filters
+
+# The Tidy filter is used to process HTML (or XHTML) through the _tidy_
+# program and outpu nicely formatted and correct HTML (or XHTML).
+#
+# Options can be passed to the _tidy_ program via the
+# <code>Webby.site</code> struct. Setting the +tidy_options+ to the string
+# of desired options will do the trick.
+#
+# From a project's Rakefile, include the following line (or one that's more
+# to your liking):
+#
+#    SITE.tidy_options = "-indent -wrap 80 -utf8"
+#
+class Tidy
+
+  # call-seq:
+  #    Tidy.new( html )
+  #
+  # Create a new filter that will process the given _html_ through the tidy
+  # program.
+  #
+  def initialize( str )
+    @log = ::Logging::Logger[self]
+    @str = str
+
+    # create a temporary file for holding any error messages
+    # from the tidy program
+    @err = Tempfile.new('tidy_err')
+    @err.close
+  end
+
+  # call-seq:
+  #    process    => formatted html
+  #
+  # Process the original HTML text string passed to the filter when it was
+  # created and output Tidy formatted HTML or XHTML.
+  #
+  def process
+    cmd = "tidy %s -q -f #{@err.path}" % ::Webby.site.tidy_options
+    out = IO.popen(cmd, 'r+') do |tidy|
+      tidy.write @str
+      tidy.close_write
+      tidy.read
+    end
+
+    if File.size(@err.path) != 0
+      @log.warn File.read(@err.path).strip
+    end
+
+    return out
+  end
+
+end  # class Tidy
+
+# Render html into html/xhtml via the Tidy program
+if cmd_available? %w[tidy -v]
+  register :tidy do |input|
+    Filters::Tidy.new(input).process
+  end
+
+# Otherwise raise an error if the user tries to use tidy
+else
+  register :tidy do |input|
+    raise Webby::Error, "'tidy' must be installed to use the tidy filter"
+  end
+end
+
+end  # module Filters
+end  # module Webby
+
+# EOF

data/lib/webby/filters.rb

@@ -0,0 +1,91 @@
+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
+        @prev_cursor = nil
+      end
+      
+      def start_for(input)
+        @prev_cursor = @renderer.instance_variable_get(:@_cursor)
+        @renderer.instance_variable_set(:@_cursor, self)
+        filters.inject(input) do |result, filter|
+          handler = Filters[filter]
+          raise ::Webby::Error, "unknown filter: #{filter.inspect}" if handler.nil?
+
+          args = [result, self][0, handler.arity]
+          handle(filter, handler, *args)
+        end
+      ensure
+        @renderer.instance_variable_set(:@_cursor, @prev_cursor)
+      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
+      end
+      
+    end  # class Cursor
+  end  # class << self
+    
+end  # module Filters
+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