darthapo-stratus 0.2

data/lib/stratus/generator/renderer.rb

@@ -0,0 +1,100 @@
+module Stratus::Generator
+
+# ==========
+# = Liquid =
+# ==========
+class LiquidRenderer
+  
+  attr_reader :context
+  
+  def initialize
+    @context = LiquidContext.new
+  end
+  
+  def render_content(content, path_to_root='../../')
+    in_context do
+      LiquidContext.path_to_root = path_to_root
+      context['this'] = content
+      template = template_for(content.collection_type, nil)
+      context['content'] = parser_for(template).render(context, [Stratus::Filters])
+      layout = layout_for(template)
+      parser_for(layout).render(context, [Stratus::Filters])
+    end
+  end
+  
+  # Currently unused... 
+  def render_content_fragment(content, state=nil)
+    in_context do
+      #LiquidContext.path_to_root = '../../' ???
+      context['this'] = content
+      template = template_for(content.collection_type, state)
+      parser_for(template).render(context, [Stratus::Filters])
+    end
+  end
+  
+  def render_index_for(collection_type, state='index')
+    in_context do
+      LiquidContext.path_to_root = state.nil? ? '' : '../'
+      template = template_for(collection_type, state)
+      context['content'] = parser_for(template).render(context, [Stratus::Filters])
+      layout = layout_for(template)
+      parser_for(layout).render(context, [Stratus::Filters])
+    end
+  end
+  
+protected
+  
+  # Allows all context changes to be scoped
+  def in_context(&block)
+    old_context = @context.clone
+    results = yield
+    @context = old_context
+    results
+  end
+  
+  # loops through all the metadata fields and processes them through Liquid...
+  # def render_attributes(content)
+  #   rendered_atts = {}
+  #   context['this'] = content
+  #   content.to_liquid.each do |key, value|
+  #     if value.is_a? String
+  #       puts "Rendering #{key} (#{value})"
+  #       rendered_atts[key] = Liquid::Template.parse(value).render(context, [Stratus::Filters])
+  #     end
+  #   end
+  #   rendered_atts
+  # end
+  
+  
+  def parser_for(template)
+    @parsers ||= Hash.new {|h,k| 
+      h[k] = ::Liquid::Template.parse(k.body)
+    }
+    @parsers[template]
+  end
+  
+  def template_for(collection_type, state=nil)
+    @templates ||= Hash.new {|h,k|
+      slugname = k.last.nil? ? "#{ k.first.singularize }.html" : "#{ k.first.singularize }.#{ k.last }.html"
+#      puts "Looking for #{ slugname }"
+      template = ::Stratus::Resources.templates(:first, :slug => slugname )
+      if template.nil?
+        slugname = k.last.nil? ? "_default.html" : "_default.#{ k.last }.html"
+#        puts "Not found, resorting to #{ slugname }"
+        template = ::Stratus::Resources.templates(:first, :slug => slugname )
+      end
+      h[k] = template
+    }
+    @templates[ [collection_type, state] ]
+  end
+
+  def layout_for(template)
+    @layouts ||= Hash.new {|h,k| 
+      h[k] = ::Stratus::Resources.layouts(:first, :slug => "#{ k }.html")
+    }
+    @layouts[ template.metadata.fetch('layout', 'main') ]
+  end
+  
+end
+
+end

data/lib/stratus/generator/scanner.rb

