webby 0.8.2 → 0.8.3

data/lib/webby/helpers/url_helper.rb

@@ -1,5 +1,3 @@
-# $Id: url_helper.rb 192 2008-03-08 16:27:29Z tim_pease $
-
 module Webby::Helpers
 
 #
@@ -67,7 +65,7 @@ module UrlHelper
     url_opts = opts.delete(:url)
 
     p = @pages.find(opts)
-    raise Webby::Renderer::Error,
+    raise ::Webby::Error,
           "could not find requested page: #{opts.inspect}" if p.nil?
 
     self.url_for(p, url_opts)
@@ -221,7 +219,7 @@ module UrlHelper
       p = @pages.find(opts)
     end
 
-    raise Webby::Renderer::Error,
+    raise ::Webby::Error,
           "could not find requested page: #{opts.inspect}" if p.nil?
 
     name = p.title || p.filename if name.nil?

data/lib/webby/link_validator.rb

@@ -1,5 +1,3 @@
-# $Id: link_validator.rb 189 2008-03-02 22:22:24Z tim_pease $
-
 require 'hpricot'
 require 'open-uri'
 

data/lib/webby/main.rb

@@ -1,5 +1,3 @@
-# $Id: main.rb 133 2008-02-05 06:33:39Z tim_pease $
-
 require 'fileutils'
 require 'find'
 require 'optparse'

data/lib/webby/renderer.rb

@@ -1,5 +1,3 @@
-# $Id: renderer.rb 192 2008-03-08 16:27:29Z tim_pease $
-
 # Equivalent to a header guard in C/C++
 # Used to prevent the spec helper from being loaded more than once
 unless defined? ::Webby::Renderer
@@ -64,52 +62,92 @@ class Renderer
     @content = nil
     @config = ::Webby.site
 
+    @_bindings = []
+    @_content_for = {}
     @log = Logging::Logger[self]
   end
 
   # call-seq:
-  #    render_page    => string
+  #    render( resource = nil, opts = {} )    => string
   #
-  # Apply the desired filters to the page. The filters to apply are
-  # determined from the page's meta-data.
+  # Render the given resource (a page or a partial) and return the results
+  # as a string. If a resource is not given, then the options hash should
+  # contain the name of a partial to render (:partial => 'name').
   #
-  def render_page
-    _track_rendering(@page.path) {
-      Filters.process(self, @page, ::Webby::Resources::File.read(@page.path))
-    }
+  # When a partial name is given, the partial is found by looking in the
+  # directory of the current page being rendered. Otherwise, the full path
+  # to the partial can be given.
+  #
+  # If a :guard option is given as true, then the resulting string will be
+  # protected from processing by subsequent filters. Currently this only
+  # protects against the textile filter.
+  #
+  # When rendering partials, local variables can be passed to the partial by
+  # setting them in hash passed as the :locals option.
+  #
+  # ==== Options
+  # :partial<String>::
+  #   The partial to render
+  # :locals<Hash>::
+  #   Locals values to define when rendering a partial
+  # :guard<Boolean>::
+  #   Prevents the resulting string from being processed by subsequent
+  #   filters (only textile for now)
+  # 
+  # ==== Returns
+  # A string that is the rendered page or partial.
+  #
+  # ==== Examples
+  #    # render the partial "foo" using the given local variables
+  #    render( :partial => "foo", :locals => {:bar => "value for bar"} )
+  #
+  #    # find another page and render it into this page and protect the
+  #    # resulting contents from further filters
+  #    page = @pages.find( :title => "Chicken Coop" )
+  #    render( page, :guard => true )
+  #
+  #    # find a partial and render it using the given local variables
+  #    partial = @partials.find( :filename => "foo", :in_directory => "/path" )
+  #    render( partial, :locals => {:baz => "baztastic"} )
+  #
+  def render( *args )
+    opts = Hash === args.last ? args.pop : {}
+    resource = args.first
+    resource = _find_partial(opts[:partial]) if resource.nil?
+
+    str = case resource
+      when Resources::Page
+        ::Webby::Renderer.new(resource)._render_page
+      when Resources::Partial
+        _render_partial(resource, opts)
+      else
+        raise ::Webby::Error, "expecting a page or a partial but got '#{resource.class.name}'"
+      end
+
+    str = _guard(str) if opts[:guard]
+    str
   end
 
   # call-seq:
