webby 0.1.0

data/lib/webby/file.rb

@@ -0,0 +1,191 @@
+# $Id: file.rb 2 2007-08-20 17:55:30Z tim_pease $
+
+require 'yaml'
+
+module Webby
+
+# The Webby::File class is identical to the core Ruby file class except for
+# YAML meta-data stored at the top of the file. This meta-data is made
+# available through the <code>meta_data</code> and <code>meta_data=</code>
+# functions.
+#
+# The meta-data data must be found between two YAML block separators "---",
+# each on their own line.
+#
+# Example:
+#
+#     ---
+#     layout: blog
+#     filter: markdown
+#     tags:
+#       - ruby
+#       - web development
+#     ---
+#     This is a blog entry formatted using MarkDown and tagged as "ruby" and
+#     "web development". The layout being used is the "blog" format.
+#
+class File < ::File
+
+  META_SEP = %r/\A---\s*\r?\n\z/o   # :nodoc:
+
+  class << self
+    # call-seq:
+    #    Webby::File.read( name [, length [, offset]])    => string
+    #
+    # Opens the file, optionally seeks to the given _offset_, then returns
+    # _length_ bytes (defaulting to the rest of the file). +read+ ensures
+    # the file is closed before returning.
+    #
+    def read( name, *args )
+      fd = new name, 'r'
+      fd.read *args
+    ensure
+      fd.close
+    end
+
+    # call-seq:
+    #    Webby::File.readlines( name, sep_string = $/ )    => array
+    #
+    # Reads the entire file specified by _name_ as individual lines, and
+    # returns those lines in an array. Lines are separated by _sep_string_.
+    # +readlines+ ensures the file is closed before returning.
+    #
+    def readlines( name, sep = $/ )
+      fd = new name, 'r'
+      fd.readlines sep
+    ensure
+      fd.close
+    end
+
+    # call-seq:
+    #    Webby::File.meta_data( name )    => object or nil
+    #
+    # Reads the meta-data from the file specified by _name_. +meta_data+
+    # ensures the files is closed before returning.
+    #
+    def meta_data( name )
+      fd = new name, 'r'
+      fd.meta_data
+    ensure
+      fd.close
+    end
+  end
+
+  # call-seq:
+  #    Webby::File.new( filename, mode = "r" )          => file
+  #    Webby::File.new( filename [, mode [, perm]] )    => file
+  #
+  # Opens the file named by _filename_ according to _mode_ (default is 'r')
+  # and returns a new +Webby::File+ object. See the description of class
+  # +IO+ for a description of _mode_. The file _mode_ may optionally be
+  # specified as a +Fixnum+ by or-ing together the flags (+O_RDONLY+ etc,
+  # again described under +IO+). Optional permission bits may be given in
+  # _perm_. These _mode_ and permission bits are platform dependent; on Unix
+  # systems, see +open(2)+ for details. 
+  #
+  #    f = File.new("testfile", "r")
+  #    f = File.new("newfile",  "w+")
+  #    f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)
+  #
+  def initialize( *args )
+    super
+    @meta_end = end_of_meta_data
+  end
+
+  # call-seq:
+  #    meta_data
+  #
+  # Returns the meta-data defined at the top of the file. Returns +nil+ if
+  # no meta-data is defined. The meta-data is returned as Ruby objects
+  #
+  # Meta-data is stored in YAML format between two YAML separators "---" on
+  # their own lines.
+  #
+  def meta_data
+    return if @meta_end.nil?
+
+    cur, meta_end, @meta_end = tell, @meta_end, nil
+    seek 0
+    return YAML.load(self)
+
+  ensure
+    @meta_end = meta_end if defined? meta_end and meta_end
+    seek cur if defined? cur and cur
+  end
+
+  # call-seq
+  #    meta_data = object
+  #
+  # Stores the given _object_ as meta-data in YAML format at the top of the
+  # file. If the _objectc_ is +nil+, then the meta-data section will be
+  # removed from the file.
+  #
+  # Meta-data is stored in YAML format between two YAML separators "---" on
+  # their own lines.
+  #
+  def meta_data=( data )
+    return if data.nil? and @meta_end.nil?
+
+    seek 0
+    lines = readlines
+
+    truncate 0
+    unless data.nil?
+      write YAML.dump(data)
+      write "--- #$/"
+    end
+    lines.each {|line| write line}
+  ensure
+    @meta_end = end_of_meta_data
+    seek 0, IO::SEEK_END
+  end
+
+  %w(getc gets read read_nonblock readbytes readchar readline readlines readpartial scanf sysread).each do |m|
+    self.class_eval <<-CODE
+      def #{m}(*a)
+        skip_meta_data
+        super
+      end
+    CODE
+  end
+
+
+  private
+
+  # Moves the file pointer to the end of the meta-data section. Does nothing
+  # if there is no meta-data section or if the file pointer is already past
+  # the meta-data section.
+  #
+  def skip_meta_data
+    return if @meta_end.nil? 
+    return if tell >= @meta_end
+    seek @meta_end
+  end
+
+  # Returns the position in this file where the meta-data ends and the file
+  # data begins. If there is no meta-data in the file, returns +nil+.
+  #
+  def end_of_meta_data
+    cur = tell
+
+    seek 0
+    line = readline
+    return unless META_SEP =~ line
+
+    loop do
+      line = readline
+      break if META_SEP =~ line
+    end
+    return tell
+
+  rescue EOFError
+    return
+
+  ensure
+    seek cur
+  end
+
+end  # class File
+end  # module Webby
+
+# EOF

