francois-webby 0.9.4.1

data/lib/webby/resources/page.rb

@@ -0,0 +1,81 @@
+require Webby.libpath(*%w[webby resources resource])
+
+module Webby::Resources
+
+# A Page is a file in the content folder that contains YAML meta-data at
+# the top of the file. Pages are processed by the Webby rendering engine
+# and then inserted into the desired layout. The string resulting from
+# processing and layout is then written to the output directory.
+#
+class Page < Resource
+
+  # call-seq:
+  #    Resource.new( path )
+  #
+  # Creates a new page object from the full path to the page file.
+  #
+  def initialize( fn, meta_data = nil )
+    super(fn)
+
+    if meta_data.instance_of?(Hash)
+      @_meta_data = meta_data
+    else
+      @_meta_data = MetaFile.meta_data(@path)
+      @_meta_data ||= {}
+    end
+    @_meta_data = ::Webby.site.page_defaults.merge(@_meta_data)
+    @_meta_data.sanitize!
+  end
+
+  # call-seq:
+  #    render   => string
+  #
+  # 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
+  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 unless @url.nil?
+
+    @url = super
+    @url = File.dirname(@url) if filename == 'index'
+    @url
+  end
+
+  # call-seq:
+  #    extension    => string
+  #
+  # Returns the extension that will be appended to the output destination
+  # filename. The extension is determined by looking at the following:
+  #
+  # * this page's meta-data for an 'extension' property
+  # * the meta-data of this page's layout for an 'extension' property
+  # * the extension of this page file
+  #
+  def extension
+    return _meta_data['extension'] if _meta_data.has_key? 'extension'
+
+    if _meta_data.has_key? 'layout'
+      lyt = ::Webby::Resources.find_layout(_meta_data['layout'])
+      lyt_ext = lyt ? lyt.extension : nil
+      return lyt_ext if lyt_ext
+    end
+
+    ext
+  end
+
+end  # class Page
+end  # module Webby::Resources
+
+# EOF

data/lib/webby/resources/partial.rb

@@ -0,0 +1,85 @@
+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
+
+    @_meta_data = MetaFile.meta_data(@path)
+    @_meta_data ||= {}
+    @_meta_data.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 _meta_data['dirty'] if _meta_data.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
+
+  # :stopdoc:
+  def _read
+    MetaFile.read(@path)
+  end
+  # :startdoc:
+
+end  # class Partial
+end  # module Webby::Resources
+
+# EOF

data/lib/webby/resources/resource.rb

