webby 0.4.0 → 0.5.0

data/lib/webby/resource.rb

@@ -1,4 +1,4 @@
-# $Id: resource.rb 17 2007-08-28 04:11:00Z tim_pease $
+# $Id: resource.rb 46 2007-11-27 03:31:29Z tim_pease $
 
 module Webby
 
@@ -54,6 +54,9 @@ class Resource
   # Resource file modification time
   attr_reader :mtime
 
+  # Resource page number (if needed)
+  attr_reader :number
+
   # call-seq:
   #    Resource.new( filename )    => resource
   #
@@ -66,6 +69,7 @@ class Resource
     @ext      = ::File.extname(@path).sub(%r/\A\.?/o, '')
     @mtime    = ::File.mtime @path
 
+    @number = nil
     @rendering = false
 
     # deal with the meta-data
@@ -119,7 +123,7 @@ class Resource
     return @mdata['extension'] if @mdata.has_key? 'extension'
 
     if @mdata.has_key? 'layout'
-      lyt = self.class.layouts.find_by_name @mdata['layout']
+      lyt = self.class.layouts.find :filename => @mdata['layout']
       break if lyt.nil?
       return lyt.extension
     end
@@ -138,18 +142,45 @@ class Resource
   # the 'destination' propery in the resource's meta-data.
   #
   def destination
-    return @dest if defined? @dest
-    return @dest = ::Webby.config['output_dir'] if is_layout?
+    return @dest if defined? @dest and @dest
+    return @dest = ::Webby.cairn if is_layout?
 
     @dest = if @mdata.has_key? 'destination' then @mdata['destination']
             else File.join(dir, filename) end
 
     @dest = File.join(::Webby.config['output_dir'], @dest)
+    @dest << @number.to_s if @number
     @dest << '.'
     @dest << extension
     @dest
   end
 
+  # call-seq
+  #    href    => string or nil
+  #
+  # Returns a string suitable for use as an href linking to this page. Nil
+  # is returned for layouts.
+  #
+  def href
+    return nil if is_layout?
+    return @href if defined? @href and @href
+
+    @href = destination.sub(::Webby.config['output_dir'], '')
+    @href
+  end
+
+  # call-seq:
+  #    resource.number = Integer
+  #
+  # Sets the page number for the current resource to the given integer. This
+  # number is used to modify the output destination for resources that
+  # require pagination.
+  #
+  def number=( num )
+    @number = num
+    @dest = nil
+  end
+
   # call-seq:
   #    render   => string
   #
@@ -160,11 +191,12 @@ class Resource
   # Note, this only renders this resource. The returned string does not
   # include any layout rendering.
   #
-  def render
+  def render( renderer = nil )
     raise Error, "page '#@path' is in a rendering loop" if @rendering
 
     @rendering = true
-    content = Renderer.new(self).render_page
+    renderer ||= Renderer.new(self)
+    content = renderer.render_page
     @rendering = false
 
     return content
@@ -213,23 +245,24 @@ class Resource
     return @mdata['dirty'] if @mdata.has_key? 'dirty'
 
     # if the destination file does not exist, then we are dirty
-    return @mdata['dirty'] = true unless test ?e, destination
+    return true unless test ?e, destination
 
     # if this file's mtime is larger than the destination file's
     # mtime, then we are dirty
-    @mdata['dirty'] = @mtime > File.mtime(destination)
-    return @mdata['dirty'] if is_static? or @mdata['dirty']
+    dirty = @mtime > File.mtime(destination)
+    return dirty if is_static? or dirty
 
     # check to see if the layout is dirty, and it it is then we
     # are dirty, too
     if @mdata.has_key? 'layout'
-      lyt = self.class.layouts.find_by_name @mdata['layout']
-      break if lyt.nil?
-      return @mdata['dirty'] = true if lyt.dirty?
+      lyt = self.class.layouts.find :filename => @mdata['layout']
+      unless lyt.nil?
+        return true if lyt.dirty?
+      end
     end
 
     # if we got here, then we are not dirty
-    @mdata['dirty'] = false
+    false
   end
 
   # call-seq:

