hobix 0.6

data/lib/hobix/base.rb

@@ -0,0 +1,480 @@
+#
+# = hobix/weblog.rb
+#
+# Hobix command-line weblog system.
+#
+# Copyright (c) 2003-2004 why the lucky stiff
+#
+# Written & maintained by why the lucky stiff <why@ruby-lang.org>
+#
+# This program is free software, released under a BSD license.
+# See COPYING for details.
+#
+#--
+# $Id$
+#++
+require 'redcloth'
+require 'yaml'
+
+module YAML
+    class Omap
+        def keys; map { |k, v| k }; end
+    end
+end
+
+module Hobix
+# The BasePlugin class is *bingo* the underlying class for
+# all Hobix plugins.  The +Class::inherited+ hook is used
+# by this class to keep track of all classes that inherit
+# from it.
+class BasePlugin
+    @@plugins = {}
+    @@required_from = nil
+    # Initializes all the plugins, returning
+    # an Array of plugin objects.  (Used by the
+    # +Hobix::Weblog+ class.)
+    def BasePlugin.start( req, opts, weblog )
+        @@required_from = req = req.dup
+        if req.tainted?
+            req.untaint if req =~ /^[\w\/\\]+$/
+        end
+        require( req )
+        @@required_from = nil
+
+        if @@plugins[req]
+            @@plugins[req].collect do |p|
+                if opts
+                    p.new( weblog, opts )
+                else
+                    p.new( weblog )
+                end
+            end
+        else
+            []
+        end
+    end
+    def BasePlugin.inherited( sub )
+        @@plugins[@@required_from] ||= []
+        @@plugins[@@required_from] << sub
+    end
+end
+
+# The BaseStorage class outlines the fundamental API for
+# all storage plugins.  Storage plugins are responsible
+# for abstracting away entry queries and managing the loading
+# of Entry objects.  The goal being: cache as much as you can,
+# be efficient and tidy.
+#
+# == Query Methods
+#
+# find::    Each of the query methods below uses the +find+ method
+#           to perform its search.  This method accepts a Hash of
+#           parameters.  Please note that calling +find+ without
+#           parameters will return all entries which qualify for
+#           placement on the front page.
+#
+# all::     Returns all entries.  Searches find( :all => true )
+# lastn::   Returns the last _n_ entries which qualify for the
+#           front page.
+# inpath::  Returns entries within a path which qualify for the
+#           front page.
+# after::   Returns entries created after a given date.
+# before::  Returns entries created before a given date.
+# within::  Returns entries created between a start and
+#           end date.
+# 
+class BaseStorage < BasePlugin
+    def initialize( weblog )
+        @link = weblog.link
+    end
+    def default_entry_id; "hobix-default-entry"; end
+    def default_entry( author )
+        Hobix::Entry.new do |e|
+            e.id = default_entry_id 
+            e.link = e.class.url_link e, @link, "html"
+            e.created = Time.now
+            e.modified = Time.now
+            e.updated = Time.now
+            e.title = "This Ghostly Message From the Slime Will Soon Vanish!"
+            e.tagline = "A temporary message, a tingling sensation, Hobix is up!!"
+            e.author = author
+            e.content = Hobix::Entry.text_processor.new( "Welcome to Hobix!  Once you make your first blog post, this entry will disappear.  However, in the meantime, you can tweak the CSS of your blog until it suits your satisfaction and you have this bit of words to act as a place holder." )
+        end
+    end
+    def all
+        find( :all => true )
+    end
+    def lastn( n )
+        find( :lastn => ( n || 10 ) )
+    end
+    def inpath( path, n = nil )
+        find( :inpath => path, :lastn => n )
+    end
+    def after( after, n = nil )
+        find( :after => after, :lastn => n )
+    end
+    def before( before, n = nil )
+        find( :before => before, :lastn => n )
+    end
+    def match( expr )
+        find( :match => expr )
+    end
+    def within( after, before )
+        find( :after => after, :before => before )
+    end
+end
+
+# The BaseOutput plugin is the underlying class for all output
+# plugins.  These plugins are associated to templates.  Based on
+# a template's suffix, the proper output plugin is loaded and
+# used to generate page output.
+class BaseOutput < BasePlugin
+end
+
+# The BasePublish plugin is the underlying class for all publishing
+# plugins, which are notified of updates to pages.
+#
+# Publish plugins are executed after generation of the site.  The plugin
+# may choose to watch updates to certain types of pages.  The plugin also
+# receives a list of all the pages which have been updated.
+#
+# Generally, publish plugins fall into two categories:
+#
+# * Plugins which contact a service when certain updates happen.
+#   (Hobix includes an XML-RPC ping, which is triggered whenever
+#   the front page is updated.)
+# * Plugins which transform Hobix output.  (Hobix includes a
+#   replication plugin, which copies updated pages to a remote
+#   system via FTP or SFTP.)
+#
+# == Publish methods
+#
+# initialize( weblog, settings ):: Like all other plugins, the initialize method takes two parameters,
+#                                  a Hobix::Weblog object for the weblog being published and the 
+#                                  settings data from the plugin's entry in hobix.yaml.
+# watch:: (Optional) Returns an array of page types which, when published, activate the plugin.
+# publish( pages ):: If pages are published and the watch criteria qualifies this plugin,
+#                    this method is called with a hash of pages published.  The key is the page type
+#                    and the value is an array of Page objects.
+class BasePublish < BasePlugin
+end
+
+# The BaseFacet plugin is the superclass for all plugins which have
+# an interface (CGI, UI, etc.)  These interfaces expose some functionality
+# to the user through an entry form or series of views.
+class BaseFacet < BasePlugin
+    def self.not_found app
+        app.send_not_found "Action `#{ app.action_uri }' not found.  If this address should work, check your plugins."
+    end
+    def protect app, weblog
+        auth = ENV['HTTP_AUTHORIZATION'] || ENV['X-HTTP_AUTHORIZATION']
+        if auth
+            realm = 'Hobix login'
+            auth_type, auth = auth.split ' ', 2
+            authorized = false
+            case auth_type.downcase
+            when 'basic'
+                require 'base64'
+                name, pass = Base64::decode64( auth.strip ).split ':', 2
+                authorized = weblog.authorize name, pass
+            when 'digest'
+                require 'md5'
+                opts = {}
+                auth.gsub( /(\w+)="(.*?)"/ ) { opts[$1] = $2 }
+                app.puts opts.inspect
+            end
+            return true if authorized
+        end
+
+        app.send_unauthorized
+        # nonce = ["#{ Time.now.to_f }:#{ app.action_uri }"].pack("m").gsub /\s/, ''
+        # app.set_header 'WWW-Authenticate', %{Digest qop="auth", realm="#{ realm }", nonce="#{ nonce }", algorithm="MD5"}
+        app.set_header 'WWW-Authenticate', %{Basic realm="#{ realm }"}
+        false
+    end
+end
+
+# Enumerable::each_with_neighbors from Joel Vanderwerf's 
+# enum extenstions.
+module Enumerable
+    def each_with_neighbors n = 1, empty = nil
+        nbrs = [empty] * (2 * n + 1)
+        offset = n
+
+        each { |x|
+            nbrs.shift
+            nbrs.push x
+            if offset == 0  # offset is now the offset of the first element, x0,
+                yield nbrs    #   of the sequence from the center of nbrs, or 0,
+            else            #   if x0 has already passed the center.
+                offset -= 1
+            end
+        }
+
+        n.times {
+            nbrs.shift
+            nbrs.push empty
+            if offset == 0
+                yield nbrs
+            else
+                offset -= 1
+            end
+        }
+
+        self
+    end
+end
+
+module BaseProperties
+    # Returns the complete list of properties for the immediate class.
+    # If called on an inheriting class, inherited properties are included.
+    module ClassMethods
+        def properties
+            if superclass.respond_to? :properties
+                s = superclass.properties.dup
+                (@__props || {}).each { |k, v| s[k] = v }
+                s
+            else
+                (@__props || {})
+            end
+        end
+        def prop_sections
+            if superclass.respond_to? :prop_sections
+                s = superclass.prop_sections.dup
+                (@__sects || {}).each { |k, v| s[k] = v }
+                s
+            else
+                (@__sects || {})
+            end
+        end
+        # Quick property definitions in class definitions.
+        def _ name, opts = nil
+            @__props ||= YAML::Omap[]
+            @__props[name] = opts
+            attr_accessor name unless method_defined? "#{ name }="
+        end
+        # Property sections
+        def _! name, opts = {}
+            @__sects ||= YAML::Omap[]
+            opts[:__sect] = @__props.last[0] rescue nil
+            @__sects[name] = opts
+        end
+    end
+    # Build a simple map of properties
+    def property_map
+        self.class.properties.map do |name, opts|
+            if opts
+                yreq = opts[:req] ? :req : :opt
+                ["@#{ name }", yreq] if yreq
+            end
+        end.compact
+    end
+    # Build a property map for the YAML module
+    def to_yaml_properties
+        property_map.find_all do |prop, req|
+            case req
+            when :opt
+                not instance_variable_get( prop ).nil?
+            when :req
+                true
+            end
+        end.
+        collect do |prop, req|
+            prop
+        end
+    end
+    def self.append_features klass
+        super
+        klass.extend ClassMethods
+    end
+end
+
+# placed here to avoid dependency cycle between base.rb and weblog.rb
+class Weblog
+    @@entry_classes = []
+    def self.add_entry_class( c )
+        @@entry_classes << c
+    end
+end
+
+class BaseContent
+    include BaseProperties
+
+    _! 'Entry Information'
+    _ :id
+    _ :link
+    _ :title,               :edit_as => :text, :search => :fulltext
+    _ :created,             :edit_as => :datetime, :search => :prefix
+    _ :modified,            :show_as => :datetime
+    _ :updated,             :show_as => :datetime
+    _ :tags,                :edit_as => :text, :search => :prefix
+
+    def initialize; yield self if block_given?; end
+    def day_id; created.strftime( "%Y/%m/%d" ) if created; end
+    def month_id; created.strftime( "%Y/%m" ) if created; end
+    def year_id; created.strftime( "%Y" ) if created; end
+    def section_id; File.dirname( id ) if id; end
+    def base_id; File.basename( id ) if id; end
+    def self.url_link( e, url = nil, ext = nil ); "#{ url }/#{ link_format e }#{ '.' + ext if ext }"; end
+    def self.link_format( e ); e.id; end
+    def force_tags; []; end
+
+    #
+    # If set to true, tags won't be deduced from the entry id
+    #
+    @@no_implicit_tags = false
+
+    def self.no_implicit_tags
+      @@no_implicit_tags = true
+    end
+
+    #
+    # When using implicit tag, the blog root (i.e) is not considered
+    # unless you set the value of +@@root_tag+ to what you need.
+    #
+    @@root_tag = nil
+    def self.root_tag=( tag )
+      @@root_tag = tag
+    end
+    
+    #
+    # When computing so-called implicit 'implicit-tag', whether
+    # or not we should split the path into several tags
+    # (default: false)
+    #
+    @@split_implicit_tags = false
+    
+    def self.split_implicit_tags
+      @@split_implicit_tags = true
+    end
+
+    #
+    # return an array of tags deduced from the path
+    # i.e. a path like ruby/hobix/foo.yml will lead
+    # to [ ruby, hobix ] tags
+    # Occurence of . (alone) will be either removed or replaced
+    # by the value of +root_tag+
+    #
+    def path_to_tags( path )
+      return [] if @@no_implicit_tags
+      return [] if path.nil? 
+      if @@split_implicit_tags
+        tags_array = path.split("/").find_all { |e| e.size > 0 }
+        tags_array.pop # Last item is the entry title
+      else
+        tags_array = [ File.dirname( path )]
+      end
+      tags_array.map { |e| e == '.' ? @@root_tag : e }.compact
+    end
+
+    # 
+    # return canonical tags, i.e. tags that are forced and that are deduced
+    # from the entry path
+    #
+    def canonical_tags( path=nil )
+      ( force_tags + path_to_tags( path || self.id ) ).uniq
+    end
+
+    def tags;( canonical_tags + Array( @tags ) ).uniq; end
+
+    def self.yaml_type( tag )
+#         if self.respond_to? :yaml_as
+#             yaml_as tag
+#         else
+            if tag =~ /^tag:([^:]+):(.+)$/
+                define_method( :to_yaml_type ) { "!#$1/#$2" }
+                YAML::add_domain_type( $1, $2 ) { |t, v| self.maker( v ) }
+            end
+#         end
+    end
+
+    alias to_yaml_orig to_yaml
+    def to_yaml( opts = {} )
+        opts[:UseFold] = true if opts.respond_to? :[]
+        self.class.text_processor_fields.each do |f|
+            v = instance_variable_get( '@' + f )
+            if v.is_a? self.class.text_processor
+                instance_eval %{
+                    def @#{ f }.to_yaml( opts = {} )
+                        s = self.to_str
+                        def s.to_yaml_style; :literal; end
+                        s.to_yaml( opts )
+                    end
+                }
+            end
+        end
+        to_yaml_orig( opts )
+    end
+
+    # Load the weblog entry from a file.
+    def self.load( file )
+      File.open( file ) { |f| YAML::load( f ) }
+    end
+
+    # Accessor which returns the text processor used for untyped
+    # strings in Entry fields.  (defaults to +RedCloth+.)
+    def self.text_processor; RedCloth; end
+    # Returns an Array of fields to which the text processor applies.
+    def self.text_processor_fields
+        self.properties.map do |name, opts|
+            name.to_s if opts and opts[:text_processor]
+        end.compact
+    end
+    # Factory method for generating Entry classes from a hash.  Used
+    # by the YAML loader.
+    def self.maker( val )
+        self::text_processor_fields.each do |f|
+            if val[f].respond_to? :value
+                str = val[f].value
+                def str.to_html
+                    self
+                end
+                val[f] = str
+            elsif val[f].respond_to? :to_str
+                val[f] = self::text_processor.new( val[f].to_str ) 
+            end
+        end
+        YAML::object_maker( self, val )
+    end
+end
+
+# The BaseEntry class is the underlying class for all Hobix
+# entries (i.e. the content for your website/blahhg.)
+class BaseEntry < BaseContent
+
+    _ :id
+    _ :link
+    _ :title,               :edit_as => :text, :search => :fulltext
+    _ :author,              :req => true, :edit_as => :text, :search => :prefix
+    _ :contributors,        :edit_as => :array, :search => :prefix
+    _ :created,             :edit_as => :datetime, :search => :prefix
+    _ :modified,            :show_as => :datetime
+    _ :updated,             :show_as => :datetime
+    _ :tags,                :edit_as => :text, :search => :prefix
+    _ :content,             :edit_as => :textarea, :search => :fulltext, :text_processor => true
+    _ :content_ratings,     :edit_as => :array
+
+    def content_ratings; @content_ratings || [:ham]; end
+
+    def self.inherited( sub )
+        Weblog::add_entry_class( sub )
+    end
+
+    # Build the searchable text
+    def to_search
+        self.class.properties.map do |name, opts|
+            next unless opts
+            val = instance_variable_get( "@#{ name }" )
+            next unless val
+            val = val.strftime "%Y-%m-%dT%H:%M:%S" if val.respond_to? :strftime
+            case opts[:search]
+            when :prefix
+                "#{ name }:" + val.to_s
+            when :fulltext
+                val.to_s
+            end
+        end.compact.join "\n"
+    end
+
+end
+end

