darthapo-cumulus 0.0.1

data/lib/cumulus/hash_db.rb

@@ -0,0 +1,137 @@
+module Cumulus
+
+# A rudimentary "database" for holding resource objects and finding them.
+# The database is held in a Ruby hash keyed by the collection/slug
+# Based on Webby's DB class...
+class HashDB
+  attr_reader :db
+  
+  def initialize
+    @db = Hash.new {|h,k| h[k] = []}
+  end
+  
+  def add( content )
+    ary = @db[content.content_path]
+    
+    # make sure we don't duplicate contents
+    ary.delete content if ary.include? content
+    ary << content
+    
+    content
+  end
+  alias :<< :add
+  
+  def clear
+    @db.clear
+    self
+  end
+  
+  def each( &block )
+    keys = @db.keys.sort
+    keys.each do |k|
+      @db[k].sort.each(&block)
+    end
+    self
+  end
+  
+  # FIXME: Need to add support for:
+  #   collection/*
+  #   */*
+  def find( *args, &block )
+    opts = Hash === args.last ? args.pop : {}
+    
+    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 collections to search through
+    search = self
+    # search = if (dir = opts.delete(:content_pat))
+    #   dir = dir.sub(%r/^\//, '')
+    #   strategy = lambda { |key| key == dir }
+    #   matching_keys = @db.keys.select(&strategy)
+    #   raise RuntimeError, "unknown collection '#{dir}'" if matching_keys.empty?
+    #   matching_keys.map { |key| @db[key] }.flatten
+    # else
+    #   self
+    # end
+    
+    # construct a search block if one was not supplied by the user
+    block ||= lambda do |content|
+      found = true
+      opts.each do |key, value|
+        if key == :content_path
+          found &&= content.__send__(key.to_sym).match( Regexp.new( value.gsub('*', '.*'), 'g' ) )
+        else
+          found &&= content.__send__(key.to_sym) == value
+        end
+        break if not found
+      end
+      found
+    end
+    
+    # search through the collections for the desired content objects
+    ary = []
+    search.each do |content|
+      ary << content if block.call(content)
+    end
+    
+    # sort the search results if the user gave an attribute to sort by
+    if sort_by
+      m = sort_by.to_sym
+      ary.delete_if {|p| p.__send__(m).nil?}
+      reverse ? 
+          ary.sort! {|a,b| b.__send__(m) <=> a.__send__(m)} :
+          ary.sort! {|a,b| a.__send__(m) <=> b.__send__(m)} 
+    end
+    
+    # limit the search results
+    case limit
+    when :all, 'all'
+      ary
+    when Integer
+      ary.slice(0,limit)
+    else
+      ary.first
+    end
+  end
+  
+  def siblings( content, opts = {} )
+    ary = @db[content.content_path].dup
+    ary.delete content
+    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 
+end  # module 
+
+# EOF
+
+# Webby's LICENCE:
+# MIT License
+# Copyright (c) 2007 - 2008
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sub-license, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/cumulus/resources.rb

@@ -0,0 +1,46 @@
+require 'cumulus/hash_db'
+
+module Cumulus::Resources
+  class << self
+    
+    # Every source file: Content, Attachment, (¿Template?)
+    def all
+      @all ||= Cumulus::HashDB.new
+    end
+    
+    # Only content attachments
+    def attachments(*args)
+      filter = args.extract_options!.merge! :content_type=>:attachment
+      all.find((args.first || :all), filter)
+    end
+    
+    # Only content objects
+    def collections(*args)
+      filter = args.extract_options!.merge! :content_type=>:content
+      all.find((args.first || :all), filter)
+    end
+    
+    # Only templates
+    def templates(*args)
+      filter = args.extract_options!.merge! :content_type=>:template
+      all.find((args.first || :all), filter)
+    end
+
+    # Only templates
+    def layouts(*args)
+      filter = args.extract_options!.merge! :content_type=>:layout
+      all.find((args.first || :all), filter)
+    end
+    
+    def clear
+      all.clear
+    end
+    
+  end
+end
+
+require 'cumulus/resources/base_resource'
+require 'cumulus/resources/attachment'
+require 'cumulus/resources/content'
+require 'cumulus/resources/template'
+require 'cumulus/resources/layout'

data/lib/cumulus/resources/attachment.rb

@@ -0,0 +1,35 @@
+module Cumulus::Resources
+
+# A attachment is any file that's not the index.html in a 
+# content object folder
+class Attachment < BaseResource
+
+  attr_reader :parent
+  
+  def initialize(filepath, content_object)
+    super(filepath)
+    @parent = content_object
+    @content_type = :attachment
+    @content_path = parent.content_path
+    @collection_type = parent.collection_type
+    parse_meta
+  end
+  
+  def output_path
+    File.join(Cumulus.output_dir, @content_path, @slug)
+  end
+  
+  
+protected
+  
+  def parse_meta
+    metadata[:filename] = File.basename(source_path)
+    metadata[:ext] = File.extname(source_path)
+    metadata[:mtime] = File.mtime(source_path)
+    metadata[:ctime] = File.ctime(source_path)
+    metadata[:size] = File.size(source_path)
+  end
+  
+end
+
+end

