hobix 0.6

data/lib/hobix/plugin/sections.rb

@@ -0,0 +1,91 @@
+## sections.rb -- Hobix section list plugin
+##
+## Displays a list of all the sections of your blog.
+##
+## USAGE:
+##
+## 1) In hobix.yaml (e.g. by running 'hobix edit <blogname>'), simply
+##    add 'hobix/plugin/sections' to the 'required' list, as follows:
+##
+## required:
+##   - hobix/plugin/sections
+##
+##    And that's it!
+##
+## NOTES:
+##
+## 1) If you redefine 'sidebar_list' in hobix.yaml, you'll need to
+##    explicitly add a 'sidebar_section_list' item.
+## 2) The default Hobix CSS doesn't indent lists, so the hierarchy is 
+##    lost upon display. You can add something like this to your CSS file
+##    to fix this:
+##
+## .sidebarBox ul {
+##     margin:7px;
+##     padding:0px;
+## }
+
+class Hobix::Out::Quick
+  def section_list( entries, topname = "top level" )
+    counts = {}
+    entries.each do |entry|
+      path = ( entry.id.split("/")[0 ... -1] || [] ) # nil in ruby 1.8.1 if path is ""
+      counts[path] = 1 + ( counts[path] || 0 )
+    end
+
+    list = []; seen = {}
+    counts[[]] ||= 0 # force the root
+    counts.sort.each do |path, count|
+      if path == []
+        list.push [topname, "", 0, counts[path]]        
+      else
+        path.inject( "." ) do |s, x|
+          prefix = s + "/" + x
+          unless seen[prefix]
+            length = prefix.count '/'
+            list.push [x, prefix, length, ( length == path.length ? count : 0 ) ]
+            seen[prefix] = true
+          end
+          prefix
+        end
+      end
+    end
+    list
+  end
+
+  def sidebar_section_list_erb
+  %q{
+    <div class="sidebarBox">
+    <h2 class="sidebarTitle">Sections</h2>
+    <% curlev = -1 %>
+    <% section_list( weblog.storage.find ).each do |name, path, lev, num| %>
+      <% if ( lev > curlev ) %>
+        <% ( lev - curlev ).times do %> <ul> <% end %>
+      <% else # less than or equal %>
+        </li>
+      <% end %>
+      <% if ( curlev > lev ) %>
+        <% ( curlev - lev ).times do %> </ul></li> <% end %>
+      <% end %>
+
+      <% curlev = lev %>
+      <li>
+        <a href="<%= weblog.expand_path path %>"><%= name %></a><% if num != 0 then %>: <%= num %> <% end %>
+    <% end %>
+    <% ( curlev + 1 ).times do %>
+      </li></ul>
+    <% end %>
+    </div>
+  }
+  end
+
+  alias sections_old_sidebar_list_erb sidebar_list_erb
+  def sidebar_list_erb
+    l = sections_old_sidebar_list_erb
+    if l.last == "sidebar_hobix"
+      l[0 ... (l.length - 1)] + ['sidebar_section_list', 'sidebar_hobix']
+    else
+      l + ['sidebar_section_list']
+    end
+  end
+end

data/lib/hobix/plugin/tags.rb

@@ -0,0 +1,60 @@
+## tags.rb -- Hobix tag list plugin
+##
+## Displays a list of all the tags of your blog.
+##
+## USAGE:
+##
+## 1) In hobix.yaml (e.g. by running 'hobix edit <blogname>'), simply
+##    add 'hobix/plugin/tags' to the 'required' list, as follows:
+##
+## required:
+##   - hobix/plugin/tags
+##
+##    And that's it!
+##
+## NOTES:
+##
+## 1) If you redefine 'sidebar_list' in hobix.yaml, you'll need to
+##    explicitly add a 'sidebar_tag_list' item.
+
+class Hobix::Out::Quick
+  def tags_list(entries)
+    tags = { }
+    entries.each do |e|
+      if e.tags
+        e.tags.each do |t|
+          tags[t] ||= 0
+          tags[t] += 1
+        end
+      end
+    end
+    tags
+  end
+
+  def sidebar_tag_list_erb
+    %q{
+        <div class="sidebarBox">
+        <h2 class="sidebarTitle">Tags</h2>
+        <ul>
+        <% tags_list(weblog.storage.find).sort.each do |name, count| %>
+          <li>
+            <a href="<%= weblog.expand_path "tags/#{ name }/" %>"><%= name
+            %></a>:&nbsp;<%=count%>
+          </li>
+        <% end %>
+        </ul>
+        </div>
+      }
+  end
+
+  alias tags_old_sidebar_list_erb sidebar_list_erb
+  def sidebar_list_erb
+    l = tags_old_sidebar_list_erb
+    if l.last == "sidebar_hobix"
+      l[0 ... (l.length - 1)] + ['sidebar_tag_list', 'sidebar_hobix']
+    else
+      l + ['sidebar_tag_list']
+    end
+  end
+
+end

