francois-webby 0.9.4.1

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,165 @@
+# 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, :filename, :directory
+  
+  # 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
+    @meta_data = @resource._meta_data.dup
+    @filename = @resource.filename
+    @directory = @resource.directory
+    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
+
+  # Finalizer method that should be called when the paginator is finished
+  def reset
+    resource._reset(@meta_data)
+  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.reset
+      if number > 1
+        if ::Webby.site.create_mode == 'directory'
+          @pager.resource['directory'] = File.join(@pager.directory, number.to_s)
+        else
+          @pager.resource['filename'] = @pager.filename + number.to_s
+        end
+      end
+      @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

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,25 @@
+
+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})
+      unless ::Webby.editor.nil?
+        args = [::Webby.editor.split, page].flatten
+        exec(*args)
+      end
+    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,16 @@
+
+unless WINDOWS
+
+task :growl do
+  growl = Logging::Appenders::Growl.new('growl',
+    :layout => Logging::Layouts::Pattern.new(:pattern => "%5l - Webby\000%m"),
+    :coalesce => true,
+    :separator => "\000"
+  )
+  Logging::Logger['Webby'].add_appenders(growl)
+  Logging::Logger['Webby::Journal'].add_appenders(growl)
+end
+
+end  # unless WINDOWS
+
+# EOF

data/lib/webby/tasks/validate.rake

@@ -0,0 +1,19 @@
+
+namespace :validate do
+
+  desc 'Validate hyperlinks (exclude external 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,232 @@
+# 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'
+
+module Webby
+
+  # :stopdoc:
+  VERSION = '0.9.4.1'   # :nodoc:
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  YAML_SEP = '---'
+  # :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 embedded webserver
+      :use_web_server => true,
+      :web_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
+
+  # Scan the <code>layouts/</code> folder and the <code>content/</code>
+  # folder and create a new Resource object for each file found there.
+  #
+  def self.load_files
+    ::Find.find(site.layout_dir, site.content_dir) do |path|
+      next unless test ?f, path
+      next if path =~ ::Webby.exclude
+      Resources.new path
+    end
+  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