data/lib/cumulus/resources/base_resource.rb

@@ -0,0 +1,105 @@
+module Cumulus::Resources
+
+=begin
+
+content_path:
+  - pages/about
+  - posts/20081105-my-slugline
+
+content_type:
+  - content
+  - attachment
+
+collection_type:
+  - pages
+  - posts
+
+slug:
+  - about
+  - 20081105-my-slugline
+
+=end
+  
+class BaseResource
+
+  attr_reader :slug, :content_path, :collection_type, :content_type, :source_path
+
+  # def guid
+  #   @guid ||= `uuidgen` # Probably need a more portable solution than this...
+  # end
+  
+  def initialize(fullpath)
+    @source_path = fullpath
+    @slug = File.basename(fullpath)
+  end
+  
+  def metadata
+    @meta ||= {}
+  end
+  
+  def includes
+    metadata.fetch(:include, [])
+  end
+  
+  def output_path
+    #filename = File.extname(@slug).empty? ? "#{@slug}.html" : @slug
+    File.join(Cumulus.output_dir, @collection_type, @slug, 'index.html')
+  end
+  
+  def method_missing(name, *args)
+    if name.to_s.ends_with? '='
+      metadata[name.to_s[0..-2].to_sym] = args.first
+    else
+      metadata[name]
+    end
+  end
+  
+  def <=>( other )
+    return unless other.kind_of? ::Cumulus::Resources::BaseResource
+    self.content_path <=> other.content_path
+  end
+  
+  def to_liquid
+    data = metadata.merge({
+      :slug => @slug,
+      :content_path => @content_path,
+      :collection_type => @collection_type,
+      :content_type => @content_type
+    }).stringify_keys
+  end
+  
+  def [](key)
+    if self.respond_to? key.to_sym
+      self.send(key.to_sym)
+    else
+      metadata[name]
+    end
+  end
+  
+  # def dirty?
+  #   return metadata[:dirty] if metadata.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
+  
+end
+
+end

data/lib/cumulus/resources/content.rb

@@ -0,0 +1,50 @@
+require 'hpricot'
+
+module Cumulus::Resources
+
+# Content objects reside within collections, they include all meta data
+# and attachments
+class Content < BaseResource
+  
+  
+  def initialize(full_path, content_path)
+    super(full_path)
+    @content_type = :content
+    @content_path = content_path
+    @collection_type = content_path.split('/').first
+    parse_file
+  end
+  
+  def attachments
+    Cumulus::Resources.attachments( :content_path=>content_path )
+  end
+  
+protected
+
+  def parse_file(filename='index.html')
+    doc = Hpricot(open(File.join(source_path, filename)))
+    metadata[:title] = doc.at("title").inner_html
+    doc.search("//title").remove
+
+    metadata[:content] = doc.at("body").inner_html #.squeeze
+    doc.search("//body").remove
+
+    doc.search("//meta").each do |meta_tag|
+      name = meta_tag[:name].gsub(' ', '_').gsub('-', '_').downcase.to_sym
+      if name == :include
+        metadata[name] = [] unless metadata.has_key? name
+        metadata[name] << meta_tag[:content]
+      else
+        metadata[name] = meta_tag[:content]
+      end
+      
+    end
+    doc.search("//meta").remove
+
+    # Whatever's left in the header, we'll pull out here...
+    metadata[:head] =  doc.at("head").inner_html.squeeze
+  end
+  
+end
+
+end

data/lib/cumulus/resources/layout.rb

@@ -0,0 +1,29 @@
+module Cumulus::Resources
+
+=begin
+
+Layouts could have meta tags, but only at the root level? 
+
+  /meta
+
+Should it use a decorator approach?
+
+<meta name="decorates" content="page"/>
+
+???
+=end
+
+
+# A layout is any .html file that contains Liquid markup 
+# for use in wrapping content objects.
+class Layout < Template
+
+  def initialize(fullpath)
+    super(fullpath)
+    @content_path = 'skin/layouts'
+    @content_type = :layout
+  end
+
+end
+
+end

data/lib/cumulus/resources/skin.rb

@@ -0,0 +1,7 @@
+module Cumulus::Resources
+  
+  class Skin
+    
+  end
+  
+end

data/lib/cumulus/resources/template.rb

@@ -0,0 +1,35 @@
+module Cumulus::Resources
+
+# A template is any .html file that contains Liquid markup 
+# for use in wrapping/rendering content objects
+class Template < BaseResource
+  
+  def initialize(fullpath)
+    super(fullpath)
+    @content_type = :template
+    @content_path = 'skin/templates'
+    parse_template
+  end
+  
+protected
+  
+  def parse_template
+    doc = Hpricot(open(source_path))
+
+    doc.search("/meta").each do |meta_tag|
+      name = meta_tag[:name].gsub(' ', '_').gsub('-', '_').downcase.to_sym
+      if name == :include or metadata.has_key? name
+        metadata[name] = [ metadata[name] ] unless metadata[name].is_a? Array
+        metadata[name] << meta_tag[:content]
+      else
+        metadata[name] = meta_tag[:content]
+      end
+    end
+    doc.search("/meta").remove
+    
+    metadata[:content] = doc.to_s
+  end
+  
+end
+
+end