TwP-webby 0.9.0

data/lib/webby/resources/partial.rb

@@ -0,0 +1,79 @@
+require Webby.libpath(*%w[webby resources resource])
+
+module Webby::Resources
+
+# A Partial is a file in the content folder whose filename starts with an
+# underscore "_" character. Partials contain text that can be included into
+# other pages. Partials are not standalone pages, and they will never
+# correspond directly to an output file.
+#
+# Partials can contain YAML meta-data at the top of the file. This
+# information is only used to determine the filters to apply to the
+# partial. If there is no meta-data, then the partial text is used "as is"
+# without any processing by the Webby rendering engine.
+#
+class Partial < Resource
+
+  # call-seq:
+  #    Partial.new( path )
+  #
+  # Creates a new Partial object given the full path to the partial file.
+  # Partial filenames start with an underscore (this is an enforced
+  # convention).
+  #
+  def initialize( fn )
+    super
+
+    @mdata = ::Webby::Resources::File.meta_data(@path)
+    @mdata ||= {}
+    @mdata.sanitize!
+  end
+
+  # call-seq:
+  #    dirty?    => true or false
+  #
+  # Returns +true+ if this resource is newer than its corresponding output
+  # product. The resource needs to be rendered (if a page or layout) or
+  # copied (if a static file) to the output directory.
+  #
+  def dirty?
+    return @mdata['dirty'] if @mdata.has_key? 'dirty'
+
+    # if the destination file does not exist, then we are dirty
+    return true unless test(?e, destination)
+
+    # if this file's mtime is larger than the destination file's
+    # mtime, then we are dirty
+    dirty = @mtime > ::File.mtime(destination)
+    return dirty if dirty
+
+    # if we got here, then we are not dirty
+    false
+  end
+
+  # call-seq:
+  #    destination    => string
+  #
+  # The output file destination for the partial. This is the ".cairn" file in
+  # the output folder. It is used to determine if the partial is newer than
+  # the build products.
+  #
+  def destination
+    ::Webby.cairn
+  end
+
+  alias :extension :ext
+
+  # call-seq:
+  #    url    => nil
+  #
+  # Partials do not have a URL. This method will alwasy return +nil+.
+  #
+  def url
+    nil
+  end
+
+end  # class Partial
+end  # module Webby::Resources
+
+# EOF

data/lib/webby/resources/resource.rb

@@ -0,0 +1,160 @@
+unless defined? Webby::Resources::Resource
+
+module Webby::Resources
+
+# A Webby::Resource is any file that can be found in the content directory
+# or in the layout directory. This class contains information about the
+# resources available to Webby.
+#
+class Resource
+
+  instance_methods.each do |m|
+      undef_method(m) unless m =~ %r/\A__|\?$/ ||
+                             m == 'class'
+  end
+
+  # The full path to the resource file
+  attr_reader :path
+
+  # The directory of the resource excluding the content directory
+  attr_reader :dir
+
+  # The resource filename excluding path and extension
+  attr_reader :filename
+
+  # Extesion of the resource file
+  attr_reader :ext
+
+  # Resource file modification time
+  attr_reader :mtime
+
+  # call-seq:
+  #    Resource.new( filename )    => resource
+  #
+  # Creates a new resource object given the _filename_.
+  #
+  def initialize( fn )
+    @path     = fn
+    @dir      = ::Webby::Resources::File.dirname(@path)
+    @filename = ::Webby::Resources::File.basename(@path)
+    @ext      = ::Webby::Resources::File.extname(@path)
+    @mtime    = ::File.mtime @path
+
+    @mdata = @@mdata ||= {}
+  end
+
+  # call-seq:
+  #    equal?( other )    => true or false
+  #
+  # Returns +true+ if the path of this resource is equivalent to the path of
+  # the _other_ resource. Returns +false+ if this is not the case.
+  #
+  def equal?( other )
+    return false unless other.kind_of? ::Webby::Resources::Resource
+    @path == other.path
+  end
+  alias :== :equal?
+  alias :eql? :equal?
+
+  # call-seq:
+  #    resource <=> other    => -1, 0, +1, or nil
+  #
+  # Resource comparison operates on the full path of the resource objects
+  # and uses the standard String comparison operator. Returns +nil+ if
+  # _other_ is not a Resource instance.
+  #
+  def <=>( other )
+    return unless other.kind_of? ::Webby::Resources::Resource
+    @path <=> other.path
+  end
+
+  # call-seq:
+  #    resource[key]    => value or nil
+  #
+  # Returns the value associated with the given meta-data key. Key is
+  # converted into a string.
+  #
+  def []( key )
+    @mdata[key.to_s]
+  end
+
+  # call-seq:
+  #    resource[key] = value
+  #
+  # Sets the given meta-data key to the value. Key is converted into a
+  # string.
+  #
+  def []=( key, value )
+    @mdata[key.to_s] = value
+  end
+
+  # call-seq:
+  #    method_missing( symbol [, *args, &block] )    => result
+  #
+  # Invoked by Ruby when a message is sent to the resource that it cannot
+  # handle. The default behavior is to convert _symbol_ to a string and
+  # search for that string in the resource's meta-data. If found, the
+  # meta-data item is returned; otherwise, +nil+ is returned.
+  #
+  def method_missing( name, *a, &b )
+    @mdata[name.to_s]
+  end
+
+  # call-seq:
+  #    dirty?    => true or false
+  #
+  # Returns +true+ if this resource is newer than its corresponding output
+  # product. The resource needs to be rendered (if a page or layout) or
+  # copied (if a static file) to the output directory.
+  #
+  def dirty?
+    return @mdata['dirty'] if @mdata.has_key? 'dirty'
+
+    # if the destination file does not exist, then we are dirty
+    return true unless test(?e, destination)
+
+    # if this file's mtime is larger than the destination file's
+    # mtime, then we are dirty
+    dirty = @mtime > ::File.mtime(destination)
+    return dirty if dirty
+
+    # check to see if the layout is dirty, and if it is then we
+    # are dirty, too
+    if @mdata.has_key? 'layout'
+      lyt = ::Webby::Resources.find_layout(@mdata['layout'])
+      unless lyt.nil?
+        return true if lyt.dirty?
+      end
+    end
+
+    # if we got here, then we are not dirty
+    false
+  end
+
+  # call-seq
+  #    url    => string or nil
+  #
+  # Returns a string suitable for use as a URL linking to this page. Nil
+  # is returned for layouts.
+  #
+  def url
+    return @url if defined? @url and @url
+    @url = destination.sub(::Webby.site.output_dir, '')
+  end
+
+  # :stopdoc:
+  def destination
+    raise NotImplementedError
+  end
+
+  def extension
+    raise NotImplementedError
+  end
+  # :startdoc:
+
+end  # class Resource
+end  # module Webby::Resources
+
+end  # unless defined?
+
+# EOF