data/lib/hobix/publish/ping.rb

@@ -0,0 +1,53 @@
+#
+# = hobix/out/ping.rb
+#
+# XML-RPC pingt for Hobix.
+#
+# 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/base'
+require 'xmlrpc/client'
+
+module Hobix
+module Publish
+class Ping < Hobix::BasePublish
+    def initialize( weblog, urls )
+        @title = weblog.title
+        @link = weblog.link
+        @urls = urls
+    end
+    def watch
+        ['index']
+    end
+    def publish( pages )
+        @urls.each do |u|
+            link = @link.to_s
+            u, link = u.keys.first, u.values.first if Hash === u
+            puts "pinging #{ u }..."
+            u = URI::parse( u )
+            begin
+                server = XMLRPC::Client.new( u.host, u.path, u.port )
+
+                begin
+                    result = server.call( "weblogUpdates.ping", @title, link )
+                rescue XMLRPC::FaultException => e
+                    puts "Error: "
+                    puts e.faultCode
+                    puts e.faultString
+                end
+            rescue Exception => e
+                puts "Error: #{ e.message }"
+            end
+        end
+    end
+end
+end
+end

data/lib/hobix/publish/replicate.rb

@@ -0,0 +1,283 @@
+# Content replication: will replicate and/or update the target with
+# the files generated by Hobix
+# Can handle (currently) copy via FTP and on local filesystem. Plug of sftp should
+# not be hard.
+#
+# == How to use
+#  Add the follozing to your hobix.yaml file:
+#
+#  - replicate:
+#      target: ftp://user:pass@isp.com/foo/bar/
+#      production_link: http://www.myisp.com/~me/blog
+#
+#  production_link is optionnal and has been stolen from Sebastian Kanthak
+#  (http://www.kanthak.net/explorations/blog/hobix/staging_hobix.html)
+#
+#  It allows to change the link to the weblog based on the HOBIX_ENV variable
+#  which mean that you can have a local test blog (link set to /home/me/foo/blog/htdocs)
+#  for example, and a "production" blog (link is http://www.myisp.com/~me/blog) and it should
+#  be uploaded to isp.com/foo/bar/ using given user/pass
+#
+#  Thus to sum-up: 
+#  
+#  * If the HOBIX_ENV variable is set to "production", then the link is changed
+#    to value of production_link (if available) and the page are uploaded to target
+#  * If HOBIX_ENV is not set, then the link is not changed and the page go to htdocs
+#
+#
+#  == TODO
+#  - Beautify/simplify code
+#  - Potentially add some other "non-generated" files (for example css files..)
+#
+#  Copyright - Frederick Ros
+#  License: same as Ruby's one
+#
+#  $Id$
+#
+require 'hobix/base'
+require 'net/ftp'
+require 'fileutils'
+
+module Publish
+
+  Target = Struct.new( :path, :host, :user, :passwd )
+
+  class PublishReplication < Hobix::BasePublish
+    attr_reader :production, :replicator, :weblog
+    
+    def initialize( blog, hash_opt )
+      @weblog = blog
+      hash_opt['items'] = nil
+      hash_opt['source'] = weblog.output_path
+      
+      if ENV['HOBIX_ENV'] == "production"
+        @production = true
+        #
+        # Change link if a production one is given
+        #
+        blog.link = hash_opt['production_link'] || blog.link
+      else
+        @production = false
+      end
+
+      if hash_opt['target'] =~ /^ftp:\/\/([^:]+):([^@]+)@([^\/]+)(\/.*)$/
+        tgt = Target.new($4,$3,$1,$2)
+
+        @replicator = ReplicateFtp::new(hash_opt, tgt)
+      else
+        #
+        # File replication
+        #
+        tgt = Target.new(hash_opt['target'])
+        @replicator = ReplicateFS.new(hash_opt, tgt)	  
+
+      end
+    end
+
+    def watch
+      ['index']
+    end
+
+    def publish( page_name )
+      return unless production
+      replicator.items = weblog.updated_pages.map { |o| o.link }
+      replicator.copy do |nb,f,src,tgt|
+        puts "## Replicating #{src}"
+      end
+    end
+
+  end
+end
+
+module Hobix
+  class Weblog
+    attr_reader :updated_pages
+    
+    alias p_publish_orig p_publish
+
+    def p_publish( obj )
+      @updated_pages ||= []
+      @updated_pages << obj
+      p_publish_orig( obj )
+    end
+
+  end
+end
+
+class Replicate
+
+  attr_accessor :items, :target, :source
+
+  def initialize(hash_src, hash_tgt)
+    @items = hash_src['items']
+    @source = hash_src['source']
+    @target = hash_tgt['path']
+
+  end
+
+
+  DIRFILE = /^(.*\/)?([^\/]*)$/
+
+  def get_dirs
+    dirs = Array.new
+
+    dirfiles = items.collect do |itm|
+      dir,file =  DIRFILE.match(itm).captures
+
+      if dir && dir.strip.size != 0
+	dirs.push dir
+      end
+    end
+    
+    dirs
+  end
+
+  def get_files
+    files = Array.new
+    dirfiles = items.collect do |itm|
+      dir,file =  DIRFILE.match(itm).captures
+
+      if file && file.strip.size != 0
+	files.push itm
+      end
+    end
+    
+    files
+  end
+
+  def check_and_make_dirs
+    dirs = get_dirs
+
+    dirs.each do |dir|
+      # Check existence and create if not present
+      dir = File.join(target,dir)
+      if !directory?(dir) 
+	# Let's create it !
+	mkdir_p(dir)
+      end
+    end      
+  end
+
+
+  def copy_files ( &block)
+    files = get_files
+
+    nb_files = files.size
+
+    files.each do |file|
+
+      src_f = File.join(source,file)
+      tgt_f = File.join(target,file)
+	
+      if block_given?
+	yield nb_files,file, src_f, tgt_f
+      end
+
+      cp(src_f,tgt_f)      
+    end
+  end
+
+
+  def copy (&block)
+    if respond_to?(:login)
+      send :login
+    end
+
+    check_and_make_dirs
+
+    copy_files &block
+
+    if respond_to?(:logout)
+      send :logout
+    end
+
+  end
+
+end
+
+
+class ReplicateFtp < Replicate
+
+  attr_accessor :ftp, :passwd, :user, :host
+
+  def initialize(hash_src, hash_tgt) 
+    super(hash_src,hash_tgt)
+
+    @user = hash_tgt['user']
+    @passwd = hash_tgt['passwd']
+    @host = hash_tgt['host']
+
+  end
+
+  def login
+    @ftp = Net::FTP.open(host)
+    ftp.login user,passwd
+  end
+
+  def logout
+    ftp.close
+  end
+
+  def directory?(d)
+    old_dir = ftp.pwd
+
+    begin
+      ftp.chdir d
+      # If we successfully change to d, we could now return to orig dir
+      # otherwise we're in the rescue section ...
+      ftp.chdir(old_dir)
+      return true
+
+    rescue Net::FTPPermError
+      if $!.to_s[0,3] == "550"
+	# 550 : No such file or directory
+	return false
+      end
+      raise Net::FTPPermError, $!
+    end
+  end
+
+
+  def mkdir_p(tgt)
+    old_dir = ftp.pwd
+    tgt.split(/\/+/).each do |dir|
+      next if dir.size == 0
+      # Let's try to go down
+      begin
+	ftp.chdir(dir)
+	# Ok .. So it was already existing ..
+      rescue Net::FTPPermError
+	if $!.to_s[0,3] == "550"
+	  # 550 : No such file or directory : let's create ..
+	  ftp.mkdir(dir)
+	  # and retry
+	  retry
+	end
+	raise Net::FTPPermError, $!
+      end
+    end
+    ftp.chdir(old_dir)
+
+  end
+
+
+  def cp(src,tgt)
+    ftp.putbinaryfile src, tgt
+  end
+end
+
+class ReplicateFS < Replicate
+
+  def directory?(d)
+    File.directory? d
+  end
+
+  def mkdir_p(tgt)
+    FileUtils.mkdir_p tgt
+  end
+
+  def cp(src,tgt)
+    FileUtils.cp src, tgt
+  end
+
+end