data/lib/hobix/bixwik.rb

@@ -0,0 +1,200 @@
+#
+# = hobix/bixwik.rb
+#
+# Hobix command-line weblog system.
+#
+# Copyright (c) 2003-2004 why the lucky stiff
+#
+# Written & maintained by why the lucky stiff <why@ruby-lang.org>
+#
+# This program is free software, released under a BSD license.
+# See COPYING for details.
+#
+#--
+# $Id$
+#++
+require 'hobix/weblog'
+
+module Hobix
+# The BixWik class is an extended Weblog, which acts like a Wiki.
+# (See http://instiki.org/ for inspiration.)
+class BixWikPlugin < Hobix::BasePlugin
+    def initialize( weblog )
+        class << weblog
+            include Hobix::BixWik
+        end
+    end
+end
+
+module BixWik
+
+    QUICK_MENU = YAML::load <<-END
+        --- %YAML:1.0 !omap
+        - HomePage: [Home Page, H, Start Over]
+        - list/index: [All Pages, A, Alphabetically sorted list of pages]
+        - recent/index: [Recently Revised, U, Pages sorted by when they were last changed]
+        - authors/index: [Authors, ~, Who wrote what]
+        - FeedList: [Feed List, ~, Subscribe to changes by RSS]
+    END
+
+    def default_entry_class; "Hobix::BixWik::Entry"; end
+    def default_index_class; "Hobix::BixWik::IndexEntry"; end
+
+    # Handler for templates with `index' prefix.  These pages simply
+    # mirror the `HomePage' entry.
+    def skel_index( path_storage, section_path )
+        homePage = path_storage.match( /^HomePage$/ ).first
+        page = Page.new( 'index' )
+        unless homePage
+            homePage = Hobix::Storage::IndexEntry.new( path_storage.default_entry( authors.keys.first ) )
+        end
+        page.timestamp = homePage.created
+        page.updated = homePage.created
+        yield :page => page, :entry => homePage
+    end
+
+    # Handler for templates with `list/index' prefix.  These templates will
+    # receive IndexEntry objects for every entry in the system.  Only one
+    # index page is requested by this handler.
+    def skel_recent_index( path_storage, section_path )
+        index_entries = storage.find( :all => true )
+        page = Page.new( 'list/index' )
+        page.timestamp = index_entries.first.created
+        page.updated = storage.last_updated( index_entries )
+        yield :page => page, :entries => index_entries
+    end
+
+    # Handler for templates with `recent/index' prefix.  These templates will
+    # receive entries loaded by +Hobix::BaseStorage#lastn+.  Only one
+    # index page is requested by this handler.
+    def skel_recent_index( path_storage, section_path )
+        index_entries = storage.lastn( @lastn || 120 )
+        page = Page.new( 'recent/index' )
+        page.timestamp = index_entries.first.created
+        page.updated = storage.last_updated( index_entries )
+        yield :page => page, :entries => index_entries
+    end
+
+    # Handler for templates with `list/index' prefix.  These templates will
+    # receive a list of all pages in the Wiki.
+    def skel_list_index( path_storage, section_path )
+        all_pages = storage.all
+        page = Page.new( 'list/index' )
+        page.timestamp = all_pages.first.created
+        page.updated = storage.last_updated( all_pages )
+        yield :page => page, :entries => all_pages, :no_load => true
+    end
+
+    def abs_link( word )
+        output_entry_map[word] && output_entry_map[word][:page].link
+    end
+
+    def wiki_page( src )
+        src.gsub( /\b([A-Z][a-z]+[A-Z][\w\/]+)\b/ ) { wiki_link( $1 ) }
+    end
+
+    def wiki_link( word )
+        abs_link = output_entry_map[word]
+        if abs_link
+            "<a class=\"existingWikiWord\" href=\"#{ expand_path( abs_link[:page].link ) }\">#{ Hobix::BixWik::wiki_word word }</a>"
+        else
+            "<span class=\"newWikiWord\">#{ Hobix::BixWik::wiki_word word }<a href=\"#{ expand_path( "control/edit/#{ word }" ) }\">?</a></span>"
+        end
+    end
+
+    def self.wiki_word( id )
+        Hobix::BixWik::QUICK_MENU[ id ].to_a.first || id.gsub( /^\w|_\w|[A-Z]/ ) { |up| " #{up[-1, 1].upcase}" }.strip
+    end
+
+    require 'redcloth'
+    class WikiRedCloth < RedCloth
+    end
+
+    class IndexEntry < Hobix::IndexEntry
+        _ :author
+        def title
+            Hobix::BixWik::wiki_word( self.id )
+        end
+        def to_yaml_type
+            "!hobix.com,2004/bixwik/indexEntry"
+        end
+    end
+
+    class Entry < Hobix::Entry
+        def title
+            Hobix::BixWik::wiki_word( self.id )
+        end
+        def to_yaml_type
+            "!hobix.com,2004/bixwik/entry"
+        end
+        def self.text_processor; WikiRedCloth; end
+    end
+end
+end
+
+YAML::add_domain_type( 'hobix.com,2004', 'bixwik/entry' ) do |type, val|
+    Hobix::BixWik::Entry::maker( val )
+end
+
+YAML::add_domain_type( 'hobix.com,2004', 'bixwik/indexEntry' ) do |type, val|
+    YAML::object_maker( Hobix::BixWik::IndexEntry, val )
+end
+
+module Hobix
+module Facets
+class WikiEdit < BaseFacet
+    def initialize( weblog, defaults = {} )
+        @weblog = weblog
+    end
+    def get app
+        if app.respond_to? :action_uri
+            ns, method_id = app.action_uri.split( '/', 2 )
+            return false unless ns == "edit"
+
+            # Display publisher page
+            app.content_type = 'text/html'
+            app.puts ::ERB.new( erb_src, nil, nil, "_bixwik" ).result( binding )
+            return true
+        end
+    end
+end
+end
+
+module Out
+class Quick
+def banner_erb; %{
+  <% page_id = page.id %>
+  <% page_id = 'HomePage' if page.id == 'index' %>
+  <% page_name = Hobix::BixWik::wiki_word( page_id ) %>
+  <div id="banner">
+    <% if page_id == "HomePage" %>
+      <h1 id="title"><%= weblog.title %></h1>
+      <% if weblog.tagline %><div id="tagline"><%= weblog.tagline %></div><% end %>
+    <% else %>
+      <div id="title"><%= weblog.title %></div>
+      <h1 id="pageName"><%= page_name %></h1>
+    <% end %>
+    <form id="navigationForm" class="navigation" action="<%= weblog.expand_path( 'search' ) %>" action="get" style="font-size: 10px">  
+    <% Hobix::BixWik::QUICK_MENU.each do |menu_link, attr| %>
+      <% if page_id == menu_link %>
+        <%= attr[0] %>
+      <% else %>
+      <a href="<%= weblog.abs_link( menu_link ) %>" title="<% if attr[1] %>[<%= attr[1] %>] <% end %><%= attr[2] %>" 
+           accesskey="<%= attr[1] %>"><%= attr[0] %></a>
+      <% end %> |
+    <% end %>
+    <input type="text" id="searchField" name="query" style="font-size: 10px" value="Search" onClick="this.value == 'Search' ? this.value = '' : true">
+    </form>
+  </div> }
+end
+def entry_title_erb; end
+def entry_content_erb
+    %{ <div class="entryContent"><%= weblog.wiki_page( entry.content.to_html ) %></div> }
+end
+def sidebar_erb; nil; end
+def entry_footer_erb; %{
+  Revision from <%= ( entry.modified || entry.created ).strftime( "%d %B %Y at %H:%M" ) %> by <%= weblog.wiki_link( "authors/" + entry.author ) %> }
+end
+end
+end
+end