data/lib/webby/main.rb

@@ -0,0 +1,129 @@
+# $Id: main.rb 2 2007-08-20 17:55:30Z tim_pease $
+
+require 'fileutils'
+require 'find'
+
+module Webby
+
+# The Webby::Main class contains all the functionality needed by the +webby+
+# command line application.
+#
+class Main
+
+  # Directory where the Webby website will be created
+  attr_accessor :site
+
+  # Directory where the prototype Webby website can be found
+  attr_accessor :data
+
+  # call-seq:
+  #    Main.run( *args )    => nil
+  #
+  # Create a new instance of Main, and run the +webby+ application given the
+  # command line _args_.
+  #
+  def self.run( *args )
+    self.new.run *args
+  end
+
+  # call-seq:
+  #    run( *args )    => nil
+  #
+  # Run the +webby+ application given the command line _args_.
+  #
+  def run( *args )
+    abort "Usage: #{$0} /path/to/your/site" unless args.length == 1
+
+    self.site = args.at 0
+    self.data = File.join(::Webby::PATH, 'data')
+
+    # see if the site already exists
+    abort "#{site} already exists" if test ?e, site
+
+    # copy over files from the data directory
+    files = site_files
+
+    files.keys.sort.each do |dir|
+      mkdir dir
+      files[dir].each {|file| cp file}
+    end
+    nil
+  end
+
+  # call-seq:
+  #    mkdir( dir )    => nil
+  #
+  # Make a directory in the user specified site location. A message will be
+  # displayed to the screen indicating tha the directory is being created.
+  #
+  def mkdir( dir )
+    dir = dir.empty? ? site : ::File.join(site, dir)
+    creating dir
+    FileUtils.mkdir_p dir
+  end
+
+  # call-seq:
+  #    cp( file )    => nil
+  #
+  # Copy a file from the Webby prototype website location to the user
+  # specified site location. A message will be displayed to the screen
+  # indicating tha the file is being created.
+  #
+  def cp( file )
+    src = ::File.join(data, file)
+    dst = ::File.join(site, file)
+    creating dst
+    FileUtils.cp src, dst
+  end
+
+  # call-seq:
+  #    creating( msg )   => nil
+  #
+  # Prints a "creating _msg_" to the screen.
+  #
+  def creating( msg )
+    print "creating "
+    puts msg
+  end
+
+  # call-seq:
+  #    abort( msg )   => nil
+  #
+  # Prints an abort _msg_ to the screen and then exits the Ruby interpreter.
+  #
+  def abort( msg )
+    puts msg
+    puts "Aborting!"
+    exit 1
+  end
+
+  # call-seq:
+  #    site_files   => hash
+  #
+  # Iterates over all the files in the Webby prototype website directory and
+  # stores them in a hash.
+  #
+  def site_files
+    exclude = %r/tmp$|bak$|~$|CVS|\.svn/o
+
+    rgxp = %r/\A#{data}\/?/o
+    paths = Hash.new {|h,k| h[k] = []}
+
+    Find.find(data) do |p|
+      next if exclude =~ p
+
+      if test(?d, p)
+        paths[p.sub(rgxp, '')]
+        next
+      end
+      dir = ::File.dirname(p).sub(rgxp, '')
+      paths[dir] << p.sub(rgxp, '')
+    end
+
+    paths
+  end
+
+end  # class Main
+end  # module Webby
+
+# EOF

