brite 0.5

data/HISTORY

@@ -0,0 +1,16 @@
+= RELEASE HISTORY
+
+== 0.5 / 2008-10-25
+
+Brite (formerly Webrite) has been completely rewritten from the ground-up,
+applying a number of ideas gathered from other systems and adding further
+innovations. This is still an early release, and in need of features
+and overt tire-kicking, but hey I'm already using to generate a pretty
+damn nice looking site.
+
+Changes:
+
+* 1 Monumentously Important Enhancment
+
+    * Happy Rebirthday!
+

data/LICENSE

@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2009 Thomas Sawyer
+
+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, sublicense, 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/MANIFEST

@@ -0,0 +1,28 @@
+#!mast bin lib meta test [A-Z]*
+bin/brite
+lib/brite/command.rb
+lib/brite/config.rb
+lib/brite/layout.rb
+lib/brite/page.rb
+lib/brite/part.rb
+lib/brite/post.rb
+lib/brite/site.rb
+lib/brite/template.rb
+meta/authors
+meta/contact
+meta/copyright
+meta/description
+meta/homepage
+meta/license
+meta/name
+meta/repository
+meta/requires
+meta/ruby
+meta/subtitle
+meta/suite
+meta/summary
+meta/title
+meta/version
+LICENSE
+README
+HISTORY

data/README

