TwP-webby 0.9.0

data/lib/webby/apps/generator.rb

@@ -0,0 +1,283 @@
+require 'fileutils'
+require 'optparse'
+
+module Webby::Apps
+
+# webby gen template site  => creates the tmplate
+# webby gen -h / --help
+# webby gen       => same as --help
+#
+
+class Generator
+
+  # Create a new Generator instance and run the +webby+ application given the
+  # command line _args_.
+  #
+  def self.run( args )
+    self.new.run args
+  end
+
+  attr_accessor :template, :site
+  attr_reader :options
+
+  # Initialize a new generator object.
+  #
+  def initialize
+    @options = {}
+    @site = @template = nil
+    @stdout, @stdin = $stdout, $stdin
+  end
+
+  # Run the generator executing the commands specified by the user on the
+  # command line.
+  #
+  def run( args )
+    parse args
+    create_site
+  end
+
+  # Parse out the command line options found in the args array.
+  #
+  def parse( args )
+    opts = OptionParser.new
+    opts.banner = 'Usage: webby-gen [options] template site'
+
+    opts.separator ''
+    opts.separator 'The webby-gen command is used to generate a site from a standard template.'
+    opts.separator 'A new site can be created, or an existing site can be added to or updated.'
+
+    opts.separator ''
+    opts.on('-f', '--force',
+            'overwrite files that already exist') {options[:collision] = :force}
+    opts.on('-s', '--skip',
+            'skip files that already exist') {options[:collision] = :skip}
+    opts.on('-u', '--update',
+            'update rake tasks for the site') {options[:update] = true}
+    opts.on('-p', '--pretend',
+            'run but do not make any changes') {options[:pretend] = true}
+
+    opts.separator ''
+    opts.on('-t', '--templates', 'list available templates') {
+      ary = templates.map {|t| ::File.basename(t)}
+      ary.delete 'webby'
+      @stdout.puts "\nAvailable Templates"
+      @stdout.puts "    #{ary.join(', ')}"
+      @stdout.puts
+      exit
+    }
+
+    opts.separator ''
+    opts.separator 'common options:'
+
+    opts.on( '-h', '--help', 'show this message' ) {@stdout.puts opts; exit}
+    opts.on( '--version', 'show version' ) do
+      @stdout.puts "Webby #{::Webby::VERSION}"
+      exit
+    end
+
+    # parse the command line arguments
+    opts.parse! args
+    tmpl, @site = args
+
+    # if no site was given, see if there is a Sitefile in the current
+    # directory
+    if site.nil?
+      self.site = '.' if test(?f, 'Sitefile')
+    end
+
+    # exit if comand line args are missing
+    if site.nil? or tmpl.nil?
+      @stdout.puts opts
+      exit 1
+    end
+
+    templates.each {|t| self.template = t if t =~ %r/\/#{tmpl}$/}
+    if template.nil?
+      @stdout.puts opts
+      abort "Could not find template '#{tmpl}'"
+    end
+
+    nil
+  end
+
+  # Returns +true+ if we are only going to pretend to do something. All the
+  # output messages will be written, but no changes will be made on the
+  # disc.
+  #
+  def pretend?
+    options[:pretend] == true
+  end
+
+  # Returns an array of available site templates.
+  #
+  def templates
+    Dir.glob(::Webby.path('examples') / '*').sort
+  end
+
+  # Create the site from the template specified by the user.
+  #
+  def create_site
+    files = site_files
+
+    # in update mode we only want to update the tasks directory
+    if options[:update]
+      FileUtils.mkdir_p site unless pretend?
+      mkdir 'tasks'
+      files['tasks'].sort.each {|file| cp file}
+    else
+      dirs = files.keys.concat %w[content layouts lib tasks templates]
+      dirs.sort!
+      dirs.uniq!
+
+      # create the directories first
+      dirs.each do |dir|
+        next if dir =~ %r/^output\/.*$/
+        mkdir dir
+      end
+
+      # and the create the files under each directory
+      dirs.each do |dir|
+        next if dir =~ %r/^output(\/.*)?$/
+        files[dir].sort.each {|file| cp file}
+      end
+    end
+  end
+
+  # Make a directory in the user specified site location. A message will be
+  # displayed to the screen indicating tha the directory is being created.
+  #
+  def mkdir( dir )
+    dir = dir.empty? ? site : site / dir
+    if test ?d, dir
+      exists dir
+    else
+      create dir
+      FileUtils.mkdir_p dir unless pretend?
+    end
+  end
+
+  # Copy a file from the template location to the user specified site
+  # location. A message will be displayed to the screen indicating tha the
+  # file is being created.
+  #
+  def cp( file )
+    src = template / file
+    dst = site / file
+
+    if test(?e, dst) 
+      if identical?(src, dst)
+        identical(dst)
+        return
+      end
+
+      choice = case options[:collision]
+        when :force then :force
+        when :skip  then :skip
+        else force_file_collision?( dst ) end
+
+      case choice
+        when :force then force(dst)
+        when :skip  then skip(dst); return
+        else raise "Invalid collision choice: #{choice.inspect}" end
+    else
+      create(dst)
+    end
+    return if pretend?
+
+    if WINDOWS then win_line_endings(src, dst)
+    else FileUtils.cp(src, dst) end
+  end
+
+  # Copy the file from the _src_ location to the _dst_ location and
+  # transform the line endings to the windows "\r\n" format.
+  #
+  def win_line_endings( src, dst )
+    case ::File.extname(src)
+    when *%w[.png .gif .jpg .jpeg]
+      FileUtils.cp src, dst
+    else
+      ::File.open(dst,'w') do |fd|
+        ::File.foreach(src, "\n") do |line|
+          line.tr!("\r\n",'')
+          fd.puts line
+        end
+      end
+    end
+  end
+
+  %w[exists create force skip identical].each do |m|
+    class_eval "def #{m}( msg ) message('#{m}', msg); end"
+  end
+
+  # Print the given message and message type to stdout.
+  #
+  def message( type, msg )
+    msg = msg.sub(%r/#{site}\/?/, '')
+    return if msg.empty?
+    @stdout.puts "%13s  %s" % [type, msg]
+  end
+
+  # Prints an abort message to the screen and then exits the Ruby
+  # interpreter. A non-zero return code is used to indicate an error.
+  #
+  def abort( msg )
+    @stdout.puts "\nAborting!"
+    @stdout.puts "    #{msg}"
+    @stdout.puts
+    exit 1
+  end
+
+  # Iterates over all the files in the template directory and stores them in
+  # a hash.
+  #
+  def site_files
+    exclude = %r/tmp$|bak$|~$|CVS|\.svn/o
+
+    rgxp = %r/\A#{template}\/?/o
+    paths = Hash.new {|h,k| h[k] = []}
+
+    Find.find(template) do |p|
+      next if exclude =~ p
+
+      if test(?d, p)
+        paths[p.sub(rgxp, '')]
+        next
+      end
+      dir = ::File.dirname(p).sub(rgxp, '')
+      paths[dir] << p.sub(rgxp, '')
+    end
+
+    paths
+  end
+
+  # Returns +true+ if the source file is identical to the destination file.
+  # Returns +false+ if this is not the case.
+  #
+  def identical?( src, dst )
+    # FIXME: this most likely won't work on windows machines
+    #        because the line endings are modified when the site is gnerated
+    source      = IO.read(src)
+    destination = IO.read(dst)
+    source == destination
+  end
+
+  # Ask the user what to do about the file collision.
+  #
+  def force_file_collision?( dst )
+    dst = dst.sub(%r/#{site}\/?/, '')
+    @stdout.print "overwrite #{dst}? [(Y)es (n)o (q)uit] "
+    @stdout.flush
+    case @stdin.gets
+      when %r/q/i  then abort 'user asked to quit'
+      when %r/n/i  then :skip
+      when %r/y/i  then :force
+      when %r/\s*/ then :force
+      else force_file_collision?(dst) end
+  rescue
+    retry
+  end
+
+end  # class Generator
+end  # module Webby::Apps
+
+# EOF

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

@@ -0,0 +1,83 @@
+require 'directory_watcher'
+
+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
+
+  # call-seq:
+  #    AutoBuilder.new
+  #
+  # Create a new AutoBuilder class.
+  #
+  def initialize
+    @log = Logging::Logger[self]
+
+    @builder = Builder.new
+    @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
+  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|
+      @log.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
+  rescue => err
+    @log.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
+    @log.info 'starting autobuild (Ctrl-C to stop)'
+
+    Signal.trap('INT') {@watcher.stop}
+
+    @watcher.start
+    @watcher.join
+  end
+
+end  # class AutoBuilder
+end  # module Webby
+
+# EOF