webby 0.9.2 → 0.9.3

data/lib/webby/apps/main.rb

@@ -12,10 +12,13 @@ class Main
     self.new.run args
   end
 
+  attr_reader :cmd_line_options
+
   # Create a new Main webby object for building websites.
   #
   def initialize
     @stdout = $stdout
+    @cmd_line_options = {}
   end
 
   # Runs the main webby application. The command line arguments are passed
@@ -44,6 +47,16 @@ class Main
       opts.on(*options)
     end
 
+    opts.separator ''
+    opts.separator 'autobuild options:'
+
+    opts.on('--web-server', 'Start a local web server') {
+      cmd_line_options[:use_web_server] = true
+    }
+    opts.on('--no-web-server', 'Do not start a local web server') {
+      cmd_line_options[:use_web_server] = false
+    }
+
     opts.separator ''
     opts.separator 'common options:'
 
@@ -98,6 +111,7 @@ class Main
   def rake
     app.init 'webby'
     app.load_rakefile
+    load_command_line_options
     app.top_level
   end
 
@@ -167,6 +181,14 @@ class Main
     args
   end
 
+  # Load options from the command line into the ::Webby.site struct
+  #
+  def load_command_line_options
+    cmd_line_options.each do |key, value|
+      ::Webby.site.__send__("#{key}=", value)
+    end
+  end
+
 end  # class Main
 end  # module Webby::Apps
 

data/lib/webby/auto_builder.rb

@@ -1,4 +1,6 @@
 require 'directory_watcher'
+require 'launchy'
+require 'webrick'
 
 module Webby
 
@@ -21,13 +23,15 @@ class AutoBuilder
     self.new.run
   end
 
+  attr_reader :logger
+
   # call-seq:
   #    AutoBuilder.new
   #
   # Create a new AutoBuilder class.
   #
   def initialize
-    @log = Logging::Logger[self]
+    @logger = Logging::Logger[self]
 
     @builder = Builder.new
     @builder.load_files
@@ -39,6 +43,8 @@ class AutoBuilder
     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:
@@ -53,15 +59,16 @@ class AutoBuilder
     return if ary.empty?
 
     ary.each do |evt|
-      @log.debug "changed #{evt.path}"
+      logger.debug "changed #{evt.path}"
       next unless test ?f, evt.path
       next if evt.path =~ ::Webby.exclude
       Resources.new evt.path
     end
 
-    @builder.run :load_files => false
+    logger.info 'running the build'
+    @builder.run :load_files => false, :verbose => false
   rescue => err
-    @log.error err
+    logger.error err
   end
 
   # call-seq:
@@ -71,14 +78,79 @@ class AutoBuilder
   # Ctrl-C to stop the watcher thread.
   #
   def run
-    @log.info 'starting autobuild (Ctrl-C to stop)'
+    logger.info 'starting autobuild (Ctrl-C to stop)'
 
