webby 0.8.4 → 0.9.0

data/lib/webby/apps/main.rb

@@ -0,0 +1,221 @@
+require 'optparse'
+require 'rake'
+
+module Webby::Apps
+
+class Main
+
+  # Create a new instance of Main, and run the +webby+ application given the
+  # command line _args_.
+  #
+  def self.run( args )
+    self.new.run args
+  end
+
+  # Create a new Main webby object for building websites.
+  #
+  def initialize
+    @stdout = $stdout
+  end
+
+  # Runs the main webby application. The command line arguments are passed
+  # in to this method as an array of strings. The command line arguments are
+  # parsed to figure out which rake task to invoke.
+  #
+  def run( args )
+    args = args.dup
+
+    parse args
+    init args
+    rake
+  end
+
+  # Parse the command line _args_ for options and commands to invoke.
+  #
+  def parse( args )
+    opts = OptionParser.new
+    opts.banner = 'Usage: webby [options] target [target args]'
+
+    opts.separator ''
+    opts.on('-D', '--describe [PATTERN]', 'describe the tasks (matching optional PATTERN), then exit') {|pattern| app.do_option('--describe', pattern)}
+    opts.on('-P', '--prereqs', 'display the tasks and dependencies, then exit') {app.do_option('--prereqs', nil)}
+    opts.on('-T', '--tasks [PATTERN]', 'display the tasks (matching optional PATTERN) with descriptions, then exit') {|pattern| app.do_option('--tasks', pattern)}
+    opts.on('-t', '--trace', 'turn on invoke/execute tracing, enable full backtrace') {app.do_option('--trace', nil)}
+
+    opts.separator ''
+    opts.separator 'common options:'
+
+    opts.on_tail( '-h', '--help', 'show this message' ) do
+      @stdout.puts opts
+      exit
+    end
+    opts.on_tail( '--version', 'show version' ) do
+      @stdout.puts "Webby #{::Webby::VERSION}"
+      exit
+    end
+
+    opts.parse! args
+
+    ARGV.replace Array(args.shift)
+    args.delete_if do |arg|
+      if %r/^[A-Z_]+=/ =~ arg
+        ARGV << arg
+        next true
+      end
+      false
+    end
+
+    args
+  end
+
+  # Initialize the Rake application object and load the core rake tasks, the
+  # site specific rake tasks, and the site specific ruby code. Any extra
+  # command line arguments are converted into a page name and directory that
+  # might get created (depending upon the task invoked).
+  #
+  def init( args )
+    # Make sure we're in a folder with a Sitefile
+    app.do_option('--rakefile', 'Sitefile')
+    app.do_option('--nosearch', nil)
+    app.do_option('--silent', nil)
+
+    unless app.have_rakefile
+      raise RuntimeError, "Sitefile not found"
+    end
+
+    import_default_tasks
+    import_website_tasks
+    require_lib_files
+    capture_command_line_args(args)
+    args
+  end
+
+  # Execute the rake command.
+  #
+  def rake
+    app.init 'webby'
+    app.load_rakefile
+    app.top_level
+  end
+
+  # Return the Rake application object.
+  #
+  def app
+    Rake.application
+  end
+
+  # Search for the "Sitefile" starting in the current directory and working
+  # upwards through the filesystem until the root of the filesystem is
+  # reached. If a "Sitefile" is not found, a RuntimeError is raised.
+  #
+  def find_sitefile
+    here = Dir.pwd
+    while ! app.have_rakefile
+      Dir.chdir("..")
+      if Dir.pwd == here || options.nosearch
+        fail "No Sitefile found"
+      end
+      here = Dir.pwd
+    end
+  end
+
+  def import_default_tasks
+    Dir.glob(::Webby.libpath(%w[webby tasks *.rake])).sort.each {|fn| import fn}
+  end
+
+  def import_website_tasks
+    Dir.glob(::File.join(%w[tasks *.rake])).sort.each {|fn| import fn}
+  end
+
+  def require_lib_files
+    Dir.glob(::File.join(%w[lib ** *.rb])).sort.each {|fn| require fn}
+  end
+
+  def capture_command_line_args(args)
+    args = OpenStruct.new(:raw => args)
+
+    if args.raw.size > 1
+      ::Webby.deprecated "multiple arguments used for page title",
+                         "please quote the page title"
+    end
+
+    dashed = args.raw.join('-').downcase
+    spaced = args.raw.join(' ')
+    dir = ::File.dirname(dashed)
+
+    args.dir   = ('.' == dir ? '' : dir)
+    args.slug  = ::Webby::Resources::File.basename(dashed).to_url
+    args.title = ::Webby::Resources::File.basename(spaced).titlecase
+
+    # page should be dir/slug without leading /
+    args.page  = ::File.join(args.dir, args.slug).gsub(/^\//, '')
+
+    ::Webby.site.args = args
+    Object.const_set(:SITE, Webby.site)
+    args
+  end
+
+end  # class Main
+end  # module Webby::Apps
+
+# :stopdoc:
+# Monkey patches so that rake displays the correct application name in the
+# help messages.
+#
+class Rake::Application
+  def display_prerequisites
+    tasks.each do |t|
+      puts "#{name} #{t.name}"
+      t.prerequisites.each { |pre| puts "    #{pre}" }
+    end
+  end
+
+  def display_tasks_and_comments
+    displayable_tasks = tasks.select { |t|
+      t.comment && t.name =~ options.show_task_pattern
+    }
+    if options.full_description
+      displayable_tasks.each do |t|
+        puts "#{name} #{t.name_with_args}"
+        t.full_comment.split("\n").each do |line|
+          puts "    #{line}"
+        end
+        puts
+      end
+    else
+      width = displayable_tasks.collect { |t| t.name_with_args.length }.max || 10
+      max_column = 80 - name.size - width - 7
+      displayable_tasks.each do |t|
+        printf "#{name} %-#{width}s  # %s\n",
+          t.name_with_args, truncate(t.comment, max_column)
+      end
+    end
+  end
+
+  # Provide standard execption handling for the given block.
+  def standard_exception_handling
+    begin
+      yield
+    rescue SystemExit => ex
+      # Exit silently with current status
+      exit(ex.status)
+    rescue SystemExit, GetoptLong::InvalidOption => ex
+      # Exit silently
+      exit(1)
+    rescue Exception => ex
+      # Exit with error message
+      $stderr.puts "webby aborted!"
+      $stderr.puts ex.message
+      if options.trace
+        $stderr.puts ex.backtrace.join("\n")
+      else
+        $stderr.puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+        $stderr.puts "(See full trace by running task with --trace)"
+      end
+      exit(1)
+    end
+  end
+end  # class Rake::Application
+# :startdoc:
+
+# EOF

data/lib/webby/apps.rb

@@ -0,0 +1,12 @@
+
+module Webby::Apps
+
+  class << self
+    def author() 'Tim Pease'; end
+  end
+
+end  # module Webby::Apps
+
+Webby.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/webby/builder.rb

@@ -69,19 +69,17 @@ class Builder
     end
 
     # call-seq:
-    #    Builder.new_page_info( task )    => [page, title, directory]
+    #    Builder.new_page_info    => [page, title, directory]
     #
-    def new_page_info( task )
-      return @new_page_info if defined? @new_page_info
+    def new_page_info
+      args = Webby.site.args
 
-      raise "Usage:  rake #{ARGV.first} path" unless ARGV.length > 1
-      page  = task.application.top_level_tasks.slice!(1..-1).join('-')
-      title = ::Webby::Resources::File.basename(page).
-                  split('-').map {|w| w.capitalize}.join(' ')
-      dir = ::File.dirname(page)
-      dir = '' if dir == '.'
+      if args.raw.empty?
+        task_name = Rake.application.top_level_tasks.first
+        raise "Usage:  webby #{task_name} path"
+      end
 
-      @new_page_info = [page, title, dir]
+      [args.page, args.title, args.dir]
     end
 
 

data/lib/webby/core_ext/enumerable.rb

@@ -0,0 +1,11 @@
+
+module Enumerable
+
+  def injecting( initial )
+    inject(initial) do |memo, obj|
+      yield(memo, obj); memo
+    end
+  end
+end  # module Enumerable
+
+# EOF

data/lib/webby/{utils.rb → core_ext/hash.rb}

@@ -1,13 +1,6 @@
-# :stopdoc:
-module Enumerable
-  def injecting( initial )
-    inject(initial) do |memo, obj|
-      yield(memo, obj); memo
-    end
-  end
-end
 
 class Hash
+
   def sanitize!
     h = self.injecting({}) do |h, (k, v)|
           h[k] = case v
@@ -30,23 +23,6 @@ class Hash
     self.each {|k,v| h[k.to_sym] = v}
     return h
   end
-end
-
-class String
-  def underscore
-    self.
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr(" -", "__").
-      downcase
-  end
-end
-
-class Time
-  def to_y
-    self.to_yaml.slice(4..-1).strip
-  end
-end
-# :startdoc:
+end  # class Hash
 
 # EOF

data/lib/webby/core_ext/kernel.rb

@@ -0,0 +1,21 @@
+
+module Kernel
+
+  # :stopdoc:
+  WINDOWS = %r/djgpp|(cyg|ms|bcc)win|mingw/ =~ RUBY_PLATFORM
+  DEV_NULL = WINDOWS ? 'NUL:' : '/dev/null'
+  # :startdoc:
+
+  def cmd_available?( *args )
+    io = [STDOUT.dup, STDERR.dup]
+    STDOUT.reopen DEV_NULL
+    STDERR.reopen DEV_NULL
+    system(*(args.flatten))
+  ensure
+    STDOUT.reopen io.first
+    STDERR.reopen io.last
+    $stdout, $stderr = STDOUT, STDERR
+  end
+end  # module Kernel
+
+# EOF

data/lib/webby/core_ext/string.rb

@@ -0,0 +1,163 @@
+
+class String
+
+  def self.small_words
+    @small_words ||= %w(a an and as at but by en for if in of on or the to v[.]? via vs[.]?)
+  end
+
+  def /( path )
+    ::File.join(self, path)
+  end
+
+  def titlecase
+    swrgxp = self.class.small_words.join('|')
+
+    parts = self.split( %r/( [:.;?!][ ] | (?:[ ]|^)["“] )/x )
+    parts.each do |part|
+      part.gsub!(%r/\b[[:alpha:]][[:lower:].'’]*\b/) do |s|
+        s =~ %r/\w+\.\w+/ ? s : s.capitalize
+      end
+
+      # Lowercase the small words
+      part.gsub!(%r/\b(#{swrgxp})\b/i) {|w| w.downcase}
+
+      # If the first word is a small word, then capitalize it
+      part.gsub!(%r/\A([[:punct:]]*)(#{swrgxp})\b/) {$1 + $2.capitalize}
+
+      # If the last word is a small word, then capitalize it
+      part.gsub!(%r/\b(#{swrgxp})([^\w\s]*)\z/) {$1.capitalize + $2}
+    end
+
+    str = parts.join
+
+    # Special cases:
+    str.gsub!(/ V(s?)\. /, ' v\1. ')               # "v." and "vs."
+    str.gsub!(/(['’])S\b/, '\1s')                  # 'S (otherwise you get "the SEC'S decision")
+    str.gsub!(/\b(AT&T|Q&A)\b/i) { |w| w.upcase }  # "AT&T" and "Q&A", which get tripped up.
+
+    str
+  end
+
+  # Borrowed from the excellent StringEx library: git://github.com/rsl/stringex.git
+
+  # Create a URI-friendly representation of the string.
+  def to_url
+    remove_formatting.downcase.replace_whitespace("-").collapse("-")
+  end
+  
+  # Performs multiple text manipulations. Essentially a shortcut for typing them all. View source
+  # below to see which methods are run.
+  def remove_formatting
+    strip_html_tags.convert_accented_entities.convert_misc_entities.convert_misc_characters.collapse
+  end
+
+  # Removes HTML tags from text. This code is simplified from Tobias Luettke's regular expression
+  # in Typo[http://typosphere.org].
+  def strip_html_tags(leave_whitespace = false)
+    name = /[\w:_-]+/
+    value = /([A-Za-z0-9]+|('[^']*?'|"[^"]*?"))/
+    attr = /(#{name}(\s*=\s*#{value})?)/
+    rx = /<[!\/?\[]?(#{name}|--)(\s+(#{attr}(\s+#{attr})*))?\s*([!\/?\]]+|--)?>/
+    (leave_whitespace) ?  gsub(rx, "").strip : gsub(rx, "").gsub(/\s+/, " ").strip
+  end
+
+  # Converts HTML entities into the respective non-accented letters. Examples:
+  # 
+  #   "&aacute;".convert_accented_entities # => "a"
+  #   "&ccedil;".convert_accented_entities # => "c"
+  #   "&egrave;".convert_accented_entities # => "e"
+  #   "&icirc;".convert_accented_entities # => "i"
+  #   "&oslash;".convert_accented_entities # => "o"
+  #   "&uuml;".convert_accented_entities # => "u"
+  # 
+  # Note: This does not do any conversion of Unicode/Ascii accented-characters. For that
+  # functionality please use <tt>to_ascii</tt>.
+  def convert_accented_entities
+    gsub(/&([A-Za-z])(grave|acute|circ|tilde|uml|ring|cedil|slash);/, '\1')
+  end
+
+  # Converts HTML entities (taken from common Textile/RedCloth formattings) into plain text formats.
+  # 
+  # Note: This isn't an attempt at complete conversion of HTML entities, just those most likely
+  # to be generated by Textile.
+  def convert_misc_entities
+    dummy = dup
+    {
+      "#822[01]" => "\"",
+      "#821[67]" => "'",
+      "#8230" => "...",
+      "#8211" => "-",
+      "#8212" => "--",
+      "#215" => "x",
+      "gt" => ">",
+      "lt" => "<",
+      "(#8482|trade)" => "(tm)",
+      "(#174|reg)" => "(r)",
+      "(#169|copy)" => "(c)",
+      "(#38|amp)" => "and",
+      "nbsp" => " ",
+      "(#162|cent)" => " cent",
+      "(#163|pound)" => " pound",
+      "(#188|frac14)" => "one fourth",
+      "(#189|frac12)" => "half",
+      "(#190|frac34)" => "three fourths",
+      "(#176|deg)" => " degrees"
+    }.each do |textiled, normal|
+      dummy.gsub!(/&#{textiled};/, normal)
+    end
+    dummy.gsub(/&[^;]+;/, "")
+  end
+
+  # Converts various common plaintext characters to a more URI-friendly representation.
+  # Examples:
+  #   
+  #   "foo & bar".convert_misc_characters # => "foo and bar"
+  #   "Chanel #9".convert_misc_characters # => "Chanel number nine"
+  #   "user@host".convert_misc_characters # => "user at host"
+  #   "google.com".convert_misc_characters # => "google dot com"
+  #   "$10".convert_misc_characters # => "10 dollars"
+  #   "*69".convert_misc_characters # => "star 69"
+  #   "100%".convert_misc_characters # => "100 percent"
+  #   "windows/mac/linux".convert_misc_characters # => "windows slash mac slash linux"
+  #   
+  # Note: Because this method will convert any & symbols to the string "and",
+  # you should run any methods which convert HTML entities (convert_html_entities and convert_misc_entities)
+  # before running this method.
+  def convert_misc_characters
+    dummy = dup.gsub(/\.{3,}/, " dot dot dot ") # Catch ellipses before single dot rule!
+    {
+      /\s*&\s*/ => "and",
+      /\s*#/ => "number",
+      /\s*@\s*/ => "at",
+      /(\S|^)\.(\S)/ => '\1 dot \2',
+      /(\s|^)\$(\d*)(\s|$)/ => '\2 dollars',
+      /\s*\*\s*/ => "star",
+      /\s*%\s*/ => "percent",
+      /\s*(\\|\/)\s*/ => "slash",
+    }.each do |found, replaced|
+      replaced = " #{replaced} " unless replaced =~ /\\1/
+      dummy.gsub!(found, replaced)
+    end
+    dummy = dummy.gsub(/(^|\w)'(\w|$)/, '\1\2').gsub(/[\.,:;()\[\]\/\?!\^'"_]/, " ")
+  end
+
+  # Replace runs of whitespace in string. Defaults to a single space but any replacement
+  # string may be specified as an argument. Examples:
+  # 
+  #   "Foo       bar".replace_whitespace # => "Foo bar"
+  #   "Foo       bar".replace_whitespace("-") # => "Foo-bar"
+  def replace_whitespace(replace = " ")
+    gsub(/\s+/, replace)
+  end
+
+  # Removes specified character from the beginning and/or end of the string and then performs
+  # <tt>String#squeeze(character)</tt>, condensing runs of the character within the string.
+  # 
+  # Note: This method has been superceded by ActiveSupport's squish method.
+  def collapse(character = " ")
+    sub(/^#{character}*/, "").sub(/#{character}*$/, "").squeeze(character)
+  end
+  
+end  # class String
+
+# EOF

data/lib/webby/core_ext/time.rb

@@ -0,0 +1,9 @@
+
+class Time
+
+  def to_y
+    self.to_yaml.slice(4..-1).strip
+  end
+end  # class Time
+
+# EOF

data/lib/webby/filters/haml.rb

@@ -1,10 +1,18 @@
-try_require 'haml'
 
 # Render text via the Haml library
-Webby::Filters.register :haml do |input, cursor|
-  opts = ::Webby.site.haml_options.merge(cursor.page.haml_options || {})
-  b = cursor.renderer.get_binding
-  Haml::Engine.new(input, opts).to_html(b)
+if try_require('haml', 'haml')
+
+  Webby::Filters.register :haml do |input, cursor|
+    opts = ::Webby.site.haml_options.merge(cursor.page.haml_options || {})
+    b = cursor.renderer.get_binding
+    Haml::Engine.new(input, opts).to_html(b)
+  end
+
+# Otherwise raise an error if the user tries to use haml
+else
+  Webby::Filters.register :haml do |input, cursor|
+    raise Webby::Error, "'haml' must be installed to use the haml filter"
+  end
 end
 
 # EOF

data/lib/webby/filters/markdown.rb

@@ -1,8 +1,16 @@
-try_require 'bluecloth'
 
-# Render text via markdown using the BlueCloth library.
-Webby::Filters.register :markdown do |input|
-  BlueCloth.new(input).to_html
+# Render text via markdown using the RDiscount library.
+if try_require('rdiscount', 'rdiscount')
+
+  Webby::Filters.register :markdown do |input|
+    RDiscount.new(input).to_html
+  end
+
+# Otherwise raise an error if the user tries to use markdown
+else
+  Webby::Filters.register :markdown do |input|
+    raise Webby::Error, "'rdiscount' must be installed to use the markdown filter"
+  end
 end
 
 # EOF

data/lib/webby/filters/outline.rb

@@ -112,7 +112,7 @@ class Outline
   # the table of contents -- "Get Fuzzy" in this example.
   #
   def filter
-    doc = Hpricot(@str)
+    doc = Hpricot.XML(@str)
 
     # extract directives from the "toc" tag
     toc_elem = doc.search('toc').first
@@ -132,7 +132,8 @@ class Outline
     @toc_range = Integer(m[1])..Integer(m[2])
     @list_opening = build_list_opening(toc_elem)
 
-    doc.traverse_element(*%w[h1 h2 h3 h4 h5 h6]) do |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

data/lib/webby/filters/sass.rb

@@ -1,9 +1,17 @@
-try_require 'sass'
 
 # Render text via the Sass library (part of Haml)
-Webby::Filters.register :sass do |input, cursor|
-  opts = ::Webby.site.sass_options.merge(cursor.page.sass_options || {})
-  Sass::Engine.new(input, opts).render
+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/textile.rb

@@ -1,8 +1,16 @@
-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
+# 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

@@ -41,11 +41,6 @@ class Tidy
   # created and output Tidy formatted HTML or XHTML.
   #
   def process
-    %x[tidy -v 2>&1]
-    unless 0 == $?.exitstatus
-      raise NameError, "'tidy' not found on the path"
-    end
-
     cmd = "tidy %s -q -f #{@err.path}" % ::Webby.site.tidy_options
     out = IO.popen(cmd, 'r+') do |tidy|
       tidy.write @str
@@ -63,9 +58,16 @@ class Tidy
 end  # class Tidy
 
 # Render html into html/xhtml via the Tidy program
-#
-register :tidy do |input|
-  Filters::Tidy.new(input).process
+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

data/lib/webby/filters.rb

@@ -50,6 +50,8 @@ module Filters
         @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

data/lib/webby/helpers/graphviz_helper.rb

@@ -127,8 +127,7 @@ module GraphvizHelper
   end
 end  # module GraphvizHelper
 
-%x[dot -V 2>&1]
-if 0 == $?.exitstatus
+if cmd_available? %w[dot -V]
   register(GraphvizHelper)
 end