data/lib/webby/resources/static.rb

@@ -0,0 +1,52 @@
+require Webby.libpath(*%w[webby resources resource])
+
+module Webby::Resources
+
+# A Static resource is any file in the content folder that does not
+# contain YAML meta-data at the top of the file and does not start with
+# and underscore "_" character (those are partials). Static resources will
+# be copied as-is from the content directory to the output directory.
+#
+class Static < Resource
+
+  # call-seq:
+  #    render   => string
+  #
+  # Returns the contents of the file.
+  #
+  def render
+    ::File.read(path)
+  end
+
+  # call-seq:
+  #    dirty?    => true or false
+  #
+  # Returns +true+ if this static file is newer than its corresponding output
+  # product. The static file needs to be copied to the output directory.
+  #
+  def dirty?
+    return true unless test(?e, destination)
+    @mtime > ::File.mtime(destination)
+  end
+
+  # call-seq:
+  #    destination    => string
+  #
+  # Returns the path in the output directory where the static file should
+  # be copied. This path is used to determine if the static file is dirty
+  # and in need of copying to the output file.
+  #
+  def destination
+    return @dest if defined? @dest and @dest
+
+    @dest = ::File.join(::Webby.site.output_dir, dir, filename)
+    @dest << '.' << @ext if @ext and !@ext.empty?
+    @dest
+  end
+
+  alias :extension :ext
+
+end  # class Layout
+end  # module Webby::Resources
+
+# EOF

data/lib/webby/resources.rb

@@ -0,0 +1,96 @@
+module Webby::Resources
+
+  class << self
+    # Returns the pages hash object.
+    #
+    def pages
+      @pages ||= ::Webby::Resources::DB.new
+    end
+
+    # Returns the layouts hash object.
+    #
+    def layouts
+      @layouts ||= ::Webby::Resources::DB.new
+    end
+
+    # Returns the partials hash object.
+    #
+    def partials
+      @partials ||= ::Webby::Resources::DB.new
+    end
+
+    # Clear the contents of the +layouts+, +pages+ and +partials+ hash
+    # objects.
+    #
+    def clear
+      self.pages.clear
+      self.layouts.clear
+      self.partials.clear
+    end
+
+    # call-seq:
+    #    Resources.new( filename )
+    #
+    #
+    def new( fn )
+      # normalize the path
+      fn = self.path(fn)
+
+      # see if we are dealing with a layout
+      if %r/\A#{::Webby.site.layout_dir}\//o =~ fn
+        r = ::Webby::Resources::Layout.new(fn)
+        self.layouts << r
+        return r
+      end
+
+      # see if we are dealing with a partial
+      filename = ::Webby::Resources::File.basename(fn)
+      if %r/\A_/o =~ filename
+        r = ::Webby::Resources::Partial.new(fn)
+        self.partials << r
+        return r
+      end
+
+      # see if we are dealing with a static resource
+      meta = ::Webby::Resources::File.meta_data(fn)
+      if meta.nil?
+        r = ::Webby::Resources::Static.new(fn)
+        self.pages << r
+        return r
+      end
+
+      # this is a renderable page
+      r = ::Webby::Resources::Page.new(fn)
+      self.pages << r
+      return r
+    end
+
+    # Returns a normalized path for the given filename.
+    #
+    def path( filename )
+      filename.sub(%r/\A(?:\.\/|\/)/o, '').freeze
+    end
+
+    # Returns the layout resource corresponding to the given _filename_ or
+    # +nil+ if no layout exists under that filename.
+    #
+    def find_layout( filename )
+      return if filename.nil?
+
+      fn  = ::Webby::Resources::File.basename(filename)
+      dir = ::File.dirname(filename)
+      dir = '.' == dir ? '' : dir
+
+      layouts.find(:filename => fn, :in_directory => dir)
+
+    rescue RuntimeError
+      raise Webby::Error, "could not find layout #{filename.inspect}"
+    end
+
+  end  # class << self
+
+end  # module Webby::Resources
+
+Webby.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/webby/stelan/mktemp.rb