@@ -0,0 +1,75 @@
+require 'fileutils'
+
+module Stratus::Generator
+
+class Scanner
+  attr_reader :base, :content_path
+
+  def initialize(base_path)
+    @base = File.expand_path(base_path)
+    raise StandardError.new("Base path must be a directory.") unless File.directory?(base)
+    
+  end
+  
+  def sweep(clear_db=true)
+    @content_path = File.join(base, 'content')
+    resources.clear if clear_db
+    sweep_content
+    sweep_templates
+    sweep_layouts
+  end
+
+private
+  
+  def sweep_content
+    Dir[File.join(content_path, '*', '*')].each do |fullpath|
+      object_path = fullpath.gsub( "#{ content_path }/", '')
+      collection = object_path.split('/').first
+      object = Stratus::Resources::Content.new(fullpath, object_path)
+      resources.register_content( object )
+      sweep_attachments fullpath, object
+    end
+    # Set indices for all content...
+    Stratus::Resources.collection_types.each do |col_type|
+      count = 1
+      resources.all.find(:collection_type=>col_type, :sort_by=>:publish_date).each do |r|
+        r.index = count if r.index.nil?
+        count += 1
+      end
+    end
+  end
+  
+  def sweep_attachments(from_path, content_object)
+    Dir[File.join(from_path, '*')].each do |filename|
+      next if File.basename(filename) == 'index.html'
+      resources.all << Stratus::Resources::Attachment.new(filename, content_object)
+    end
+  end
+
+  def sweep_templates
+    templates_path = File.join(base, 'themes', Stratus.setting('theme', 'default'), 'templates', 'objects')
+    Dir[File.join(templates_path, '*')].each do |fullpath|
+      object_path = fullpath.gsub( "#{ templates_path }/", '')
+      template = Stratus::Resources::Template.new(fullpath, "templates/#{object_path}")
+      resources.all << template
+    end
+  end
+
+  def sweep_layouts
+    layouts_path = File.join(base, 'themes', Stratus.setting('theme', 'default'), 'templates', 'layouts')
+    Dir[File.join(layouts_path, '*')].each do |fullpath|
+      object_path = fullpath.gsub( "#{ layouts_path }/", '')
+      layout = Stratus::Resources::Layout.new(fullpath, "layouts/#{object_path}")
+      resources.all << layout
+    end
+  end
+  
+  def resources
+    Stratus::Resources
+  end
+
+end
+
+
+
+end

data/lib/stratus/generator.rb

@@ -0,0 +1,12 @@
+module Stratus::Generator
+  
+  def self.config
+    ::Stratus.settings[:generator]
+  end
+  
+end
+
+require 'stratus/generator/builder'
+require 'stratus/generator/context'
+require 'stratus/generator/renderer'
+require 'stratus/generator/scanner'

data/lib/stratus/resources/attachment.rb

@@ -0,0 +1,41 @@
+module Stratus::Resources
+
+class Attachment < Base
+  
+  attr_reader :parent
+
+  def initialize(fullpath, content_object)
+    super(fullpath, content_object.content_path, :file)
+    @parent = content_object
+    @content_type = :attachment
+    @content_path = parent.content_path
+    @collection_type = parent.collection_type
+  end
+  
+  def validate!
+    #raise StandardError.new("Posts must have a published-on date! #{content_path}") unless metadata.has_key?(:publish_on)
+    true
+  end
+  
+  def full_path
+    "#{@parent.collection_type}/#{@parent.slug}/#{@slug}"
+  end
+  
+  def output_path
+    File.join(Stratus.output_dir, full_path)
+  end
+  
+  def is_homepage?
+    false
+  end
+  
+
+protected
+
+  def parse_file(filename)
+    load_filedata(filename)
+  end
+
+end
+
+end

data/lib/stratus/resources/base.rb