-  #    render_partial( partial )    => string
+  #    render_page    => string
   #
-  # Render the given _partial_ into the current page. The _partial_ can
-  # either be the name of the partial to render or a Partial object.
+  # This method is being deprecated. It is being made internal to the
+  # framework and really shouldn't be used anymore.
   #
-  # In the former case, the partial is found by first looking in the
-  # directory of the current for a partial of the same name. Failing that,
-  # the search is expanded to include all directories in the site. The first
-  # partial with a matching name is returned.
+  def render_page
+    Webby.deprecated "render_page", "this method is being made internal to the framework"
+    _render_page
+  end
+
+  # call-seq:
+  #    render_partial( partial, :locals => {} )    => string
   #
-  # In the latter case, Partial objects can be found by using the +find+
-  # method of the <tt>@partials</tt> database hash. Please refer to
-  # Webby::Resources::DB#find method for more information.
+  # This method is being deprecated. Please use the +render+ method instead.
   #
   def render_partial( part, opts = {} )
-    part = case part
-      when String
-        fn = '_' + part
-        p = Resources.partials.find(
-            :filename => fn, :in_directory => @page.dir ) rescue nil
-        p ||= Resources.partials.find(:filename => fn)
-        raise ::Webby::Error, "could not find partial '#{part}'" if p.nil?
-        p
-      when ::Webby::Resources::Partial
-        part
-      else raise ::Webby::Error, "expecting a partial or a partial name" end
-
-    _track_rendering(part.path) {
-      Filters.process(self, part, ::Webby::Resources::File.read(part.path))
-    }
+    Webby.deprecated "render_partial", "it is being replaced by the Renderer#render() method"
+    opts[:partial] = part
+    render opts
   end
 
   # call-seq:
@@ -140,11 +178,34 @@ class Renderer
   # Returns the current binding for the renderer.
   #
   def get_binding
-    binding
+    @_bindings.last
   end
 
+  # call-seq:
+  #    _render_page    => string
+  #
+  # Apply the desired filters to the page. The filters to apply are
+  # determined from the page's meta-data.
+  #
+  def _render_page
+    _track_rendering(@page.path) {
+      Filters.process(self, @page, ::Webby::Resources::File.read(@page.path))
+    }
+  end
 
-  private
+  # call-seq:
+  #    _render_partial( partial, :locals => {} )    => string
+  #
+  # Render the given _partial_ into the current page. The :locals are a hash
+  # of key / value pairs that will be set as local variables in the scope of
+  # the partial when it is rendered.
+  #
+  def _render_partial( part, opts = {} )
+    _track_rendering(part.path) {
+      _configure_locals(opts[:locals])
+      Filters.process(self, part, ::Webby::Resources::File.read(part.path))
+    }
+  end
 
   # call-seq:
   #    _layout_page    => string
@@ -155,7 +216,7 @@ class Renderer
   # page's meta-data.
   #
   def _layout_page