@@ -0,0 +1,201 @@
+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 name of the file excluding the directory and extension
+  attr_reader :name
+
+  # The directory of the resource excluding the content directory
+  attr_reader :dir
+
+  # Extesion of the resource file
+  attr_reader :ext
+
+  # Resource file modification time
+  attr_reader :mtime
+
+  attr_reader :_meta_data  #:nodoc:
+
+  # call-seq:
+  #    Resource.new( filename )    => resource
+  #
+  # Creates a new resource object given the _filename_.
+  #
+  def initialize( fn )
+    @path  = fn
+    @dir   = ::Webby::Resources.dirname(@path)
+    @name  = ::Webby::Resources.basename(@path)
+    @ext   = ::Webby::Resources.extname(@path)
+    @mtime = ::File.mtime @path
+
+    @_meta_data =  {}
+    self._reset
+  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
+    (self.destination == other.destination) && (self.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
+    self.destination <=> other.destination
+  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 )
+    _meta_data[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 )
+    _meta_data[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 )
+    _meta_data[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 _meta_data['dirty'] if _meta_data.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 _meta_data.has_key? 'layout'
+      lyt = ::Webby::Resources.find_layout(_meta_data['layout'])
+      unless lyt.nil?
+        return true if lyt.dirty?
+      end
+    end
+
+    # if we got here, then we are not dirty
+    false
+  end
+
+  # The resource filename excluding path and extension. This will either be
+  # the name of the file or the 'filename' attribute from the meta-data if
+  # present.
+  #
+  def filename
+    return _meta_data['filename'] if _meta_data.has_key? 'filename'
+    name
+  end
+
+  # The resource file extension. This will either be the extension of the
+  # file or the 'extension' attribute from the meta-data if present.
+  #
+  def extension
+    return _meta_data['extension'] if _meta_data.has_key? 'extension'
+    ext
+  end
+
+  # The location of this resource in the directory structure. This directory
+  # does not include the content folder or the output folder.
+  #
+  def directory
+    return _meta_data['directory'] if _meta_data.has_key? 'directory'
+    dir
+  end
+
+  # Returns the path in the output directory where the resource will be
+  # generated. This path is used to determine if the resource is dirty
+  # and in need of generating.
+  #
+  def destination
+    return @destination unless @destination.nil?
+
+    @destination = ::File.join(::Webby.site.output_dir, directory, filename)
+    ext = extension
+    unless ext.nil? or ext.empty?
+      @destination << '.' << ext
+    end
+    @destination
+  end
+
+  # Returns a string suitable for use as a URL linking to this resource.
+  #
+  def url
+    return @url unless @url.nil?
+    @url = destination.sub(::Webby.site.output_dir, '')
+  end
+
+  # :stopdoc:
+  def _read
+    MetaFile.read(@path)
+  end
+
+  def _reset( meta_data = nil )
+    _meta_data.replace(meta_data) if meta_data.instance_of?(Hash)
+    @url = nil
+    @destination = nil
+  end
+  # :startdoc:
+
+end  # class Resource
+end  # module Webby::Resources
+
+end  # unless defined?
+
+# EOF

data/lib/webby/resources/static.rb

@@ -0,0 +1,36 @@
+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
+
+  # Returns the contents of the file.
+  #
+  def render
+    Webby.deprecated "render", "it is being replaced by the Renderer#render() method"
+    self._read
+  end
+
+  # 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
+
+  # :stopdoc:
+  def _read
+    ::File.read(path)
+  end
+  # :startdoc:
+
+end  # class Layout
+end  # module Webby::Resources
+
+# EOF

data/lib/webby/resources.rb

@@ -0,0 +1,137 @@
+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 = self.basename(fn)
+      if %r/\A_/o =~ filename
+        r = ::Webby::Resources::Partial.new(fn)
+        self.partials << r
+        return r
+      end
+
+      begin
+        fd = ::File.open(fn, 'r')
+        mf = MetaFile.new fd
+
+        # see if we are dealing with a static resource
+        unless mf.meta_data?
+          r = ::Webby::Resources::Static.new(fn)
+          self.pages << r
+          return r
+        end
+
+        # this is a renderable page
+        mf.each do |meta_data|
+          r = ::Webby::Resources::Page.new(fn, meta_data)
+          self.pages << r
+          r
+        end
+      rescue MetaFile::Error => err
+        logger.error "error loading file #{fn.inspect}"
+        logger.error err
+      ensure
+        fd.close if fd
+      end
+    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 unless filename
+      filename = filename.to_s
+
+      fn  = self.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
+
+    # Returns the directory component of the _filename_ with the content
+    # directory removed from the beginning if it is present.
+    #
+    def dirname( filename )
+      rgxp = %r/\A(?:#{::Webby.site.content_dir}|#{::Webby.site.layout_dir})\//o
+      dirname = ::File.dirname(filename)
+      dirname << '/' if dirname.index(?/) == nil
+      dirname.sub(rgxp, '')
+    end
+
+    # Returns the last component of the _filename_ with any extension
+    # information removed.
+    #
+    def basename( filename )
+      ::File.basename(filename, '.*')
+    end
+
+    # Returns the extension (the portion of file name in path after the
+    # period). This method excludes the period from the extension name.
+    #
+    def extname( filename )
+      ::File.extname(filename).tr('.', '')
+    end
+
+    # :stopdoc:
+    def logger
+      @logger ||= ::Logging::Logger[self]
+    end
+    # :startdoc:
+
+  end  # class << self
+end  # module Webby::Resources
+
+Webby.require_all_libs_relative_to(__FILE__)
+
+# EOF