francois-webby 0.9.4.1

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/auto_builder.rb

@@ -0,0 +1,157 @@
+require 'directory_watcher'
+require 'launchy'
+require 'webrick'
+
+module Webby
+
+# The AutoBuilder class is used to monitor the content and layouts folders
+# and to compile the resource files only when they are modified. If a
+# layout is modified, then all resources that depend upon the layout are
+# compiled.
+#
+class AutoBuilder
+
+  # TODO: hit Ctrl-C once to rebuild everything, and hit it twice to stop the autobuild loop
+
+  # call-seq:
+  #    AutoBuilder.run
+  #
+  # Creates a new AutoBuilder and sets it running. This method will only
+  # return when the user presses Ctrl-C.
+  #
+  def self.run
+    self.new.run
+  end
+
+  attr_reader :logger
+
+  # call-seq:
+  #    AutoBuilder.new
+  #
+  # Create a new AutoBuilder class.
+  #
+  def initialize
+    @logger = Logging::Logger[self]
+
+    @builder = Builder.new
+    ::Webby.load_files
+
+    @watcher = DirectoryWatcher.new '.', :interval => 2
+    @watcher.add_observer self
+
+    glob = []
+    glob << File.join(::Webby.site.layout_dir, '**', '*')
+    glob << File.join(::Webby.site.content_dir, '**', '*')
+    @watcher.glob = glob
+
+    @web_server = ::Webby.site.use_web_server ? WebServer.new : nil
+  end
+
+  # call-seq:
+  #    update( *events )
+  #
+  # The update method is called by the DirectoryWatcher when files have been
+  # modified, added, or deleted. An array of events is passed to his method,
+  # and each event contains the event type and the path to the file.
+  #
+  def update( *events )
+    ary = events.find_all {|evt| evt.type != :removed}
+    return if ary.empty?
+
+    ary.each do |evt|
+      logger.debug "changed #{evt.path}"
+      next unless test ?f, evt.path
+      next if evt.path =~ ::Webby.exclude
+      Resources.new evt.path
+    end
+
+    logger.info 'running the build'
+    @builder.run :load_files => false, :verbose => false
+  rescue => err
+    logger.error err
+  end
+
+  # call-seq:
+  #    run
+  #
+  # Starts the DirectoryWatcher running and waits till the user presses
+  # Ctrl-C to stop the watcher thread.
+  #
+  def run
+    logger.info 'starting autobuild (Ctrl-C to stop)'
+
+    Signal.trap('INT') {
+      @watcher.stop
+      @web_server.stop if @web_server
+    }
+
+    @watcher.start
+    if @web_server
+      @web_server.start
+      sleep 0.25
+      Launchy.open("http://localhost:#{::Webby.site.web_port}")
+    end
+
+    @watcher.join
+    @web_server.join if @web_server
+  end
+
+  # Wrapper class around the webrick web server.
+  #
+  class WebServer
+
+    # Create a new webrick server configured to serve pages from the output
+    # directory. Output will be directed to /dev/null.
+    #
+    def initialize
+      logger = WEBrick::Log.new(Kernel::DEV_NULL, WEBrick::Log::DEBUG)
+      access_log = [[ logger, WEBrick::AccessLog::COMBINED_LOG_FORMAT ]]
+
+      @thread = nil
+      @running = false
+      @server = WEBrick::HTTPServer.new(
+        :BindAddress   => 'localhost',
+        :Port          => ::Webby.site.web_port,
+        :DocumentRoot  => ::Webby.site.output_dir,
+        :FancyIndexing => true,
+        :Logger        => logger,
+        :AccessLog     => access_log
+      )
+    end
+
+    # Returns +true+ if the server is running.
+    #
+    def running?
+      @running
+    end
+
+    # Start the webrick server running in a separate thread (so we don't
+    # block forever).
+    #
+    def start
+      return if running?
+      @running = true
+      @thread = Thread.new {@server.start}
+    end
+
+    # Stop the webrick server.
+    #
+    def stop
+      return if not running?
+      @running = false
+      @server.shutdown
+    end
+
+    # Join on the webserver thread.
+    #
+    def join
+      return if not running?
+      @thread.join
+    end
+
+  end  # class WebServer
+
+end  # class AutoBuilder
+end  # module Webby
+
+# EOF

data/lib/webby/builder.rb