@@ -0,0 +1,42 @@
+= Brite
+
+(The BrightLite of Static Website Generators)
+
+* home: http://proutils.github.com/brite
+* source: http://github.com/proutils/brite
+
+
+== DESCRIPTION
+
+Brite is an inovative static website/blog generation utility
+which is extremely easy to use as it is versitle.
+
+== FEATURES/ISSUES
+
+* Awesome
+* Extra Cool
+* And Dyn-o-mite!
+
+
+== SYNOPSIS
+
+For now please see the Brite website and API documentation.
+
+
+== HOW TO INSTALL
+
+You know the routine ;)
+
+  $ sudop gem install brite
+
+If you're old fashion and want to install to a site
+location, see Setup.rb (http://protuils.github.com/setup).
+
+
+== COPYRIGHT/LICENSE
+
+Brite is Copyright (c) 2009 Thomas Sawyer
+
+It is distributed under the terms of the MIT license.
+
+

data/bin/brite

@@ -0,0 +1,3 @@
+#! /usr/bin/ruby
+require 'brite/command'
+Brite::Command.start

data/lib/brite/command.rb

@@ -0,0 +1,85 @@
+require 'brite/site'
+
+module Brite
+
+  # Webrite command line interface.
+
+  class Command
+
+    def self.start
+      new.start
+    end
+
+    def initialize(argv=nil)
+      @argv ||= ARGV.dup
+
+      @noharm = @argv.delete('--dryrun') || @argv.delete('--noharm')
+      @debug  = @argv.delete('--debug')
+
+      @argv.reject!{ |e| e =~ /^-/ }
+
+      @location = @argv.shift || '.'
+      #@output = @argv.shift
+    end
+
+    #
+    def start
+      begin
+        site.build
+      rescue => e
+        @debug ? raise(e) : puts(e.message)
+      end
+    end
+
+    def site
+      Site.new(
+        :location => @location,
+        :output   => @output,
+        :noharm   => @noharm,
+        :trace    => @trace
+      )
+    end
+  end
+
+  #
+  # Command to generate a single part to standard out.
+  #
+
+  class PartCommand
+
+    def self.start
+      new.start
+    end
+
+    def initialize(argv=nil)
+      @argv ||= ARGV.dup
+    end
+
+    def start
+      render(parts)
+    end
+
+    # render a single part to stdout.
+
+    def render(parts)
+      $stdout << Page.new(parts).to_html
+    end
+
+  private
+
+    def parts
+      parts = []
+      @argv.each do |x|
+        if /^-/ =~ x
+          parts << [x.sub(/-{1,2}/,'')]
+        else
+          parts.last < x
+        end
+      end
+      Hash[*parts]
+    end
+
+  end
+
+end
+

data/lib/brite/config.rb

@@ -0,0 +1,30 @@
+require 'ostruct'
+
+module Brite
+
+  # Configuration
+  class Config
+
+    #
+    DEFAULTS = {
+      :stencil    => 'rhtml',
+      #:format     => 'html',
+      :pagelayout => 'page',
+      :postlayout => 'post',
+      :maxchars   => 500,
+    }
+
+    attr :defaults
+
+    def initialize
+      if File.exist?('.config/defaults')
+        custom_defaults = YAML.load(File.new('.config/defaults'))
+      else
+        custom_defaults = {}
+      end
+      @defaults = OpenStruct.new(DEFAULTS.merge(custom_defaults))
+    end
+  end
+
+end
+

data/lib/brite/layout.rb

@@ -0,0 +1,36 @@
+module Brite
+
+  # Layout class
+  class Layout < Page
+    undef_method :save
+
+    #def to_contextual_attributes
+    #  { 'site'=>site.to_h }
+    #end
+
+    #
+    def render(attributes={})
+      #attributes = to_contextual_attributes
+      #attributes['content'] = content if content
+
+      output = parts.map{ |part| part.render(stencil, attributes) }.join("\n")
+
+      #@content = output
+
+      attributes = attributes.merge('content'=>output)
+
+      if layout
+        output = site.lookup_layout(layout).render(attributes)
+      end
+
+      output
+    end
+
+    # Layouts have no default layout.
+    def default_layout
+      nil
+    end
+
+  end
+
+end

data/lib/brite/page.rb

@@ -0,0 +1,235 @@
+require 'brite/part'
+
+module Brite
+
+  # Page class
+  class Page
+
+    attr :file
+
+    # Template type (rhtml or liquid)
+    attr :stencil
+
+    # Layout name (relative filename less extension)
+    attr :layout
+
+    # Author
+    attr :author
+
+    # Title of page/post
+    attr :title
+
+    # Publish date
+    attr :date
+
+    # Tags (labels)
+    attr :tags
+
+    # Category ("a glorified tag")
+    attr :category
+
+    # rendered output text
+    attr :content
+
+    # output extension (defualt is 'html')
+    attr :extension
+
+    #
+    def initialize(site, file)
+      @site  = site
+      @file  = file
+      @parts = []
+      parse
+    end
+
+    def name
+      @name ||= file.chomp(File.extname(file))
+    end
+
+    #
+    def url
+      @url ||= name + extension
+    end
+
+    #
+    def extension
+      @extension ||= '.html'
+    end
+
+    #
+    def root
+      '../' * file.count('/')
+    end
+
+    # TODO
+    #def next
+    #  self
+    #end
+
+    # TODO
+    #def previous
+    #  self
+    #end
+
+    #
+    def to_h
+      {
+        'url'      => url,
+        'author'   => author,
+        'title'    => title,
+        'date'     => date,
+        'tags'     => tags,
+        'category' => category,
+        'content'  => content
+      }
+    end
+
+    #
+    def save(output=nil)
+      output ||= Dir.pwd  # TODO
+      text  = render
+      fname = file.chomp(File.extname(file)) + extension
+      if dryrun
+        puts "[DRYRUN] write #{fname}"
+      else
+        puts "write #{fname}"
+        File.open(fname, 'w'){ |f| f << text }
+      end
+    end
+
+    def to_contextual_attributes
+      { 'site'=>site.to_h, 'page'=>to_h, 'root'=>root }
+    end
+
+    #
+    def to_liquid
+      to_contextual_attributes
+    end
+
+  protected
+
+    # TODO: Should validate front matter before anything processing.
+    #
+    def render(inherit={})
+      attributes = to_contextual_attributes
+
+      attributes = attributes.merge(inherit)
+
+      #attributes['content'] = content if content
+
+      output = parts.map{ |part| part.render(stencil, attributes) }.join("\n")
+
+      @content = output
+
+      attributes = attributes.merge('content'=>output)
+      if layout
+        renout = site.lookup_layout(layout)
+        raise "No such layout -- #{layout}" unless renout
+        output = renout.render(attributes)
+      end
+
+      output
+    end
+
+  private
+
+    #
+    def site
+      @site
+    end
+
+    #
+    def parts
+      @parts
+    end
+
+    #
+    def dryrun
+      site.dryrun
+    end
+
+    #
+    def parse
+      hold = []
+      text = File.read(file)
+      sect = text.split(/^\-\-\-/)
+
+      if sect.size == 1
+        @prop = {}
+        @parts << Part.new(sect[0], site.defaults.format)
+      else
+        void = sect.shift
+        head = sect.shift
+        head = YAML::load(head)
+
+        parse_header(head)
+
+        sect.each do |body|
+          index   = body.index("\n")
+          format  = body[0...index].strip
+          format  = site.defaults.format if format.empty?
+          text    = body[index+1..-1]
+          @parts << Part.new(text, format)
+        end
+      end
+
+    end
+
+    #
+    def parse_header(head)
+      @stencil   = head['stencil'] || site.defaults.stencil
+      @author    = head['author']  || 'Anonymous'
+      @title     = head['title']
+      @date      = head['date']
+      @category  = head['category']
+      @extension = head['extension']
+
+      self.tags   = head['tags']
+      self.layout = head['layout']
+    end
+
+    def layout=(layout)
+      if FalseClass === layout
+        @layout = nil
+      else
+        @layout = layout || default_layout
+      end
+    end
+
+    #
+    def tags=(entry)
+      return entry unless entry
+      case entry
+      when String, Symbol
+        entry = entry.to_s.strip
+        if entry.index(/[,;]/)
+          entry = entry.split(/[,;]/)
+        else
+          entry = entry.split(/\s+/)
+        end
+      else
+        entry = entry.to_a.flatten
+      end
+      @tags = entry.map{ |e| e.strip }
+    end
+
+    # Default layout is different for pages vs. posts, so we
+    # use this method to differntiation them.
+    def default_layout
+      site.defaults.pagelayout
+    end
+
+  public
+
+    def to_s
+      file
+    end
+
+    def inspect
+      "<#{self.class}: #{file}>"
+    end
+
+  end
+
+end
+

data/lib/brite/part.rb

@@ -0,0 +1,31 @@
+module Brite
+
+  # A Part is the section of a page. Pages can be segmented into
+  # parts using the '--- FORMAT' notation.
+  #
+  class Part
+    # Markup format (html, rdoc, markdown, textile)
+    attr :format
+
+    # Body of text as given in the part.
+    attr :text
+
+    #
+    def initialize(text, format=nil)
+      @format = format
+      @text   = text
+    end
+
+    #
+    def render(type, attributes)
+      template_engine.render(type, format, text, attributes)
+    end
+
+    #
+    def template_engine
+      TemplateEngine
+    end
+  end
+
+end
+

data/lib/brite/post.rb

@@ -0,0 +1,37 @@
+require 'brite/page'
+
+module Brite
+
+  # Post class
+  class Post < Page
+
+    def default_layout
+      site.defaults.postlayout
+    end
+
+    #def to_contextual_attributes
+    #  { 'site' => site.to_h, 'post' => to_h }
+    #end
+
+=begin
+    #
+    def render(content=nil)
+      attributes = to_contextual_attributes
+      #attributes['page']['content'] = content if content
+
+      output = parts.map{ |part| part.render(stencil, attributes) }.join("\n")
+
+      # content
+      @content = output
+
+      if layout
+        output = site.lookup_layout(layout).render(output)
+      end
+      output
+    end
+=end
+
+  end
+
+end
+

data/lib/brite/site.rb

@@ -0,0 +1,137 @@
+##
+#  "entia non sunt multiplicanda praeter necessitatem"
+#                                        --Ockham's razor
+##
+
+require 'brite/config'
+require 'brite/page'
+require 'brite/post'
+require 'brite/layout'
+require 'brite/template'
+
+#
+module Brite
+
+  # Site class
+  class Site
+
+    # Location of site.
+    attr :location
+    attr :output
+
+    attr :layouts
+    attr :pages
+    attr :posts
+
+    attr :dryrun
+    attr :verbose
+
+    def initialize(options={})
+      @location = options[:location] || Dir.pwd
+      @output   = options[:output]   || Dir.pwd
+      @dryrun   = options[:dryrun]
+
+      @layouts = []
+      @pages   = []
+      @posts   = []
+    end
+
+    def tags
+      @tags ||= posts.map{ |p| p.tags }.flatten.uniq.sort
+    end
+
+    def posts_by_tag
+      @posts_by_tag ||= (
+        chart ||= Hash.new{|h,k|h[k]=[]}
+        posts.each do |post|
+          post.tags.each do |tag|
+            chart[tag] << post
+          end
+        end
+        chart
+      )
+    end
+
+    def verbose?
+      true
+    end
+
+    def build
+      Dir.chdir(location) do
+        sort_files
+        if verbose?
+          puts "Layouts: " + layouts.join(", ")
+          puts "Pages:   " + pages.join(", ")
+          puts "Posts:   " + posts.join(", ")
+          puts
+        end
+        render
+      end
+    end
+
+    def lookup_layout(name)
+      layouts.find{ |l| name == l.name }
+    end
+
+    def sort_files
+      files = Dir['**/*']
+      files.each do |file|
+        temp = false
+        name = File.basename(file)
+        ext  = File.extname(file)
+        case ext
+        when '.layout'
+          layouts << Layout.new(self, file)
+        when '.page' #*%w{.markdown .rdoc .textile .whtml}
+          pages << Page.new(self, file)
+        when '.post'
+          posts << Post.new(self, file)
+        end
+      end
+      posts.sort!{ |a,b| b.date <=> a.date }
+    end
+
+    def render
+      render_posts  # renger posts first, so pages can use them
+      render_pages
+    end
+
+    def render_pages
+      pages.each do |page|
+        page.save(output)
+      end
+    end
+
+    def render_posts
+      posts.each do |post|
+        post.save(output)
+      end
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    def defaults
+      config.defaults
+    end
+
+    def to_h
+      pbt = {}
+      posts_by_tag.each do |tag, posts|
+        pbt[tag] = posts.map{ |p| p.to_h }
+      end
+      {
+        'posts' => posts.map{ |p| p.to_h },
+        'posts_by_tag' => pbt, #posts_by_tag, #.map{ |t, ps| [t, ps.map{|p|p.to_h}] }
+        'tags' => tags
+      }
+    end
+
+    def to_liquid
+      to_h
+    end
+
+  end
+
+end

data/lib/brite/template.rb

@@ -0,0 +1,215 @@
+require 'tilt'
+
+module Brite
+
+  # Stencil controls rendering to a variety
+  # of back-end templating and markup systems.
+  #
+  module TemplateEngine
+    extend self
+
+    #
+    def render(stencil, format, text, attributes)
+      text = render_format(format, text)
+      text = render_stencil(stencil, text, attributes)
+      text
+    end
+
+    #def render_format(format, text)
+    #  case format
+    #  when 'rdoc'
+    #    rdoc(text)
+    #  when 'markdown'
+    #    rdiscount(text)
+    #  when 'textile'
+    #    redcloth(text)
+    #  when 'haml'
+    #    haml(text)
+    #  else # html
+    #    text
+    #  end
+    #end
+
+    # Format Rendering
+    # ----------------
+
+    #
+    def render_format(format, text)
+      case format
+      when /^coderay/
+        coderay(text, format)
+      when 'rdoc'  # TODO: Remove when next version of tilt is released.
+        rdoc(text)
+      else
+        if engine = Tilt[format]
+          engine.new{text}.render #(context)
+        else
+          text
+        end
+      end
+    end
+
+    #
+    #def redcloth(input)
+    #  RedCloth.new(input).to_html
+    #end
+
+    #def bluecloth(input)
+    #  BlueCloth.new(input).to_html
+    #end
+
+    #def rdiscount(input)
+    #  RDiscount.new(input).to_html
+    #end
+
+    def rdoc(input)
+      markup = RDoc::Markup::ToHtml.new
+      markup.convert(input)
+    end
+
+    #def haml(input)
+    #  Haml::Engine.new(input).render
+    #end
+
+    def coderay(input, format)
+      require 'coderay'
+      format = format.split('.')[1] || :ruby #:plaintext
+      tokens = CodeRay.scan(input, format.to_sym) #:ruby
+      tokens.div()
+    end
+
+    # Stencil Rendering
+    # -----------------
+
+    #
+    #def render_stencil(stencil, text, attributes)
+    #  case stencil
+    #  when 'rhtml'
+    #    erb(text, attributes)
+    #  when 'liquid'
+    #    liquid(text, attributes)
+    #  else
+    #    text
+    #  end
+    #end
+
+    #
+    def render_stencil(stencil, text, attributes)
+      if engine = Tilt[stencil]
+        engine.new{text}.render(nil, attributes)
+      else
+        text
+      end
+    end
+
+    #
+    #def erb(input, attributes)
+    #  template = ERB.new(input)
+    #  context  = TemplateContext.new(attributes)
+    #  result   = template.result(context.__binding__)
+    #  result
+    #end
+
+    #def liquid(input, attributes)
+    #  template = Liquid::Template.parse(input)
+    #  result   = template.render(attributes, :filters => [TemplateFilters])
+    #  result
+    #end
+
+    # Require Dependencies
+    # --------------------
+
+    # TODO: Load engines only if used.
+
+    begin ; require 'rubygems'  ; rescue LoadError ; end
+    begin ; require 'erb'       ; rescue LoadError ; end
+    begin ; require 'redcloth'  ; rescue LoadError ; end
+    begin ; require 'bluecloth' ; rescue LoadError ; end
+    begin ; require 'rdiscount' ; rescue LoadError ; end
+
+    begin
+      require 'liquid'
+      #Liquid::Template.register_filter(TemplateFilters)
+    rescue LoadError
+    end
+
+    begin
+      require 'haml'
+      #Haml::Template.options[:format] = :html5
+    rescue LoadError
+    end
+
+    begin
+      require 'rdoc/markup'
+      require 'rdoc/markup/to_html'
+    rescue LoadError
+    end
+
+  end
+
+  #
+  #
+  #
+
+  #module TemplateFilters
+
+    # NOTE: HTML truncate did not work well.
+
+    # # HTML comment regular expression
+    # REM_RE = %r{<\!--(.*?)-->}
+    #
+    # # HTML tag regular expression
+    # TAG_RE = %r{</?\w+((\s+\w+(\s*=\s*(?:"(.|\n)*?"|'(.|\n)*?'|[^'">\s]+))?)+\s*|\s*)/?>}    #'
+    #
+    # #
+    # def truncate_html(html, limit)
+    #   return html unless limit
+    #
+    #   mask = html.gsub(REM_RE){ |m| "\0" * m.size }
+    #   mask = mask.gsub(TAG_RE){ |m| "\0" * m.size }
+    #
+    #   i, x = 0, 0
+    #
+    #   while i < mask.size && x < limit
+    #     x += 1 if mask[i] != "\0"
+    #     i += 1
+    #   end
+    #
+    #   while x > 0 && mask[x,1] == "\0"
+    #     x -= 1
+    #   end
+    #
+    #   return html[0..x]
+    # end
+
+  #end
+
+  # = Clean Rendering Context
+  #
+  # The TemplateContext is is used by ERB.
+
+  class TemplateContext
+    #include TemplateFilters
+
+    instance_methods(true).each{ |m| private m unless m =~ /^__/ }
+
+    def initialize(attributes={})
+      @attributes = attributes
+    end
+
+    def __binding__
+      binding
+    end
+
+    def to_h
+      @attributes
+    end
+
+    def method_missing(s, *a)
+      s = s.to_s
+      @attributes.key?(s) ? @attributes[s] : super
+    end
+  end
+
+end
+

data/meta/authors

@@ -0,0 +1 @@
+Thomas Sawyer

data/meta/contact

@@ -0,0 +1 @@
+http://googlegroups.com/group/proutils

data/meta/copyright

@@ -0,0 +1 @@
+Copyright (c) 2006,2009 Thomas Sawyer

data/meta/description

@@ -0,0 +1,4 @@
+Brite is a remarkably easy to use, light-weight website
+generator. It supports a variety of backend rendering engines
+including rhtml via eruby, textile via redcloth, markdown
+via rdiscount, with others on the way.

data/meta/homepage

@@ -0,0 +1 @@
+http://proutils.github.com/brite

data/meta/license

@@ -0,0 +1 @@
+GPL

data/meta/name

@@ -0,0 +1 @@
+brite

data/meta/repository

@@ -0,0 +1 @@
+git://github.com/proutils/brite.git

data/meta/requires

@@ -0,0 +1 @@
+tilt

data/meta/ruby

@@ -0,0 +1,2 @@
+- 1.8.6
+- 1.8.7

data/meta/subtitle

@@ -0,0 +1 @@
+Light Up Your Site

data/meta/suite

@@ -0,0 +1 @@
+proutils

data/meta/summary

@@ -0,0 +1 @@
+Super Simple Static Site Generation

data/meta/title

@@ -0,0 +1 @@
+Brite

data/meta/version

@@ -0,0 +1 @@
+0.5

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: brite
+version: !ruby/object:Gem::Version 
+  version: "0.5"
+platform: ruby
+authors: 
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-17 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tilt
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: |-
+  Brite is a remarkably easy to use, light-weight website
+  generator. It supports a variety of backend rendering engines
+  including rhtml via eruby, textile via redcloth, markdown
+  via rdiscount, with others on the way.
+email: http://googlegroups.com/group/proutils
+executables: 
+- brite
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MANIFEST
+- LICENSE
+- HISTORY
+files: 
+- bin/brite
+- lib/brite/command.rb
+- lib/brite/config.rb
+- lib/brite/layout.rb
+- lib/brite/page.rb
+- lib/brite/part.rb
+- lib/brite/post.rb
+- lib/brite/site.rb
+- lib/brite/template.rb
+- meta/authors
+- meta/contact
+- meta/copyright
+- meta/description
+- meta/homepage
+- meta/license
+- meta/name
+- meta/repository
+- meta/requires
+- meta/ruby
+- meta/subtitle
+- meta/suite
+- meta/summary
+- meta/title
+- meta/version
+- LICENSE
+- README
+- HISTORY
+- MANIFEST
+has_rdoc: true
+homepage: http://proutils.github.com/brite
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Brite API
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: brite
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Super Simple Static Site Generation
+test_files: []
+