-    @content = @page.render(self)
+    @content = _render_page
 
     _track_rendering(@page.path) {
       _render_layout_for(@page)
@@ -182,6 +243,7 @@ class Renderer
   # a layout, then this method returns immediately.
   #
   def _render_layout_for( res )
+    return unless res.layout
     lyt = Resources.layouts.find :filename => res.layout
     return if lyt.nil?
 
@@ -228,6 +290,7 @@ class Renderer
   def _track_rendering( path )
     loop_error = @@stack.include? path
     @@stack << path
+    @_bindings << _binding
 
     if loop_error
       msg = "rendering loop detected for '#{path}'\n"
@@ -239,8 +302,71 @@ class Renderer
     yield
   ensure
     @@stack.pop if path == @@stack.last
+    @_bindings.pop
+  end
+
+  # call-seq:
+  #    _configure_locals( locals )
+  #
+  # Configure local variables in the scope of the current binding returned
+  # by the +get_binding+ method. The _locals_ should be given as a hash of
+  # name / value pairs.
+  #
+  def _configure_locals( locals )
+    return if locals.nil?
+
+    locals.each do |k,v|
+      Thread.current[:value] = v
+      definition = "#{k} = Thread.current[:value]"
+      eval(definition, get_binding)
+    end
+  end
+
+  # Attempts to locate a partial by name. If only the partial name is given,
+  # then the current directory of the page being rendered is searched for
+  # the partial. If a full path is given, then the partial is searched for
+  # in that directory.
+  #
+  # Raies a Webby::Error if the partial could not be found.
+  #
+  def _find_partial( part )
+    case part
+    when String
+      part_dir = ::File.dirname(part)
+      part_dir = @page.dir if part_dir == '.'
+
+      part_fn = ::File.basename(part)
+      part_fn = '_' + part_fn unless part_fn =~ %r/^_/
+
+      p = Resources.partials.find(
+          :filename => part_fn, :in_directory => part_dir ) rescue nil
+      raise ::Webby::Error, "could not find partial '#{part}'" if p.nil?
+      p
+    when ::Webby::Resources::Partial
+      part
+    else raise ::Webby::Error, "expecting a partial or a partial name" end
   end
 
+  # This method will put filter guards around the given input string. This
+  # will protect the string from being processed by any remaining filters
+  # (specifically the textile filter).
+  #
+  # The string is returned unchanged if there are no remaining filters to
+  # guard against.
+  #
+  def _guard( str )
+    return str unless @_cursor
+
+    if @_cursor.remaining_filters.include? 'textile'
+      str = "<notextile>\n%s\n</notextile>" % str
+    end
+    str
+  end
+
+  # Returns the binding in the scope of this Renderer object.
+  #   
+  def _binding() binding end
+
 end  # class Renderer
 end  # module Webby
 

data/lib/webby/resources.rb

@@ -1,5 +1,3 @@
-# $Id: resources.rb 167 2008-02-24 00:59:54Z tim_pease $
-
 module Webby::Resources
 
   class << self

data/lib/webby/resources/db.rb

@@ -1,5 +1,3 @@
-# $Id: db.rb 169 2008-02-24 03:59:37Z tim_pease $
-
 module Webby::Resources
 
 # A rudimentary "database" for holding resource objects and finding them.
@@ -51,19 +49,24 @@ class DB
   # Iterate over each resource in the database and pass it to the given
   # block.
   #
-  def each( &b )
+  def each( &block )
     keys = @db.keys.sort
     keys.each do |k|
-      @db[k].sort.each(&b)
+      @db[k].sort.each(&block)
     end
     self
   end
 
   # call-seq:
-  #    find( opts = {} )                       => resource or nil
-  #    find( opts = {} ) {|resource| block}    => resource or nil
+  #    find( limit = nil, opts = {} )                       => resource or nil
+  #    find( limit = nil, opts = {} ) {|resource| block}    => resource or nil
   #
   # Find a specific resource or collection of resources in the pages database.
+  # The first resource found will be returned if the _limit_ is nil. If the
+  # _limit_ is an integer, then up to that number of resources will be
+  # returned as an array. If the limit is :all, then all resources matching
+  # the given attributes will be returned.
+  #
   # Resources can be found using any combination of attributes by passing them
   # in as options to the +find+ method. This will used simple equality
   # comparison to find the resource or resources.
@@ -80,41 +83,46 @@ class DB
   # on the limit. The method will return the first resource or all
   # resources, respectively, for which the block returns true.
   # 
-  # Options:
-  #    :limit        => :all, integer or nil
-  #    :in_directory => directory
-  #    :recursive    => true or false
-  #    :sort_by      => attribute
-  #    :reverse      => true or false
-  #
-  # Examples:
-  #
+  # ==== Options
+  # :in_directory<String>::
+  #   The directory to search.
+  # :recursive<Boolean>::
+  #   Whether or not to recurse into subdirectories
+  # :sort_by<Symbol>::
+  #   Sort results using the given attribute
+  # :reverse<Boolean>::
+  #   Reverse the order of the search results
+  #
+  # ==== Examples
   #    # find the "index" resource in the "foo/bar" directory
   #    @pages.find( :filename => 'index', :in_directory => 'foo/bar' )
   #
   #    # find all resources under the "foo/bar" directory recursively
-  #    @pages.find( :limit => :all, :in_directory => 'foo/bar', :recursive => true )
+  #    @pages.find( :all, :in_directory => 'foo/bar', :recursive => true )
   #
   #    # find the resource named "widgets" whose color is "blue"
   #    @pages.find( :name => 'widgets', :color => 'blue' )
   #
   #    # find all resources created in the past week
-  #    @pages.find( :limit => :all ) do |resource|
+  #    @pages.find( :all ) do |resource|
   #      resource.created_at > Time.now - (7 * 24 * 3600)
   #    end
   #
   def find( *args, &block )
     opts = Hash === args.last ? args.pop : {}
 
-    limit = opts.delete(:limit)
+    limit = args.shift
+    limit = opts.delete(:limit) if opts.has_key?(:limit)
     sort_by = opts.delete(:sort_by)
     reverse = opts.delete(:reverse)
 
     # figure out which directories to search through and whether to recurse
     # into directories or not
     search = if (dir = opts.delete(:in_directory))
+      dir = dir.sub(%r/^\//, '')
       strategy = if opts.delete(:recursive)
-        lambda { |key| key =~ %r/^#{Regexp.escape(dir)}(?:\/|$)/ }
+        rgxp = dir.empty? ? '.*' : Regexp.escape(dir)
+        lambda { |key| key =~ %r/^#{rgxp}(\/.*)?$/ }
       else
         lambda { |key| key == dir }
       end
@@ -168,10 +176,11 @@ class DB
   # resource. A sibling is any resource that is in the same directory as the
   # _page_.
   #
-  # Options include:
-  #
-  #    :sorty_by => 'attribute'
-  #    :reverse  => true
+  # ==== Options
+  # :sorty_by<Symbol>::
+  #   The attribute to sort by
+  # :reverse<Boolean>::
+  #   Reverse the order of the results
   #
   def siblings( page, opts = {} )
     ary = @db[page.dir].dup
@@ -191,10 +200,11 @@ class DB
   # resource. A child is any resource that exists in a subdirectory of the
   # page's directory.
   #
-  # Options include:
-  #
-  #    :sorty_by => 'attribute'
-  #    :reverse  => true
+  # ==== Options
+  # :sorty_by<Symbol>::
+  #   The attribute to sort by
+  # :reverse<Boolean>::
+  #   Reverse the order of the results
   #
   def children( page, opts = {} )
     rgxp = Regexp.new "\\A#{page.dir}/[^/]+"

data/lib/webby/resources/file.rb

@@ -1,5 +1,3 @@
-# $Id: file.rb 167 2008-02-24 00:59:54Z tim_pease $
-
 require 'yaml'
 
 module Webby::Resources

data/lib/webby/resources/layout.rb

@@ -1,5 +1,3 @@
-# $Id: layout.rb 167 2008-02-24 00:59:54Z tim_pease $
-
 require Webby.libpath(*%w[webby resources resource])
 
 module Webby::Resources

data/lib/webby/resources/page.rb

@@ -1,5 +1,3 @@
-# $Id: page.rb 198 2008-03-10 15:25:55Z tim_pease $
-
 require Webby.libpath(*%w[webby resources resource])
 
 module Webby::Resources
@@ -32,16 +30,13 @@ class Page < Resource
   # call-seq:
   #    render   => string
   #
-  # Creates a new Webby::Renderer instance and uses that instance to render
-  # the page contents using the configured filter(s). The filter(s) to
-  # use is defined in the page's meta-data as the 'filter' key.
-  #
-  # Note, this only renders this page. The returned string does not include
-  # any layout rendering.
+  # This method is being deprecated. Please use the +Renderer#render+ method
+  # instead.
   #
   def render( renderer = nil )
+    Webby.deprecated "render", "it is being replaced by the Renderer#render() method"
     renderer ||= ::Webby::Renderer.new(self)
-    renderer.render_page
+    renderer._render_page
   end
 
   # call-seq