-    Signal.trap('INT') {@watcher.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.heel_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.heel_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
 

data/lib/webby/builder.rb

@@ -82,7 +82,6 @@ class Builder
       [args.page, args.title, args.dir]
     end
 
-
     private
 
     # Returns the binding in the scope of the Builder class object.
@@ -98,7 +97,7 @@ class Builder
   # layout directories.
   #
   def initialize
-    @log = Logging::Logger[self]
+    @logger = Logging::Logger[self]
   end
 
   # call-seq:
@@ -125,24 +124,25 @@ class Builder
   #
   def run( opts = {} )
     opts[:load_files] = true unless opts.has_key?(:load_files)
+    verbose = opts.getopt(:verbose, true)
 
     unless test(?d, output_dir)
-      @log.info "creating #{output_dir}"
+      journal.create output_dir
       FileUtils.mkdir output_dir
     end
 
     load_files if opts[:load_files]
 
     Resources.pages.each do |page|
-      next unless page.dirty? or opts[:rebuild]
-
-      @log.info "creating #{page.destination}"
-
-      # make sure the directory exists
-      FileUtils.mkdir_p ::File.dirname(page.destination)
+      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
 

data/lib/webby/core_ext/kernel.rb

@@ -16,6 +16,11 @@ module Kernel
     STDERR.reopen io.last
     $stdout, $stderr = STDOUT, STDERR
   end
+
+  def journal
+    @journal ||= ::Webby::Journal.new
+  end
+
 end  # module Kernel
 
 # EOF

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

@@ -159,6 +159,9 @@ module UrlHelper
   #
   def link_to_page( *args )
     self.link_to(*_find_page(args))
+  rescue ::Webby::Error => err
+    return yield if block_given?
+    raise err
   end
 
   # call-seq:
@@ -184,6 +187,9 @@ module UrlHelper
     return name if @page == page
 
     self.link_to(name, page, link_opts)
+  rescue ::Webby::Error => err
+    return yield if block_given?
+    raise err
   end
 
   

data/lib/webby/journal.rb

@@ -0,0 +1,126 @@
+
+module Webby
+
+# The Journal class is used to output simple messages regarding the creation
+# and updating of files when webby applications are run. The output messages
+# will be color coded if the terminal supports the ANSI codes.
+#
+class Journal
+
+  attr_accessor :colorize
+  attr_reader :logger
+
+  # Create a new journal
+  #
+  def initialize
+    @logger = ::Logging::Logger[self]
+    @colorize = ENV.has_key?('TERM')
+  end
+
+  # Output a message of the given _type_ using the option _color_ code. The
+  # available codes are as follows:
+  #
+  # * black
+  # * red
+  # * green
+  # * yellow
+  # * blue
+  # * magenta
+  # * cyan
+  # * white
+  #
+  # The color is specified as a string or a symbol.
+  #
+  def typed_message( type, msg, color = nil )
+    type = type.to_s.rjust(13)
+    type = self.send(color, type) unless color.nil?
+    logger.info "#{type}  #{msg.to_s}"
+  end
+
+  # Output a "create" message or an "update" message depending on whether
+  # the given _page_ already has a generated output file or not.
+  #
+  def create_or_update( page )
+    if test(?e, page.destination)
+      update(page.destination)
+    else
+      create(page.destination)
+    end
+  end
+
+  # Output a create message.
+  #
+  def create( msg )
+    typed_message('create', msg, (colorize ? :green : nil))
+  end
+
+  # Output an update message.
+  #
+  def update( msg )
+    typed_message('update', msg, (colorize ? :yellow : nil))
+  end
+
+  # Output a force message.
+  #
+  def force( msg )
+    typed_message('force', msg, (colorize ? :red : nil))
+  end
+
+  # Output a skip message.
+  #
+  def skip( msg )
+    typed_message('skip', msg, (colorize ? :yellow : nil))
+  end
+
+  # Output an exists message.
+  #
+  def exists( msg )
+    typed_message('exists', msg, (colorize ? :cyan : nil))
+  end
+
+  # Output an identical message.
+  #
+  def identical( msg )
+    typed_message('identical', msg, (colorize ? :cyan : nil))
+  end
+
+  [ [ :clear        ,   0 ],
+    [ :reset        ,   0 ],     # synonym for :clear
+    [ :bold         ,   1 ],
+    [ :dark         ,   2 ],
+    [ :italic       ,   3 ],     # not widely implemented
+    [ :underline    ,   4 ],
+    [ :underscore   ,   4 ],     # synonym for :underline
+    [ :blink        ,   5 ],
+    [ :rapid_blink  ,   6 ],     # not widely implemented
+    [ :negative     ,   7 ],     # no reverse because of String#reverse
+    [ :concealed    ,   8 ],
+    [ :strikethrough,   9 ],     # not widely implemented
+    [ :black        ,  30 ],
+    [ :red          ,  31 ],
+    [ :green        ,  32 ],
+    [ :yellow       ,  33 ],
+    [ :blue         ,  34 ],
+    [ :magenta      ,  35 ],
+    [ :cyan         ,  36 ],
+    [ :white        ,  37 ],
+    [ :on_black     ,  40 ],
+    [ :on_red       ,  41 ],
+    [ :on_green     ,  42 ],
+    [ :on_yellow    ,  43 ],
+    [ :on_blue      ,  44 ],
+    [ :on_magenta   ,  45 ],
+    [ :on_cyan      ,  46 ],
+    [ :on_white     ,  47 ] ].each do |name,code|
+
+    class_eval <<-CODE
+      def #{name.to_s}( str )
+        "\e[#{code}m\#{str}\e[0m"
+      end
+    CODE
+  end
+
+end  # class Journal
+end  # module Webby
+
+# EOF

data/lib/webby/renderer.rb

@@ -36,6 +36,9 @@ class Renderer
     renderer = self.new(page)
 
     loop {
+      FileUtils.mkdir_p ::File.dirname(page.destination)
+      journal.create_or_update(page)
+
       ::File.open(page.destination, 'w') do |fd|
         fd.write(renderer._layout_page)
       end
@@ -43,6 +46,8 @@ class Renderer
     }
   end
 
+  attr_reader :logger
+
   # call-seq:
   #    Renderer.new( page )
   #
@@ -64,7 +69,7 @@ class Renderer
 
     @_bindings = []
     @_content_for = {}
-    @log = Logging::Logger[self]
+    @logger = Logging::Logger[self]
   end
 
   # call-seq:
@@ -227,11 +232,11 @@ class Renderer
 
     @content
   rescue ::Webby::Error => err
-    @log.error "while rendering page '#{@page.path}'"
-    @log.error err.message
+    logger.error "while rendering page '#{@page.path}'"
+    logger.error err.message
   rescue => err
-    @log.error "while rendering page '#{@page.path}'"
-    @log.fatal err
+    logger.error "while rendering page '#{@page.path}'"
+    logger.fatal err
     exit 1
   ensure
     @content = nil
@@ -271,7 +276,7 @@ class Renderer
       @_content_for.clear
       @_bindings.clear
     else
-      @pager.pager.done
+      @pager.pager.reset
       @pager = nil
       return false
     end