TwP-webby 0.9.0

data/lib/webby/stelan/spawner.rb

@@ -0,0 +1,339 @@
+require 'rbconfig'
+require 'thread'
+require 'tempfile'
+
+# :stopdoc:
+
+# == Synopsis
+#
+# A class for spawning child processes and ensuring those children continue
+# running.
+#
+# == Details
+#
+# When a spawner is created it is given the command to run in a child
+# process. This child process has +stdin+, +stdout+, and +stderr+ redirected
+# to +/dev/null+ (this works even on Windows). When the child dies for any
+# reason, the spawner will restart a new child process in the exact same
+# manner as the original.
+#
+class Spawner
+
+  @dev_null = test(?e, "/dev/null") ? "/dev/null" : "NUL:"
+
+  c = ::Config::CONFIG
+  ruby = File.join(c['bindir'], c['ruby_install_name']) << c['EXEEXT']
+  @ruby = if    system('%s -e exit' % ruby) then ruby
+          elsif system('ruby -e exit')      then 'ruby' 
+          else  warn 'no ruby in PATH/CONFIG'
+          end
+
+  class << self
+    attr_reader :ruby
+    attr_reader :dev_null
+
+    def finalizer( cids )
+      pid = $$
+      lambda do
+        break unless pid == $$
+        cids.kill 'TERM', :all
+      end  # lambda
+    end  # finalizer
+  end
+
+  # call-seq:
+  #    Spawner.new( command, *args, opts = {} )
+  #
+  # Creates a new spawner that will execute the given external _command_ in
+  # a sub-process. The calling semantics of <code>Kernel::exec</code> are
+  # used to execute the _command_. Any number of optional _args_ can be
+  # passed to the _command_.
+  #
+  # Available options:
+  #
+  #    :spawn   => the number of child processes to spawn
+  #    :pause   => wait time (in seconds) before respawning after termination
+  #    :ruby    => the Ruby interpreter to use when spawning children
+  #    :env     => a hash for the child process environment
+  #    :stdin   => stdin child processes will read from
+  #    :stdout  => stdout child processes will write to
+  #    :stderr  => stderr child processes will write to
+  #
+  # The <code>:env</code> option is used to add environemnt variables to
+  # child processes when they are spawned.
+  #
+  # *Note:* all spawned child processes will use the same stdin, stdout, and
+  # stderr if they are given in the options. Otherwise they all default to
+  # <code>/dev/null</code> on *NIX and <code>NUL:</code> on Windows.
+  #
+  def initialize( *args )
+    config = {
+      :ruby => self.class.ruby,
+      :spawn => 1,
+      :pause => 0,
+      :stdin => self.class.dev_null,
+      :stdout => self.class.dev_null,
+      :stderr => self.class.dev_null
+    }
+    config.merge! args.pop if Hash === args.last
+    config[:argv] = args
+
+    raise ArgumentError, 'wrong number of arguments' if args.empty?
+
+    @stop = true
+    @cids = []
+    @group = ThreadGroup.new
+
+    @spawn = config.delete(:spawn)
+    @pause = config.delete(:pause)
+    @ruby = config.delete(:ruby)
+
+    @tmp = child_program(config)
+
+    class << @cids
+      # call-seq:
+      #    sync {block}
+      #
+      # Executes the given block in a synchronized fashion -- i.e. only a
+      # single thread can execute at a time. Uses Mutex under the hood.
+      #
+      def sync(&b) 
+        @mutex ||= Mutex.new
+        @mutex.synchronize(&b)
+      end
+
+      # call-seq:
+      #    kill( signal, num )     => number killed
+      #    kill( signal, :all )    => number killed
+      #
+      # Send the _signal_ to a given _num_ of child processes or all child
+      # processes if <code>:all</code> is given instead of a number. Returns
+      # the number of child processes killed.
+      #
+      def kill( signal, arg )
+        return if empty?
+
+        ary = sync do
+                case arg
+                when :all; self.dup
+                when Integer; self.slice(0,arg)
+                else raise ArgumentError end
+              end
+
+        ary.each do |cid|
+          begin
+            Process.kill(signal, cid)
+          rescue SystemCallError
+            sync {delete cid}
+          end
+        end
+        ary.length
+      end  # def kill
+    end  # class << @cids
+
+  end  # def initialize
+
+  attr_reader :spawn
+  attr_accessor :pause
+
+  # call-seq:
+  #    spawner.spawn = num
+  #
+  # Set the number of child processes to spawn. If the new spawn number is
+  # less than the current number, then spawner threads will die 
+  #
+  def spawn=( num )
+    num = num.abs
+    diff, @spawn = num - @spawn, num
+    return unless running?
+
+    if diff > 0
+      diff.times {_spawn}
+    elsif diff < 0
+      @cids.kill 'TERM', diff.abs
+    end
+  end
+
+  # call-seq:
+  #    start    => self
+  #
+  # Spawn the sub-processes.
+  #
+  def start
+    return self if running?
+    @stop = false
+
+    @cleanup = Spawner.finalizer(@cids)
+    ObjectSpace.define_finalizer(self, @cleanup)
+
+    @spawn.times {_spawn}
+    self
+  end
+
+  # call-seq:
+  #    stop( timeout = 5 )    => self
+  #
+  # Stop any spawned sub-processes.
+  #
+  def stop( timeout = 5 )
+    return self unless running?
+    @stop = true
+
+    @cleanup.call
+    ObjectSpace.undefine_finalizer(self)
+
+    # the cleanup call sends SIGTERM to all the child processes
+    # however, some might still be hanging around, so we are going to wait
+    # for a timeout interval and then send a SIGKILL to any remaining child
+    # processes
+    nap_time = 0.05 * timeout   # sleep for 5% of the timeout interval
+    timeout = Time.now + timeout
+
+    until @cids.empty?
+      sleep nap_time
+      unless Time.now < timeout
+        @cids.kill 'KILL', :all
+        @cids.clear
+        @group.list.each {|t| t.kill}
+        break
+      end
+    end
+
+    self
+  end
+
+  # call-seq:
+  #    restart( timeout = 5 )
+  #
+  def restart( timeout = 5 )
+    stop( timeout )
+    start
+  end
+
+  # call-seq:
+  #    running?
+  #
+  # Returns +true+ if the spawner is currently running; returns +false+
+  # otherwise.
+  #
+  def running?
+    !@stop
+  end
+
+  # call-seq:
+  #    join( timeout = nil )    => spawner or nil
+  #
+  # The calling thread will suspend execution until all child processes have
+  # been stopped. Does not return until all spawner threads have exited (the
+  # child processes have been stopped) or until _timeout seconds have
+  # passed. If the timeout expires +nil+ will be returned; otherwise the
+  # spawner is returned.
+  #
+  def join( limit = nil )
+    loop do
+      t = @group.list.first
+      break if t.nil?
+      return nil unless t.join(limit)
+    end
+    self
+  end
+
+
+  private
+
+  # call-seq:
+  #    _spawn    => thread
+  #
+  # Creates a thread that will spawn the sub-process via
+  # <code>IO::popen</code>. If the sub-process terminates, it will be
+  # respawned until the +stop+ message is sent to this spawner.
+  #
+  # If an Exception is encountered during the spawning process, a message
+  # will be printed to stderr and the thread will exit.
+  #
+  def _spawn
+    t = Thread.new do
+          catch(:die) do
+            loop do
+              begin
+                io = IO.popen("#{@ruby} #{@tmp.path}", 'r')
+                cid = io.gets.to_i
+
+                @cids.sync {@cids << cid} if cid > 0
+                Process.wait cid
+              rescue Exception => e
+                STDERR.puts e.inspect
+                STDERR.puts e.backtrace.join("\n")
+                throw :die
+              ensure
+                io.close rescue nil
+                @cids.sync {
+                  @cids.delete cid
+                  throw :die unless @cids.length < @spawn
+                }
+              end
+
+              throw :die if @stop
+              sleep @pause
+
+            end  # loop
+          end  # catch(:die)
+        end  # Thread.new
+
+    @group.add t
+    t
+  end
+
+  # call-seq:
+  #    child_program( config )    => tempfile
+  #
+  # Creates a child Ruby program based on the given _config_ hash. The
+  # following hash keys are used:
+  #
+  #    :argv    => command and arguments passed to <code>Kernel::exec</code>
+  #    :env     => environment variables for the child process
+  #    :cwd     => the current working directory to use for the child process
+  #    :stdin   => stdin the child process will read from
+  #    :stdout  => stdout the child process will write to
+  #    :stderr  => stderr the child process will write to
+  #
+  def child_program( config )
+    config = Marshal.dump(config)
+
+    tmp = Tempfile.new(self.class.name.downcase)
+    tmp.write <<-PROG
+      begin
+        config = Marshal.load(#{config.inspect})
+
+        argv = config[:argv]
+        env = config[:env]
+        cwd = config[:cwd]
+        stdin = config[:stdin]
+        stdout = config[:stdout]
+        stderr = config[:stderr]
+
+        Dir.chdir cwd if cwd
+        env.each {|k,v| ENV[k.to_s] = v.to_s} if env
+      rescue Exception => e
+        STDERR.warn e
+        abort
+      end
+
+      STDOUT.puts Process.pid
+      STDOUT.flush
+
+      STDIN.reopen stdin
+      STDOUT.reopen stdout
+      STDERR.reopen stderr
+
+      exec *argv
+    PROG
+
+    tmp.close
+    tmp
+  end
+end  # class Spawner
+
+# :startdoc:
+
+# EOF

data/lib/webby/tasks/build.rake

@@ -0,0 +1,27 @@
+
+task :configure_basepath do
+  Webby.site.base = ENV['BASE'] if ENV.has_key?('BASE')
+end
+
+desc "Build the website"
+task :build => :configure_basepath do |t|
+  Webby::Builder.run
+end
+
+desc "Rebuild the website"
+task :rebuild => :configure_basepath do |t|
+  Webby::Builder.run :rebuild => true
+end
+
+desc "Continuously build the website"
+task :autobuild => :configure_basepath do |t|
+  Webby::AutoBuilder.run
+end
+
+desc "Delete the website"
+task :clobber do |t|
+  rm_rf Webby.site.output_dir
+  mkdir Webby.site.output_dir
+end
+
+# EOF

data/lib/webby/tasks/create.rake

@@ -0,0 +1,22 @@
+
+namespace :create do
+
+  FileList["#{Webby.site.template_dir}/*"].each do |template|
+    next unless test(?f, template)
+    name = template.pathmap '%n'
+
+    # if the file is a partial template
+    name = $1 if name =~ %r/^_(.*)/
+
+    desc "Create a new #{name}"
+    task name do |t|
+      page, title, dir = Webby::Builder.new_page_info
+      page = Webby::Builder.create(page, :from => template,
+                 :locals => {:title => title, :directory => dir})
+      exec(::Webby.editor, page) unless ::Webby.editor.nil?
+    end
+  end  # each
+
+end  # namespace :create
+
+# EOF

data/lib/webby/tasks/deploy.rake

@@ -0,0 +1,22 @@
+
+require 'rake/contrib/sshpublisher'
+
+namespace :deploy do
+
+  desc 'Deploy to the server using rsync'
+  task :rsync do
+    cmd = "rsync #{SITE.rsync_args.join(' ')} "
+    cmd << "#{SITE.output_dir}/ #{SITE.user}@#{SITE.host}:#{SITE.remote_dir}"
+    sh cmd
+  end
+
+  desc 'Deploy to the server using ssh'
+  task :ssh do
+    Rake::SshDirPublisher.new(
+        "#{SITE.user}@#{SITE.host}", SITE.remote_dir, SITE.output_dir
+    ).upload
+  end
+
+end  # deploy
+
+# EOF

data/lib/webby/tasks/growl.rake

@@ -0,0 +1,15 @@
+
+unless WINDOWS
+
+task :growl do
+  Logging::Logger['Webby'].add_appenders(Logging::Appenders::Growl.new(
+    "Webby",
+    :layout => Logging::Layouts::Pattern.new(:pattern => "%5l - Webby\000%m"),
+    :coalesce => true,
+    :separator => "\000"
+  ))
+end
+
+end  # unless WINDOWS
+
+# EOF

data/lib/webby/tasks/heel.rake

@@ -0,0 +1,28 @@
+
+namespace :heel do
+
+  desc 'Start the heel server to view website (not for Windows)'
+  task :start do
+    sh "heel --root #{SITE.output_dir} --port #{SITE.heel_port} --daemonize"
+  end
+  
+  desc 'Stop the heel server'
+  task :stop do
+    sh "heel --kill"
+  end
+
+  task :autorun do
+    heel_exe = File.join(Gem.bindir, 'heel')
+    @heel_spawner = Spawner.new(Spawner.ruby, heel_exe, '--root', SITE.output_dir, '--port', SITE.heel_port.to_s, :pause => 86_400)
+    @heel_spawner.start
+  end
+
+  task :autobuild => :autorun do
+    at_exit {@heel_spawner.stop if defined? @heel_spawner and not @heel_spawner.nil?}
+  end
+
+end
+
+task :autobuild => 'heel:autobuild'
+
+# EOF

data/lib/webby/tasks/validate.rake

@@ -0,0 +1,19 @@
+
+namespace :validate do
+
+  desc 'Validate hyperlinks (exclude exteranl sites)'
+  task :internal => :build do
+    Webby::LinkValidator.validate(:external => false)
+  end
+
+  desc 'Validate hyperlinks (include external sites)'
+  task :external => :build do
+    Webby::LinkValidator.validate(:external => true)
+  end
+
+end  # validate
+
+desc 'Alias to validate:internal'
+task :validate => 'validate:internal'
+
+# EOF

data/lib/webby.rb

@@ -0,0 +1,227 @@
+# Equivalent to a header guard in C/C++
+# Used to prevent the spec helper from being loaded more than once
+unless defined? ::Webby
+
+require 'rubygems'
+require 'logging'
+require 'ostruct'
+require 'date'
+
+# Configure Webby to log to STDOUT at the 'info' level
+Logging::Logger['Webby'].level = :info
+Logging::Logger['Webby'].add_appenders(Logging::Appender.stdout)
+Logging::Appender.stdout.layout = Logging::Layouts::Pattern.new(
+    :pattern      => "[%d] %5l: %m\n",    # [date] LEVEL: message
+    :date_pattern => "%H:%M:%S"           # date == HH:MM:SS
+)
+
+module Webby
+
+  # :stopdoc:
+  VERSION = '0.9.0'   # :nodoc:
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  class Error < StandardError; end  # :nodoc:
+
+  # call-seq:
+  #    Webby.site    => struct
+  #
+  # Returns a struct containing the configuration parameters for the 
+  # Webby site. These defaults should be overridden as needed in the
+  # site specific Rakefile.
+  #
+  def self.site
+    return @site if defined? @site
+    @site = OpenStruct.new(
+      :output_dir    => 'output',
+      :content_dir   => 'content',
+      :layout_dir    => 'layouts',
+      :template_dir  => 'templates',
+      :exclude       => %w(tmp$ bak$ ~$ CVS \.svn),
+      :page_defaults => {
+        'layout'     => 'default'
+      },
+      :find_by       => 'title',
+      :base          => nil,
+      :create_mode   => 'page',
+      :blog_dir      => 'blog',
+      :tumblog_dir   => 'tumblog',
+
+      # Items for running the heel webserver
+      :heel_port => 4331,
+
+      # Items used to deploy the website
+      :user       => ENV['USER'] || ENV['USERNAME'],
+      :host       => 'example.com',
+      :remote_dir => '/not/a/valid/dir',
+      :rsync_args => %w(-av),
+
+      # Global options for HAML and SASS
+      :haml_options => {},
+      :sass_options => {},
+
+      # Options passed to the 'tidy' program when the tidy filter is used
+      :tidy_options => '-indent -wrap 80',
+
+      # List of valid URIs (these automatically pass validation)
+      :valid_uris => [],
+
+      # Options for coderay processing
+      :coderay => {
+        :lang => :ruby,
+        :line_numbers => nil,
+        :line_number_start => 1,
+        :bold_every => 10,
+        :tab_width => 8
+      },
+
+      # Options for graphviz processing
+      :graphviz => {
+        :path => nil,
+        :cmd => 'dot',
+        :type => 'png'
+      },
+
+      # Options for tex2img processing
+      :tex2img => {
+        :path => nil,
+        :type => 'png',
+        :bg => 'white',
+        :fg => 'black',
+        :resolution => '150x150'
+      },
+
+      # Options for ultraviolet syntax highlighting
+      :uv => {
+        :lang => 'ruby',
+        :line_numbers => false,
+        :theme => 'mac_classic'
+      },
+
+      # XPath identifiers used by the basepath filter
+      :xpaths => %w(
+          /html/head//base[@href]
+          /html/head//link[@href]
+          //script[@src]
+          /html/body[@background]
+          /html/body//a[@href]
+          /html/body//object[@data]
+          /html/body//img[@src]
+          /html/body//area[@href]
+          /html/body//form[@action]
+          /html/body//input[@src]
+      )
+      # other possible XPaths to include for base path substitution
+      #   /html/body//object[@usemap]
+      #   /html/body//img[@usemap]
+      #   /html/body//input[@usemap]
+    )
+  end
+
+  # call-seq
+  #    Webby.exclude    => regexp
+  #
+  # Returns a regular expression used to exclude resources from the content
+  # directory from being processed by Webby. This same regular expression is
+  # also used to exclude layouts.
+  #
+  def self.exclude
+    @exclude ||= Regexp.new(site.exclude.join('|'))
+  end
+
+  # call-seq:
+  #    Webby.editor    => string or nil
+  #
+  # Returns the default editor to use when creating new pages. This editor
+  # will be spawned to allow the user to edit the newly created page.
+  #
+  def self.editor
+    return @editor if defined? @editor
+
+    @editor = if ENV['EDITOR'].nil? or ENV['EDITOR'].empty? then nil
+              else ENV['EDITOR'] end
+  end
+
+  # call-seq:
+  #    cairn    => filename
+  #
+  # The Webby _cairn_ file is used to mark the last time the content was
+  # built into the output directory. It is an empty file; only the
+  # modification time of the file is important.
+  #
+  def self.cairn
+    @cairn ||= ::File.join(site.output_dir, '.cairn')
+  end
+
+  # Returns the library path for Webby. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the path for Webby. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # call-seq:
+  #    Webby.require_all_libs_relative_to( filename, directory = nil )
+  #
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+  # Prints a deprecation warning using the logger. The message states that
+  # the given method is being deprecated. An optional message can be give to
+  # -- somthing nice and fuzzy about a new method or why this one has to go
+  # away; sniff, we'll miss you little buddy.
+  #
+  def self.deprecated( method, message = nil )
+    msg = "'#{method}' has been deprecated"
+    msg << "\n\t#{message}" unless message.nil?
+    Logging::Logger['Webby'].warn msg
+  end
+
+end  # module Webby
+
+
+# call-seq:
+#    try_require( library, gemname = nil )    => true or false
+#
+# Try to laod the given _library_ using the built-in require, but do not
+# raise a LoadError if unsuccessful. Returns +true+ if the _library_ was
+# successfully loaded; returns +false+ otherwise.
+#
+# If a _gemname_ is given, then the "gem gemname" command will be called
+# before the library is loaded.
+#
+def try_require( lib, gemname = nil )
+  gem gemname unless gemname.nil?
+  require lib
+  true
+rescue LoadError
+  false
+end
+
+Webby.require_all_libs_relative_to(__FILE__, ::File.join(%w[webby core_ext]))
+Webby.require_all_libs_relative_to(__FILE__)
+
+end  # unless defined?
+
+# EOF