webby 0.9.3-x86-mswin32

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/core_ext/hash.rb

@@ -0,0 +1,28 @@
+
+class Hash
+
+  def sanitize!
+    h = self.injecting({}) do |h, (k, v)|
+          h[k] = case v
+                 when 'none', 'nil'; nil
+                 when 'true', 'yes'; true
+                 when 'false', 'no'; false
+                 else v end
+        end
+    self.replace h
+  end
+
+  def stringify_keys
+    h = {}
+    self.each {|k,v| h[k.to_s] = v}
+    return h
+  end
+
+  def symbolize_keys
+    h = {}
+    self.each {|k,v| h[k.to_sym] = v}
+    return h
+  end
+end  # class Hash
+
+# EOF

data/lib/webby/core_ext/kernel.rb

@@ -0,0 +1,26 @@
+
+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
+
+  def journal
+    @journal ||= ::Webby::Journal.new
+  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.rb

@@ -0,0 +1,83 @@
+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
+      
+    # 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
+      
+      # 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/filters/basepath.rb

@@ -0,0 +1,97 @@
+require 'hpricot'
+
+module Webby
+module Filters
+
+# The BasePath filter is used to rewrite URI paths in HTML documents. This
+# is useful when the server location of the website is not located at the
+# root of the webserver (e.g. http://my.site.com/foo/bar).
+#
+# The BasePath filter will adjust the URI paths in a given HTML document by
+# prepending a base path to the URI. This only works for URIs that start
+# with a leading slash "/". Any other character will exclude the URI from
+# being modified.
+#
+# Assume the user specifies a new URI base in the <tt>Webby.site.base</tt>
+# property:
+#
+#    Webby.site.base = '/foo/bar'
+#
+# Here is a snippet from some HTML document.
+#
+#    <a href="/some/other/page.html">Page</a>
+#    <img src="fractal.jpg" alt="a fractal" />
+#
+# When run through the BasePath filter, the resulting snippet would look
+# like this.
+#
+#    <a href="/foo/bar/some/other/page.html">Page</a>
+#    <img src="fractal.jpg" alt="a fractal" />
+#
+# The +href+ attribute of the anchor tag is modified because it started
+# with a leading slash. The +src+ attribute of the image tag is not
+# modified because it lacks the leading slash.
+#
+class BasePath
+
+  # call-seq:
+  #    BasePath.new( html, mode )
+  #
+  # Creates a new BasePath filter that will operate on the given _html_
+  # string. The _mode_ is either 'xml' or 'html' and determines how Hpricot
+  # will handle the parsing of the input string.
+  #
+  def initialize( str, mode )
+    @str = str
+    @mode = mode.downcase.to_sym
+  end
+
+  # call-seq:
+  #    filter    => html
+  #
+  # Process the original html document passed to the filter when it was
+  # created. The document will be scanned and the basepath for certain
+  # elements will be modified.
+  #
+  # For example, if a document contains the following line:
+  # 
+  #    <a href="/link/to/another/page.html">Page</a>
+  #
+  # and the user has requested for the base path to be some other directory
+  # on the webserver -- <tt>/some/other/directory</tt>. The result of the
+  # BasePath filter would be:
+  #
+  #     <a href="/some/other/directory/link/to/another/page.html">Page</a>
+  #
+  def filter
+    doc = @mode == :xml ? Hpricot.XML(@str) : Hpricot(@str)
+    base_path = ::Webby.site.base
+    attr_rgxp = %r/\[@(\w+)\]$/o
+    sub_rgxp = %r/\A(?=\/)/o
+
+    ::Webby.site.xpaths.each do |xpath|
+      @attr_name = nil
+
+      doc.search(xpath).each do |element|
+        @attr_name ||= attr_rgxp.match(xpath)[1]
+        a = element.get_attribute(@attr_name)
+        element.set_attribute(@attr_name, a) if a.sub!(sub_rgxp, base_path)
+      end
+    end
+
+    doc.to_html
+  end
+
+end  # class BasePath
+
+# Rewrite base URIs in the input HTML text.
+#
+register :basepath do |input, cursor|
+  if ::Webby.site.base then BasePath.new(input, cursor.page.extension).filter
+  else input end
+end
+
+end  # module Filters
+end  # module Webby
+
+# EOF

data/lib/webby/filters/erb.rb

@@ -0,0 +1,9 @@
+require 'erb'
+
+# Render text via ERB using the built in ERB library.
+Webby::Filters.register :erb do |input, cursor|
+  b = cursor.renderer.get_binding
+  ERB.new(input, nil, '-').result(b)
+end
+
+# EOF

data/lib/webby/filters/haml.rb

@@ -0,0 +1,18 @@
+
+# Render text via the Haml library
+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