jamesgolick-webby 0.9.5

data/lib/webby/apps/main.rb

@@ -0,0 +1,258 @@
+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
+
+  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
+  # 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 ''
+
+    desired_opts = %[--describe --prereqs --tasks --trace]
+    app.standard_rake_options.each do |options|
+      next unless desired_opts.include?(options.first)
+      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:'
+
+    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
+    options = app.standard_rake_options
+    [['--rakefile', 'Sitefile'],
+     ['--no-search', nil],
+     ['--silent', nil]].each {|opt, value| options.assoc(opt).last.call(value)}
+
+    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
+    load_command_line_options
+    app.top_level
+  end
+
+  # Return the Rake application object.
+  #
+  def app
+    Rake.application
+  end
+
+  # Returns the options hash from the Rake application object.
+  #
+  def options
+    app.options
+  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,
+      :rake => ARGV.dup
+    )
+
+    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.basename(dashed).to_url
+    args.title = ::Webby::Resources.basename(spaced).titlecase
+
+    # page should be dir/slug without leading /
+    args.page  = ::File.join(args.dir, args.slug).gsub(/^\//, '')
+
+    ext = ::File.extname(dashed)
+    args.page << ext unless ext.empty?
+
+    ::Webby.site.args = args
+    Object.const_set(:SITE, Webby.site)
+    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
+
+# :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 = truncate_output? ? terminal_width - name.size - width - 7 : nil
+      displayable_tasks.each do |t|
+        printf "#{name} %-#{width}s  # %s\n",
+          t.name_with_args, max_column ? truncate(t.comment, max_column) : t.comment
+      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, OptionParser::InvalidOption => ex
+      # Exit silently
+      exit(1)
+    rescue Exception => ex
+      # Exit with error message
+      $stderr.puts "#{name} 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/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? ? Webby.site.default_ext : ext)
+      elsif ::Webby.site.create_mode == 'directory' and name != 'index'
+        page = ::File.join(::Webby.site.content_dir, dir, name, 'index')
+        page << '.' << (ext.empty? ? Webby.site.default_ext : ext)
+      else
+        page = ::File.join(::Webby.site.content_dir, page)
+        page << '.' << Webby.site.default_ext 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