data/lib/webby/stelan/paginator.rb

@@ -0,0 +1,149 @@
+# This code was originally written by Bruce Williams, and it is available
+# as the Paginator gem. I've added a few helper methods and modifications so
+# it plays a little more nicely with Webby. Specifically, a Webby::Resource
+# can be given to the Page and used to generate links to the previous and
+# next pages.
+#
+# Many thanks to Bruce Williams for letting me use his work. Drop him a note
+# of praise scribbled on the back of a $100 bill. He'd appreciate it.
+
+require 'forwardable'
+
+module Webby
+class Paginator
+  
+  include Enumerable
+
+  class ArgumentError < ::ArgumentError; end
+  class MissingCountError < ArgumentError; end
+  class MissingSelectError < ArgumentError; end  
+  
+  attr_reader :per_page, :count, :resource
+  
+  # Instantiate a new Paginator object
+  #
+  # Provide:
+  # * A total count of the number of objects to paginate
+  # * The number of objects in each page
+  # * A block that returns the array of items
+  #   * The block is passed the item offset 
+  #     (and the number of items to show per page, for
+  #     convenience, if the arity is 2)
+  def initialize(count, per_page, resource, &select)
+    @count, @per_page, @resource = count, per_page, resource
+    unless select
+      raise MissingSelectError, "Must provide block to select data for each page"
+    end
+    @select = select
+  end
+  
+  # Total number of pages
+  def number_of_pages
+     (@count / @per_page).to_i + (@count % @per_page > 0 ? 1 : 0)
+  end
+  
+  # First page object
+  def first
+    page 1
+  end
+  
+  # Last page object
+  def last
+    page number_of_pages
+  end
+  
+  def each
+    1.upto(number_of_pages) do |number|
+      yield page(number)
+    end
+  end
+  
+  # Retrieve page object by number
+  def page(number)
+    number = (n = number.to_i) > 0 ? n : 1
+    Page.new(self, number, lambda { 
+      offset = (number - 1) * @per_page
+      args = [offset]
+      args << @per_page if @select.arity == 2
+      @select.call(*args)
+    })
+  end
+  
+  # Page object
+  #
+  # Retrieves items for a page and provides metadata about the position
+  # of the page in the paginator
+  class Page
+    
+    include Enumerable
+        
+    attr_reader :number, :pager
+    
+    def initialize(pager, number, select) #:nodoc:
+      @pager, @number = pager, number
+      @offset = (number - 1) * pager.per_page
+      @select = select
+
+      @pager.resource.number = number
+    end
+    
+    # Retrieve the items for this page
+    # * Caches
+    def items
+      @items ||= @select.call
+    end
+    
+    # Checks to see if there's a page before this one
+    def prev?
+      @number > 1
+    end
+    
+    # Get previous page (if possible)
+    def prev
+      @pager.page(@number - 1) if prev?
+    end
+     
+    # Checks to see if there's a page after this one
+    def next?
+      @number < @pager.number_of_pages
+    end
+     
+    # Get next page (if possible)
+    def next
+      @pager.page(@number + 1) if next?
+    end
+     
+    # The "item number" of the first item on this page
+    def first_item_number
+      1 + @offset
+    end
+     
+    # The "item number" of the last item on this page
+    def last_item_number
+      if next?
+        @offset + @pager.per_page
+      else
+        @pager.count
+      end
+    end
+     
+    def ==(other) #:nodoc:
+      @pager == other.pager && self.number == other.number
+    end
+     
+    def each(&block)
+      items.each(&block)
+    end
+     
+    def method_missing(meth, *args, &block) #:nodoc:
+      if @pager.respond_to?(meth)
+        @pager.__send__(meth, *args, &block)
+      else
+        super
+      end
+    end
+
+  end
+  
+end  # class Paginator
+end  # module Webby

data/lib/webby/stelan/spawner.rb

@@ -0,0 +1,337 @@
+# $Id: spawner.rb 46 2007-11-27 03:31:29Z tim_pease $
+
+require 'rbconfig'
+require 'thread'
+require 'tempfile'
+
+# == 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
+
+# EOF