@@ -0,0 +1,257 @@
+module Stratus::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 Base
+  attr_reader :index, :slug, :content_path, :collection_type, :content_type, :source_path
+
+  def initialize(fullpath, content_path='', parse=:index)
+    @source_path = fullpath
+    @slug = File.basename(fullpath)
+    @content_type = :content
+    @content_path = content_path
+    @collection_type = content_path.split('/').first
+    @parse_mode = parse
+    @is_template = false
+    @index = if @slug =~ /^([\d]{3})_(.*)$/
+      @slug = $2
+#      @content_path = "#{collection_type}/#{slug}"
+      $1.to_i
+    else
+      nil
+    end
+    
+    case parse
+    when :index
+      parse_file(File.join(source_path, 'index.html'))
+    when :file
+      parse_file(source_path)
+    when :template
+      @is_template = true
+      parse_file(source_path)
+    else
+      puts "Not parsing #{fullpath}"
+    end
+  end
+
+  def metadata
+    @meta ||= {} # Hash.new {|h,k| h[k] = []}
+  end
+
+  def full_path
+    is_homepage ? "" : "#{ collection_type }/#{ @slug }"
+  end
+  
+  def output_path
+    File.join(Stratus.output_dir, @collection_type, @slug, 'index.html')
+  end
+  
+  def attachments
+    Stratus::Resources.attachments( :content_path=>content_path )
+  end
+  
+  def attachments_hash
+    returning( {} ) do |hash|
+      attachments.each do |att|
+        slug = att.slug.gsub(att.metadata[:ext], '')
+        hash[slug] = att
+      end
+    end
+  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? Stratus::Resources::Base
+    self.content_path <=> other.content_path
+  end
+
+  def [](key)
+    if self.respond_to? key.to_sym
+      self.send(key.to_sym)
+    else
+      metadata[key]
+    end
+  end
+  def []=(key, value)
+    if self.respond_to? key.to_sym
+      self.send(key.to_sym)
+    else
+      metadata[key] = value
+    end
+  end
+  
+  def is_homepage
+    Stratus.setting('homepage') == content_path
+  end
+  
+  def next_content
+    Stratus::Resources.content(:first, :collection_type=>@collection_type, :index=>(@index + 1)) unless index.nil?
+  end
+
+  def prev_content
+    Stratus::Resources.content(:first, :collection_type=>@collection_type, :index=>(@index - 1)) unless index.nil?
+  end
+  
+  def to_liquid
+    data = rendered_attributes({
+      'slug'             => @slug,
+      'content_path'     => @content_path,
+      'collection_type'  => @collection_type,
+      'content_type'     => @content_type,
+      'full_path'        => full_path,
+      'source_path'      => source_path,
+      'attachments'      => attachments,
+      'attachment'       => attachments_hash,
+      'next'             => next_content,
+      'prev'             => prev_content,
+      'is_homepage'      => is_homepage
+    })
+  end
+  
+  # Subclasses need to override this to ensure all the proper metadata exists
+  def validate!
+    true
+  end
+  
+  def fixup_meta
+    if metadata.has_key? :tags
+      tags = [metadata[:tags]].flatten.join(',')
+      tags = tags.split(',')
+      tags.map {|t| t.strip! }
+      metadata[:tags] = tags
+    end
+    if metadata.has_key? :category
+      cats = [metadata[:category]].flatten.join(',')
+      cats = cats.split(',')
+      cats.map {|t| t.strip! }
+      metadata[:categories] = cats
+    end
+    if metadata.has_key? :publish_date
+      metadata[:publish_date] = Chronic.parse( metadata[:publish_date] )
+    else
+      metadata[:publish_date] = Time.now
+    end
+  end
+  
+protected
+
+  def rendered_attributes(rendered_atts={})
+    context = Stratus::Generator::LiquidContext.new
+    context['this'] = rendered_atts
+    metadata.each do |key, value|
+      if value.is_a? String
+        rendered_atts[key.to_s] = Liquid::Template.parse(value).render(context, [Stratus::Filters])
+      else
+        rendered_atts[key.to_s] = value
+      end
+    end
+    rendered_atts
+  end
+
+  def parse_file(filename)
+    load_filedata(filename)
+    if File.size(filename) == 0
+      puts "!! File cannot be empty: #{@slug}"
+      # throw an error?
+      return
+    end
+    doc = Hpricot( open(filename) )
+    
+    # Only grab root level meta tags for layouts and templates...
+    meta_q = (@is_template)? "/meta" : "//meta"
+    
+    doc.search(meta_q).each do |meta_tag|
+      name = meta_tag[:name].gsub(' ', '_').gsub('-', '_').downcase.to_sym
+      # Coerce the meta data value if it's defined...
+      content = if meta_tag[:type]
+        case meta_tag[:type].downcase.to_sym
+        when :int
+          meta_tag[:content].to_i
+        when :integer
+          meta_tag[:content].to_i
+        when :float
+          meta_tag[:content].to_f
+        when :double
+          meta_tag[:content].to_f
+        when :array
+          meta_tag[:content].split(',')
+        when :list
+          meta_tag[:content].split(',')
+        when :date
+          Chronic.parse( meta_tag[:content] )
+        else
+          meta_tag[:content]
+        end
+      else
+        meta_tag[:content]
+      end
+      # Create an array of values for a meta key if it's the second time it's used
+      if metadata.has_key? name
+        metadata[name] = [metadata[name]] unless metadata[name].is_a? Array
+        metadata[name] << content
+      else
+        metadata[name] = content
+      end
+    end
+    # Now, remove the meta tags...
+    doc.search(meta_q).remove
+
+    if @parse_mode == :index # Content objects
+      doc.search("//title").each do |title_tag|
+        metadata[:title] = title_tag.inner_html
+      end
+      doc.search("//title").remove
+    
+      # Whatever's left in the header, we'll pull out here...
+      metadata[:head] =  doc.at("head").inner_html.squish
+    
+      doc.search("//head").remove
+
+      # Grab the rest of the root level nodes and add their inner_html
+      # as metadata as well...
+      doc.search("/*").each do |tag|
+        metadata[tag.name.to_sym] = tag.inner_html unless tag.blank? or tag.is_a?( Hpricot::Text )
+      end
+
+    else # The rest
+      metadata[:body] = doc.to_html
+    end
+  end
+  
+  def load_filedata(filename)
+    metadata[:filename] = File.basename(filename)
+    metadata[:ext]      = File.extname(filename)
+    metadata[:mtime]    = File.mtime(filename)
+    metadata[:ctime]    = File.ctime(filename)
+    metadata[:size]     = File.size(filename)
+  end
+  
+  
+end
+
+end