@@ -0,0 +1,172 @@
+require 'find'
+require 'fileutils'
+require 'erb'
+
+module Webby
+
+# The Builder class performs the work of scanning the content folder,
+# creating Resource objects, and converting / copying the contents to the
+# output folder as needed.
+#
+class Builder
+
+  class << self
+
+    # call-seq:
+    #    Builder.run( :rebuild => false )
+    #
+    # Create a new instance of the Builder class and invoke the run method.
+    # If the <code>:rebuild</code> option is given as +true+, then all pages
+    # will be recreated / copied.
+    #
+    def run( opts = {} )
+      self.new.run opts
+    end
+
+    # call-seq:
+    #    Builder.create( page, :from => template, :locals => {} )
+    #
+    # This mehod is used to create a new _page_ in the content folder based
+    # on the specified template. _page_ is the relative path to the new page
+    # from the <code>content/</code> folder. The _template_ is the name of
+    # the template to use from the <code>templates/</code> folder.
+    #
+    def create( page, opts = {} )
+      tmpl = opts[:from]
+      raise Error, "template not given" unless tmpl
+
+      name = ::Webby::Resources.basename(page)
+      ext  = ::Webby::Resources.extname(page)
+      dir  = ::File.dirname(page)
+      dir  = '' if dir == '.'
+
+      if tmpl.pathmap('%n') =~ %r/^_/
+        page = ::File.join(::Webby.site.content_dir, dir, '_'+name)
+        page << '.' << (ext.empty? ? 'txt' : ext)
+      elsif ::Webby.site.create_mode == 'directory' and name != 'index'
+        page = ::File.join(::Webby.site.content_dir, dir, name, 'index')
+        page << '.' << (ext.empty? ? 'txt' : ext)
+      else
+        page = ::File.join(::Webby.site.content_dir, page)
+        page << '.txt' if ext.empty?
+      end
+      raise Error, "#{page} already exists" if test ?e, page
+
+      Logging::Logger[self].info "creating #{page}"
+      FileUtils.mkdir_p ::File.dirname(page)
+
+      context = scope
+      opts[:locals].each do |k,v|
+        Thread.current[:value] = v
+        definition = "#{k} = Thread.current[:value]"
+        eval(definition, context)
+      end if opts.has_key?(:locals)
+
+      str = ERB.new(::File.read(tmpl), nil, '-').result(context)
+      ::File.open(page, 'w') {|fd| fd.write str}
+
+      page
+    end
+
+    # call-seq:
+    #    Builder.new_page_info    => [page, title, directory]
+    #
+    def new_page_info
+      args = Webby.site.args
+
+      # TODO: maybe even get rid of this method altogether
+      raise "Usage:  webby #{args.rake.first} 'path'" if args.raw.empty?
+
+      [args.page, args.title, args.dir]
+    end
+
+    private
+
+    # Returns the binding in the scope of the Builder class object.
+    #   
+    def scope() binding end
+
+  end  # class << self
+
+  # call-seq:
+  #    Builder.new
+  #
+  # Creates a new Builder object for creating pages from the content and
+  # layout directories.
+  #
+  def initialize
+    @logger = Logging::Logger[self]
+  end
+
+  # call-seq:
+  #    run( :rebuild => false, :load_files => true )
+  #
+  # Runs the Webby builder by loading in the layout files from the
+  # <code>layouts/</code> folder and the content from the
+  # <code>contents/</code> folder. Content is analyzed, and those that need
+  # to be copied or compiled (filtered using ERB, Texttile, Markdown, etc.)
+  # are handled. The results are placed in the <code>output/</code> folder.
+  #
+  # If the <code>:rebuild</code> flag is set to +true+, then all content is
+  # copied and/or compiled to the output folder.
+  #
+  # A content file can mark itself as dirty by setting the +dirty+ flag to
+  # +true+ in the meta-data of the file. This will cause the contenet to
+  # always be compiled when the builder is run. Conversely, setting the
+  # dirty flag to +false+ will cause the content to never be compiled or
+  # copied to the output folder.
+  #
+  # A content file needs to be built if the age of the file is less then the
+  # age of the output product -- i.e. the content file has been modified
+  # more recently than the output file.
+  #
+  def run( opts = {} )
+    opts[:load_files] = true unless opts.has_key?(:load_files)
+    verbose = opts.getopt(:verbose, true)
+
+    unless test(?d, output_dir)
+      journal.create output_dir
+      FileUtils.mkdir output_dir
+    end
+
+    ::Webby.load_files if opts[:load_files]
+
+    Resources.pages.each do |page|
+      unless page.dirty? or opts[:rebuild]
+        journal.identical(page.destination) if verbose
+        next
+      end
+
+      # copy the resource to the output directory if it is static
+      if page.instance_of? Resources::Static
+        FileUtils.mkdir_p ::File.dirname(page.destination)
+        journal.create_or_update(page)
+        FileUtils.cp page.path, page.destination
+        FileUtils.chmod 0644, page.destination
+
+      # otherwise, layout the resource and write the results to
+      # the output directory
+      else Renderer.write(page) end
+    end
+
+    # touch the cairn so we know when the website was last generated
+    FileUtils.touch ::Webby.cairn
+
+    nil
+  end
+
+  def load_files
+    ::Webby.deprecated "load_files", "it is being replaced by the Webby#load() method"
+    ::Webby.load_files
+  end
+
+  %w(output_dir layout_dir content_dir).each do |key|
+    self.class_eval <<-CODE
+      def #{key}( ) ::Webby.site.#{key} end
+    CODE
+  end
+
+end  # class Builder
+end  # module Webby
+
+# EOF

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