hobix 0.4

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

data/lib/hobix/search/porter_stemmer.rb

@@ -0,0 +1,203 @@
+#! /local/ruby/bin/ruby
+#
+# $Id$
+#
+# Lifted from SimpleSearch by Chad Fowler / Dave Thomas / Allen Condit / perhaps other unseeable folks in the distance ...
+#
+# See example usage at the end of this file.
+#
+
+module Hobix
+module Stemmable
+
+  STEMMED = {}
+
+  STEP_2_LIST = {
+    'ational'=>'ate', 'tional'=>'tion', 'enci'=>'ence', 'anci'=>'ance',
+    'izer'=>'ize', 'bli'=>'ble',
+    'alli'=>'al', 'entli'=>'ent', 'eli'=>'e', 'ousli'=>'ous',
+    'ization'=>'ize', 'ation'=>'ate',
+    'ator'=>'ate', 'alism'=>'al', 'iveness'=>'ive', 'fulness'=>'ful',
+    'ousness'=>'ous', 'aliti'=>'al',
+    'iviti'=>'ive', 'biliti'=>'ble', 'logi'=>'log'
+  }
+  
+  STEP_3_LIST = {
+    'icate'=>'ic', 'ative'=>'', 'alize'=>'al', 'iciti'=>'ic',
+    'ical'=>'ic', 'ful'=>'', 'ness'=>''
+  }
+
+
+  SUFFIX_1_REGEXP = /(
+                    ational  |
+                    tional   |
+                    enci     |
+                    anci     |
+                    izer     |
+                    bli      |
+                    alli     |
+                    entli    |
+                    eli      |
+                    ousli    |
+                    ization  |
+                    ation    |
+                    ator     |
+                    alism    |
+                    iveness  |
+                    fulness  |
+                    ousness  |
+                    aliti    |
+                    iviti    |
+                    biliti   |
+                    logi)$/x
+
+
+  SUFFIX_2_REGEXP = /(
+                      al       |
+                      ance     |
+                      ence     |
+                      er       |
+                      ic       | 
+                      able     |
+                      ible     |
+                      ant      |
+                      ement    |
+                      ment     |
+                      ent      |
+                      ou       |
+                      ism      |
+                      ate      |
+                      iti      |
+                      ous      |
+                      ive      |
+                      ize)$/x
+
+
+  C = "[^aeiou]"         # consonant
+  V = "[aeiouy]"         # vowel
+  CC = "#{C}(?>[^aeiouy]*)"  # consonant sequence
+  VV = "#{V}(?>[aeiou]*)"    # vowel sequence
+
+  MGR0 = /^(#{CC})?#{VV}#{CC}/o                # [cc]vvcc... is m>0
+  MEQ1 = /^(#{CC})?#{VV}#{CC}(#{VV})?$/o       # [cc]vvcc[vv] is m=1
+  MGR1 = /^(#{CC})?#{VV}#{CC}#{VV}#{CC}/o      # [cc]vvccvvcc... is m>1
+  VOWEL_IN_STEM   = /^(#{CC})?#{V}/o                      # vowel in stem
+
+  #
+  # Porter stemmer in Ruby.
+  #
+  # This is the Porter stemming algorithm, ported to Ruby from the
+  # version coded up in Perl.  It's easy to follow against the rules
+  # in the original paper in:
+  #
+  #   Porter, 1980, An algorithm for suffix stripping, Program, Vol. 14,
+  #   no. 3, pp 130-137,
+  #
+  # See also http://www.tartarus.org/~martin/PorterStemmer
+  #
+  # Send comments to raypereda@hotmail.com
+  #
+  
+  def stem_porter(w = self.to_str.dup)
+
+    # make a copy of the given object and convert it to a string.
+    original_word = w
+    
+    return w if w.length < 3
+
+    result = STEMMED[w]
+    return result if result
+
+    # now map initial y to Y so that the patterns never treat it as vowel
+    w[0] = 'Y' if w[0] == ?y
+    
+    # Step 1a
+    if w =~ /(ss|i)es$/
+      w = $` + $1
+    elsif w =~ /([^s])s$/ 
+      w = $` + $1
+    end
+
+    # Step 1b
+    if w =~ /eed$/
+      w.chop! if $` =~ MGR0 
+    elsif w =~ /(ed|ing)$/
+      stem = $`
+      if stem =~ VOWEL_IN_STEM 
+        w = stem
+	case w
+        when /(at|bl|iz)$/             then w << "e"
+        when /([^aeiouylsz])\1$/       then w.chop!
+        when /^#{CC}#{V}[^aeiouwxy]$/o then w << "e"
+        end
+      end
+    end
+
+    if w =~ /y$/ 
+      stem = $`
+      w = stem + "i" if stem =~ VOWEL_IN_STEM 
+    end
+
+    # Step 2
+    if w =~ SUFFIX_1_REGEXP
+      stem = $`
+      suffix = $1
+      # print "stem= " + stem + "\n" + "suffix=" + suffix + "\n"
+      if stem =~ MGR0
+        w = stem + STEP_2_LIST[suffix]
+      end
+    end
+
+    # Step 3
+    if w =~ /(icate|ative|alize|iciti|ical|ful|ness)$/
+      stem = $`
+      suffix = $1
+      if stem =~ MGR0
+        w = stem + STEP_3_LIST[suffix]
+      end
+    end
+
+    # Step 4
+    if w =~ SUFFIX_2_REGEXP
+      stem = $`
+      if stem =~ MGR1
+        w = stem
+      end
+    elsif w =~ /(s|t)(ion)$/
+      stem = $` + $1
+      if stem =~ MGR1
+        w = stem
+      end
+    end
+
+    #  Step 5
+    if w =~ /e$/ 
+      stem = $`
+      if (stem =~ MGR1) ||
+          (stem =~ MEQ1 && stem !~ /^#{CC}#{V}[^aeiouwxy]$/o)
+        w = stem
+      end
+    end
+
+    if w =~ /ll$/ && w =~ MGR1
+      w.chop!
+    end
+
+    # and turn initial Y back to y
+    w[0] = 'y' if w[0] == ?Y
+
+    STEMMED[original_word] = w
+
+    w
+  end
+
+
+  module_function :stem_porter
+  #
+  # make the stem_porter the default stem method, just in case we
+  # feel like having multiple stemmers available later.
+  #
+  alias stem stem_porter
+
+end
+end