data/lib/hobix/publisher.rb

@@ -0,0 +1,18 @@
+#
+# = hobix/publisher.rb
+#
+# Hobix command-line weblog system, web-based publishing interface.
+#
+# 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/facets/publisher'
+

data/lib/hobix/search/dictionary.rb

@@ -0,0 +1,141 @@
+# Maintain a dictionary mapping words to consecutive integers (the
+# first unique word is 0, the second is 1 and so on)
+
+require 'hobix/search/porter_stemmer'
+module Hobix
+module Search
+  module Simple
+  class Dictionary
+    STOP_WORDS = {
+      "a" => 1,
+      "again" => 1,
+      "all" => 1,
+      "along" => 1,
+      "also" => 1,
+      "an" => 1,
+      "and" => 1,
+      "arialhelvetica" => 1,
+      "as" => 1,
+      "at" => 1,
+      "but" => 1,
+      "by" => 1,
+      "came" => 1,
+      "can" => 1,
+      "cant" => 1,
+      "couldnt" => 1,
+      "did" => 1,
+      "didn" => 1,
+      "didnt" => 1,
+      "do" => 1,
+      "doesnt" => 1,
+      "dont" => 1,
+      "entrytitledetail" => 1,
+      "ever" => 1,
+      "first" => 1,
+      "fontvariant" => 1,
+      "from" => 1,
+      "have" => 1,
+      "her" => 1,
+      "here" => 1,
+      "him" => 1,
+      "how" => 1,
+      "i" => 1,
+      "if" => 1,
+      "in" => 1,
+      "into" => 1,
+      "is" => 1,
+      "isnt" => 1,
+      "it" => 1,
+      "itll" => 1,
+      "just" => 1,
+      "last" => 1,
+      "least" => 1,
+      "like" => 1,
+      "most" => 1,
+      "my" => 1,
+      "new" => 1,
+      "no" => 1,
+      "not" => 1,
+      "now" => 1,
+      "of" => 1,
+      "on" => 1,
+      "or" => 1,
+      "should" => 1,
+      "sidebartitl" => 1,
+      "sinc" => 1,
+      "so" => 1,
+      "some" => 1,
+      "textdecoration" => 1,
+      "th" => 1,
+      "than" => 1,
+      "that" => 1,
+      "the" => 1,
+      "their" => 1,
+      "then" => 1,
+      "those" => 1,
+      "to" => 1,
+      "told" => 1,
+      "too" => 1,
+      "true" => 1,
+      "try" => 1,
+      "until" => 1,
+      "url" => 1,
+      "us" => 1,
+      "were" => 1,
+      "when" => 1,
+      "whether" => 1,
+      "while" => 1,
+      "with" => 1,
+      "within" => 1,
+      "yes" => 1,
+      "you" => 1,
+      "youll" => 1,
+      }
+    
+      attr_reader :total, :clsf, :words
+
+      def initialize
+        @total = 0
+        @clsf = {}
+        @words = {}
+      end
+    
+      def add_word(word, classifications = [], mod = 1)
+        word = Stemmable::stem_porter(word)
+        if STOP_WORDS[word]
+          nil
+        else
+          @words[word] ||= {:pos => @words.size, :clsf => {}}
+          classifications.each do |c|
+            @clsf[c] ||= {}
+            @clsf[c][word] ||= 0
+            @clsf[c][word] += mod
+            @total += mod
+          end
+          @words[word][:pos]
+        end
+      end
+    
+      def remove_word(word, classifications = [])
+        add_word(word, classifications, -1)
+      end
+
+      def find(word)
+        word = Stemmable::stem_porter(word)
+        if @words[word] and not STOP_WORDS[word]
+          @words[word][:pos]
+        end
+      end
+    
+      def size
+        @words.size
+      end
+    
+      def dump
+        puts @words.keys.sort
+      end
+
+    end
+  end
+end
+end