data/lib/webby/pages_db.rb

@@ -0,0 +1,70 @@
+# $Id: pages_db.rb 6 2007-08-22 22:25:53Z tim_pease $
+
+module Webby
+
+#
+#
+class PagesDB
+  include Enumerable
+
+  def initialize
+    @db = Hash.new {|h,k| h[k] = []}
+  end
+
+  def add( page )
+    @db[page.dir] << page
+    self
+  end
+  alias :<< :add
+
+  def clear
+    @db.clear
+  end
+
+  def each( &b )
+    keys = @db.keys.sort
+    keys.each do |k|
+      @db[k].sort.each(&b)
+    end
+  end
+
+  def find_by_name( name )
+    self.find {|page| page.filename == name}
+  end
+
+  # call-seq:
+  #    siblings( page, opts = {} )    => array
+  #
+  # Options include:
+  #    :sorty_by => 'attribute'
+  #
+  def siblings( page, opts = {} )
+    ary = @db[page.dir].dup
+    ary.delete page
+    return ary unless opts.has_key? :sort_by
+
+    m = opts[:sort_by]
+    ary.sort! {|a,b| a.send(m) <=> b.send(m)}
+    ary.reverse! if opts[:reverse]
+    ary
+  end
+
+  def children( page, opts = {} )
+    rgxp = Regexp.new "\\A#{page.dir}/[^/]+"
+
+    keys = @db.keys.find_all {|k| rgxp =~ k}
+    ary  = keys.map {|k| @db[k]}
+    ary.flatten!
+
+    return ary unless opts.has_key? :sort_by
+
+    m = opts[:sort_by]
+    ary.sort! {|a,b| a.send(m) <=> b.send(m)}
+    ary.reverse! if opts[:reverse]
+    ary
+  end
+
+end  # class PagesDB
+end  # module Webby
+
+# EOF

data/lib/webby/renderer.rb

@@ -0,0 +1,94 @@
+# $Id: renderer.rb 2 2007-08-20 17:55:30Z tim_pease $
+
+require 'erb'
+
+try_require 'bluecloth'
+try_require 'redcloth'
+
+module Webby
+
+#
+#
+class Renderer
+  include ERB::Util
+
+  # call-seq:
+  #    Renderer.new( page )
+  #
+  def initialize( page )
+    unless page.is_page?
+      raise ArgumentError,
+            "only page resources can be rendered '#{page.path}'"
+    end
+
+    @page = page
+    @pages = Resource.pages
+    @content = nil
+  end
+
+  # call-seq:
+  #    layout_page
+  #
+  def layout_page
+    layouts = Resource.layouts
+    obj = @page
+    str = @page.render
+
+    loop do
+      lyt = layouts.find_by_name obj.layout
+      break if lyt.nil?
+
+      @content, str = str, ::Webby::File.read(lyt.path)
+
+      lyt.filter.to_a.each do |filter|
+        str = self.send(filter + '_filter', str)
+      end
+
+      @content, obj = nil, lyt
+    end
+
+    str
+  end
+
+  # call-seq:
+  #    render_page
+  #
+  def render_page
+    str = ::Webby::File.read(@page.path)
+
+    @page.filter.to_a.each do |filter|
+      str = self.send(filter + '_filter', str)
+    end
+
+    str
+  end
+
+  # Render text via ERB using the built in ERB library.
+  #
+  def erb_filter( str )
+    b = binding
+    ERB.new(str, nil, '-').result(b)
+  end
+
+  # Render text via markdown using the BlueCloth library.
+  #
+  def markdown_filter( str )
+    BlueCloth.new(str).to_html
+  rescue NameError
+    $stderr.puts 'ERROR: markdown filter failed (BlueCloth not installed?)'
+    exit
+  end
+
+  # Render text via textile using the RedCloth library.
+  #
+  def textile_filter( str )
+    RedCloth.new(str).to_html
+  rescue NameError
+    $stderr.puts 'ERROR: textile filter failed (RedCloth not installed?)'
+    exit
+  end
+
+end  # class Renderer
+end  # module Webby
+
+# EOF