data/lib/stratus/resources/content.rb

@@ -0,0 +1,17 @@
+module Stratus::Resources
+require 'pp'
+class Content < Base
+  
+  def validate!
+    raise StandardError.new("Posts must have a publish-date! #{content_path}") if (!metadata.has_key?(:publish_date) and collection_type == 'posts')
+    true
+  end
+
+  def full_path
+    parent_path = super
+    super.empty? ? "index.html" : "#{parent_path}/index.html"
+  end
+  
+end
+
+end

data/lib/stratus/resources/hash_db.rb

@@ -0,0 +1,128 @@
+module Stratus::Resources
+
+# 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
+    
+    # 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/stratus/resources/layout.rb

@@ -0,0 +1,18 @@
+module Stratus::Resources
+
+class Layout < Template
+  
+  def initialize(fullpath, content_path='')
+    super(fullpath, content_path)
+    @content_type = :layout
+  end
+
+  def validate!
+    metadata[:layout] = nil unless metadata.has_key? :layout
+    #raise StandardError.new("Posts must have a published-on date! #{content_path}") unless metadata.has_key?(:publish_on)
+    true
+  end
+  
+end
+
+end

data/lib/stratus/resources/template.rb

@@ -0,0 +1,22 @@
+module Stratus::Resources
+
+class Template < Base
+  
+  def initialize(fullpath, content_path='')
+    super(fullpath, content_path, :template)
+    @content_type = :template
+  end
+  
+  def validate!
+    metadata[:layout] = 'main' unless metadata.has_key? :layout
+    #raise StandardError.new("Posts must have a published-on date! #{content_path}") unless metadata.has_key?(:publish_on)
+    true
+  end
+  
+  def full_path
+    content_path
+  end
+  
+end
+
+end