@@ -0,0 +1,135 @@
+# :stopdoc:
+# Skeleton module for the 'mktemp' routine.
+#
+# Ideally, one would do this in their code to import the "mktemp" call
+# directly into their current namespace:
+#
+#     require 'mktemp'
+#     include MkTemp
+#     # do something with mktemp()
+#
+#
+# It is recommended that you look at the documentation for the mktemp()
+# call directly for specific usage.
+#
+#--
+#
+# The compilation of software known as mktemp.rb is distributed under the
+# following terms:
+# Copyright (C) 2005-2006 Erik Hollensbe. All rights reserved.
+#
+# Redistribution and use in source form, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+# THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+#
+#++
+
+module Webby
+module MkTemp
+  VALID_TMPNAM_CHARS = (?a..?z).to_a + (?A..?Z).to_a
+
+  #
+  # This routine just generates a temporary file similar to the
+  # routines from 'mktemp'. A trailing series of 'X' characters will
+  # be transformed into a randomly-generated set of alphanumeric
+  # characters.
+  # 
+  # This routine performs no file testing, at all. It is not suitable
+  # for anything beyond that.
+  #
+  
+  def tmpnam(filename)
+    m = filename.match(/(X*)$/)
+    
+    retnam = filename.dup
+    
+    if m[1]
+      mask = ""
+      m[1].length.times { mask += VALID_TMPNAM_CHARS[rand(52)].chr }
+      retnam.sub!(/(X*)$/, mask) 
+    end
+
+    return retnam
+  end
+  
+  module_function :tmpnam
+
+  #
+  # This routine works similarly to mkstemp(3) in that it gets a new
+  # file, and returns a file handle for that file. The mask parameter
+  # determines whether or not to process the filename as a mask by
+  # calling the tmpnam() routine in this module. This routine will
+  # continue until it finds a valid filename, which may not do what
+  # you expect.
+  #
+  # While all attempts have been made to keep this as secure as
+  # possible, due to a few problems with Ruby's file handling code, we
+  # are required to allow a few concessions. If a 0-length file is
+  # created before we attempt to create ours, we have no choice but to
+  # accept it. Do not rely on this code for any expected level of
+  # security, even though we have taken all the measures we can to
+  # handle that situation.
+  #
+
+  def mktemp(filename, mask=true)
+    fh = nil
+
+    begin 
+      loop do
+        fn = mask ? tmpnam(filename) : filename
+
+        if File.exist? fn
+          fail "Unable to create a temporary filename" unless mask
+          next
+        end
+
+        fh = File.new(fn, "a", 0600)
+        fh.seek(0, IO::SEEK_END)
+        break if fh.pos == 0 
+  
+        fail "Unable to create a temporary filename" unless mask
+        fh.close
+      end
+    rescue Exception => e
+      # in the case that we hit a locked file...
+      fh.close if fh
+      raise e unless mask
+    end
+    
+    return fh
+  end
+
+  module_function :mktemp
+
+  # 
+  # Create a directory. If mask is true (default), it will use the
+  # random name generation rules from the tmpnam() call in this
+  # module.
+  #
+ 
+  def mktempdir(filename, mask=true)
+    fn = mask ? tmpnam(filename) : filename
+    Dir.mkdir(fn)
+    return fn
+  end
+
+  module_function :mktempdir
+end  # module MkTemp
+end  # module Webby
+
+# :startdoc:
+# EOF

data/lib/webby/stelan/paginator.rb

@@ -0,0 +1,150 @@
+# 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, :url
+    
+    def initialize(pager, number, select) #:nodoc:
+      @pager, @number = pager, number
+      @offset = (number - 1) * pager.per_page
+      @select = select
+
+      @pager.resource.number = (number == 1 ? nil : number)
+      @url = @pager.resource.url
+    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