instiki 0.9.2

data/app/views/wiki/rollback.rhtml

@@ -0,0 +1,31 @@
+<% 
+  @title = "Rollback to #{@page.plain_name} Rev ##{@revision.number}"
+  @content_width = 720
+  @hide_navigation = true
+%><%= sub_template "top" %>
+
+<%= "<p style='color:red'>Please correct the error that caused this error in rendering:<br/><small>#{@params["msg"]}</small></p>" if @params["msg"] %>
+
+<form id="editForm" action="../save/<%= @page.name %>" method="post" onSubmit="cleanAuthorName();">
+<p>
+  <textarea name="content" style="font-size: 12px; width: 450px; height: 500px"><%= @revision.content %></textarea>
+</p>
+<p>
+    <input type="submit" value="Update"> as 
+    <input type="text" name="author" id="authorName" value="<%= @author %>" 
+        onClick="this.value == 'AnonymousCoward' ? this.value = '' : true">
+    | <a href="../cancel_edit/<%= @page.name %>">Cancel</a> <small>(unlocks page)</small>
+</p>
+</form>
+
+<%= render_markup_help %>
+
+<script language="JavaScript1.2">
+function cleanAuthorName() {
+  if (document.getElementById('authorName').value == "") {
+    document.getElementById('authorName').value = 'AnonymousCoward';
+  }
+}
+</script>
+
+<%= sub_template "bottom" %>

data/app/views/wiki/rss_feed.rhtml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/">
+	<channel>
+		<title><%= @web.name %></title>
+		<link><%= "#{@web_url}/show/HomePage" %></link>
+		<description>An Instiki wiki</description>
+		<language>en-us</language>
+		<ttl>40</ttl>
+  <% for page in @pages_by_revision %>
+		<item>
+      <title><%= page.plain_name %></title>
+    <% unless @hide_description %>
+      <description><%= CGI.escapeHTML(page.display_content) %></description>
+    <% end %>
+      <pubDate><%= page.created_at.strftime "%a, %e %b %Y %H:%M:%S %Z" %></pubDate>
+      <guid><%= "#{@web_url}/show/#{page.name}" %></guid>
+      <link><%= "#{@web_url}/show/#{page.name}" %></link>
+      <dc:creator><%= WikiWords.separate(page.author) %></dc:creator>
+    </item>
+  <% end %>
+  </channel>
+</rss>

data/app/views/wiki/search.rhtml

@@ -0,0 +1,15 @@
+<% @title = @results.length > 0 ? "#{@results.length} pages contains \"#{@params["query"]}\"" : "No pages contains \"#{@query}\"" %><%= sub_template "top" %>
+
+<% if @results.length > 0 %>
+  <ul>
+    <% for page in @results %>
+      <li><a href="../show/<%= page.name %>"><%= page.plain_name %></a></li>
+    <% end %>
+  </ul>
+<% else %>
+  <p>Perhaps you should try expanding your query. Remember that Instiki searches for entire phrases, so if you search for "all that jazz" it will not match pages that contain these words in separation&mdash;only as a sentence fragment.</p>
+
+  <p>If you're a high-tech computer wizard, you might even want try constructing a regular expression. That's actually what Instiki uses, so go right ahead and flex your "[a-z]*Leet?RegExpSkill(s|z)"</p>
+<% end %>
+
+<%= sub_template "bottom" %>

data/app/views/wiki/tex.rhtml

@@ -0,0 +1,23 @@
+\documentclass[12pt,titlepage]{article}
+
+\usepackage[danish]{babel}      %danske tekster
+\usepackage[OT1]{fontenc}       %rigtige danske bogstaver...
+\usepackage{a4}
+\usepackage{graphicx}
+\usepackage{ucs}
+\usepackage[utf8]{inputenc}
+\input epsf 
+
+%-------------------------------------------------------------------
+
+\begin{document}
+
+\sloppy
+
+%-------------------------------------------------------------------
+
+\section*{<%= @page.name %>}
+
+<%= @tex_content %>
+
+\end{document}

data/app/views/wiki/tex_web.rhtml

@@ -0,0 +1,35 @@
+\documentclass[12pt,titlepage]{article}
+
+\usepackage{fancyhdr}
+\pagestyle{fancy}
+
+\fancyhead[LE,RO]{}
+\fancyhead[LO,RE]{\nouppercase{\bfseries \leftmark}}
+\fancyfoot[C]{\thepage}
+
+\usepackage[danish]{babel}      %danske tekster
+\usepackage{a4}
+\usepackage{graphicx}
+\usepackage{ucs}
+\usepackage[utf8]{inputenc}
+\input epsf 
+
+
+%-------------------------------------------------------------------
+
+\title{<%= @web_name %>}
+
+\begin{document}
+
+\maketitle
+
+\tableofcontents
+\pagebreak
+
+\sloppy
+
+%-------------------------------------------------------------------
+
+<%= @tex_content %>
+
+\end{document}

data/app/views/wiki/web_list.rhtml

@@ -0,0 +1,13 @@
+<% @title = "Wiki webs" %><%= sub_template "top" %>
+
+<ul>
+<% for web in @webs %>
+  <li>
+    <a href="/<%= web.address %>/show/HomePage"><%= web.name %></a>
+    (<%= web.pages.length %> pages by <%= web.authors.length %> authors)
+    <% if web.published then %>(<a href="/<%= web.address %>/published/HomePage">published</a>)<% end %>
+  </li>
+<% end %>
+</ul>
+
+<%= sub_template "bottom" %>

data/app/views/wiki_words_help.rhtml

@@ -0,0 +1,8 @@
+<h3>Wiki words</h3>
+<p style="border-top: 1px dotted #ccc; margin-top: 0px">
+  Two or more uppercase words stuck together (camel case) or any phrase surrounded by doubble brackets is a wiki word. A camel-case wiki word can be escaped by putting \ in front of it.
+</p>
+<p>
+  Wiki words: <i>HomePage, ThreeWordsTogether, [[C++]], [[Let's play again!]]</i><br/>
+  Not wiki words: <i>IBM, School</i>
+</p>

data/instiki

@@ -0,0 +1,67 @@
+#!/usr/local/bin/ruby
+
+if RUBY_VERSION < "1.8.1" 
+  puts "Instiki requires Ruby 1.8.1+" 
+  exit
+end
+ 
+require 'optparse'
+require 'fileutils'
+
+cdir = File.expand_path(File.dirname(__FILE__))
+%w( /libraries/ /app/models /app/controllers ).each { |dir| $:.unshift(cdir + dir) }
+%w( web_controller_server action_controller_servlet wiki_service wiki ).each { |lib| require lib }
+
+fork_available = true
+begin
+  exit unless fork
+rescue NotImplementedError
+  fork_available = false
+end
+
+begin
+  pdflatex_available = system "pdflatex -version"
+rescue Errno::ENOENT
+  pdflatex_available = false
+end
+
+OPTIONS = {
+  :server_type => fork_available ? Daemon : SimpleServer,
+  :port        => 2500,
+  :storage     => "#{File.expand_path(FileUtils.pwd)}/storage",
+  :pdflatex    => pdflatex_available
+}
+
+ARGV.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = "Usage: ruby #{script_name} [options]"
+
+  opts.separator ""
+
+  opts.on("-p", "--port=port", Integer,
+          "Runs Instiki on the specified port.",
+          "Default: 2500") { |OPTIONS[:port]| }
+  opts.on("-s", "--simple", "--simple-server",
+          "Forces Instiki not to run as a Daemon if fork is available."
+          ) { OPTIONS[:server_type] = SimpleServer }
+  opts.on("-t", "--storage=storage", String,
+          "Makes Instiki use the specified directory for storage.",
+          "Default: ./storage/[port]") { |OPTIONS[:storage]| }
+
+  opts.separator ""
+
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+Socket.do_not_reverse_lookup = true
+
+storage_dir = OPTIONS[:storage] + "/" + OPTIONS[:port].to_s
+FileUtils.mkdir_p(storage_dir)
+WikiService.storage_path = storage_dir
+
+WikiController.template_root = "#{cdir}/app/views/"
+
+WebControllerServer.new(OPTIONS[:port], OPTIONS[:server_type], "#{cdir}/app/controllers/")

data/libraries/action_controller_servlet.rb

@@ -0,0 +1,177 @@
+require 'erb'
+require 'cgi'
+require 'webrick'
+include WEBrick
+
+require 'view_helper'
+
+class ActionControllerServlet < HTTPServlet::AbstractServlet
+  @@template_root = "./views"
+  def self.template_root() @@template_root end
+  def self.template_root=(template_root) @@template_root = template_root end
+
+  include ViewHelper
+  
+  def do_POST(req, res) do_GET(req, res) end 
+  
+  def do_GET(req, res)
+    @req, @res = req, res
+
+    @res['Content-Type']  = "text/html; charset=utf-8"
+    @res['Pragma']        = "no-cache"
+    @res['Cache-Control'] = "no-cache"
+
+    @params = @req.query
+    @assigns = {}
+    @performed_render = @performed_redirect = false
+
+    @logger.info "Performing #{action_name}"
+    @logger.info "  Parameters: #{@params.inspect}"
+    @logger.info "  Cookies: #{@req.cookies.collect { |c| "#{c.name} => #{c.value}" }.join(", ") }"
+
+    perform_action
+    @res
+  end
+  
+  protected
+    def template_root() self.class.template_root end
+
+    # Issues a HTTP 302 (location) redirect to the specified <tt>path</tt>. Query string
+    # parameters can be specified in the <tt>params</tt> hash and are automatically URL escaped.
+    # An <tt>anchor</tt> can also be specified (as a string).
+    def redirect_path(path, params = nil, anchor = nil)
+      path << build_query_string(params) unless params.nil?
+      path << "\##{anchor}" unless anchor.nil?
+      @res.set_redirect WEBrick::HTTPStatus::MovedPermanently, path
+      @performed_redirect = true
+    end
+
+    # Redirects the browser to another action within the current controller, so redirect_path "pages"
+    # within a controller called WikiController would take the user to "http://www.example.com/wiki/pages"
+    def redirect_action(action, params = nil, anchor = nil)
+      redirect_path "/#{controller_name}/#{action}", params, anchor
+    end
+
+    
+    # Compiles the template response and adds it to the response. If no template_name has been
+    # supplied, the action parameter parsed to the controller is used. So invoking
+    # render on a object initialized with myController.new("show_person") will compile the template
+    # located at "../views/show_person.rhtml". Notice that the ".rhtml" extension is postfixed
+    # to the template_name regardless of one was passed or that the action parameter was used.
+    def render(template_name = "#{controller_name}/#{action_name}")
+      @performed_render = true
+      @logger.info "Rendering: #{template_name}"
+      add_instance_variables_to_assigns
+      @res.body = template_result "#{template_root}/#{template_name}.rhtml"
+    end
+
+    def render_text(text)
+      @performed_render = true
+      @logger.info "Rendering in text"
+      @res.body = text
+    end
+
+    # Wrapper around render that presumes the current controller is used as a base for the action, 
+    # so render_action("page") in WikiController will be equal to render("wiki/page")
+    def render_action(action_name)
+      render "#{controller_name}/#{action_name}"
+    end
+
+    def sub_template(template_name)
+      template_result "#{template_root}/#{template_name}.rhtml"
+    end
+
+    # Returns the value of the cookie matching +name+ (or nil if none is found).
+    def read_cookie(key)
+      cookies = @req.cookies.select { |cookie| cookie.name == key }
+      cookies.empty? ? nil : cookies.first.value
+    end
+
+    def write_cookie(key, value, permanent = false)
+      @logger.info "Writing cookie: #{key} => #{value}"
+
+      cookie = WEBrick::Cookie.new(key, value)
+      cookie.path = "/"
+      cookie.expires = Time.local(2030) if permanent
+      @res.cookies << cookie
+    end
+
+
+    # Returns the last part of the uri path ("page" in "/wiki/page") by default, but
+    # can be overwritten to implement mod_rewrite-like behaviour, such as "page" in "/wiki/page/home"
+    def action_name
+      @req.path.to_s.split(/\//).last
+    end
+
+    # Returns an array with each of the parts in the request as an element. So /something/cool/dude
+    # returns ["something", "cool", "dude"]
+    def request_path
+      request_path_parts = @req.path.to_s.split(/\//)
+      request_path_parts.length > 1 ? request_path_parts[1..-1] : []
+    end
+
+    # Can be overwritten by a controller class to implement shared behaviour for all the actions in
+    # the class, such as security measures
+    def before_action() end
+
+
+  private
+    # Wraps around all action calls to ensure the session is properly updated and closed.
+    # Figures out whether an action, such as "list", is implemented as show_list or do_list.
+    # The show_* type has precedence and automatically calls render after execution.
+    def perform_action
+      if before_action == false then return end
+        
+      if action_methods.include?(action_name)
+        send(action_name)
+        render unless @performed_render || @performed_redirect || !@res.body.empty?
+      elsif template_exists_for_action
+        render
+      else
+        raise "No action responded to #{action_name}", caller
+      end
+    end
+
+    def add_instance_variables_to_assigns
+      instance_variables.each { |var|
+        next if protected_instance_variables.include?(var)
+        @assigns[var[1..-1]] = instance_variable_get(var)
+      }
+    end
+
+    def protected_instance_variables
+      [ "@assigns", "@performed_redirect", "@performed_render" ]
+    end
+
+    def action_methods
+      methods - Object.instance_methods
+    end
+  
+    # Returns true if a template exists in the controller directory for the specified <tt>action_name</tt>,
+    # which would mean true if called for WikiController#changes and "/views/wiki/changes.rhtml" existed.
+    def template_exists_for_action
+      File.exist? action_template_path
+    end
+  
+    def action_template_path(action = action_name)
+      "#{template_root}/#{controller_name}/#{action}.rhtml"
+    end
+  
+    def template_result(template_path)
+      @assigns.each { |key, value| instance_variable_set "@#{key}", value }
+      ERB.new(IO.readlines(template_path).join).result(binding)
+    end
+  
+    # Converts the class name from something like "OneModule::TwoModule::NeatController"
+    # to "neat".
+    def controller_name
+      self.class.to_s.split("::").last.sub(/Controller/, "").downcase
+    end
+
+    # Returns a query string with escaped keys and values from the passed hash.
+    def build_query_string(hash)
+      elements = []
+      hash.each { |key, value| elements << "#{CGI.escape(key)}=#{CGI.escape(value.to_s)}" }
+      "?" + elements.join("&")
+    end
+end

data/libraries/diff/diff.rb

@@ -0,0 +1,475 @@
+# heavily based off difflib.py - see that file for documentation
+# ported from Python by Bill Atkins
+
+# This does not support all features offered by difflib; it 
+# implements only the subset of features necessary
+# to support a Ruby version of HTML Differ.  You're welcome to finish this off.
+
+# By default, String#each iterates by line.  This isn't really appropriate
+# for diff, so often a string will be split by // to get an array of one-
+# character strings.
+
+# Some methods in Diff are untested and are not guaranteed to work.  The
+# methods in HTMLDiff and any methods it calls should work quite well.
+
+# changes by DenisMertz
+# * main change:
+# ** get the tag soup away
+#    the tag soup problem was first reported with <p> tags, but it appeared also with
+#    <li>, <ul> etc... tags 
+#   this version should mostly fix these problems
+# ** added a Builder class to manage the creation of the final htmldiff
+# * minor changes:
+# ** use symbols instead of string to represent opcodes 
+# ** small fix to html2list
+#
+
+module Enumerable
+  def reduce(init)
+    result = init
+    each { |item| result = yield(result, item) }
+    result
+  end
+end
+
+module Diff
+
+  class SequenceMatcher
+    def initialize(a=[''], b=[''], isjunk=nil, byline=false)
+      a = (!byline and a.kind_of? String) ? a.split(//) : a
+      b = (!byline and b.kind_of? String) ? b.split(//) : b
+      @isjunk = isjunk || proc {}
+      set_seqs a, b
+    end
+
+    def set_seqs(a, b)
+      set_seq_a a
+      set_seq_b b
+    end
+
+    def set_seq_a(a)
+      @a = a
+      @matching_blocks = @opcodes = nil
+    end
+
+    def set_seq_b(b)
+      @b = b
+      @matching_blocks = @opcodes = nil
+      chain_b
+    end
+
+    def chain_b
+      @fullbcount = nil
+      @b2j = {}
+      pophash = {}
+      junkdict = {}
+      
+      @b.each_with_index do |elt, i|
+        if @b2j.has_key? elt
+          indices = @b2j[elt]
+          if @b.length >= 200 and indices.length * 100 > @b.length
+            pophash[elt] = 1
+            indices.clear
+          else
+            indices.push i
+          end
+        else
+          @b2j[elt] = [i]
+        end
+      end
+        
+      pophash.each_key { |elt| @b2j.delete elt }
+      
+      junkdict = {}
+        
+      unless @isjunk.nil?
+        [pophash, @b2j].each do |d|
+          d.each_key do |elt|
+            if @isjunk.call(elt)
+              junkdict[elt] = 1
+              d.delete elt
+            end
+          end
+        end
+      end
+      
+      @isbjunk = junkdict.method(:has_key?)
+      @isbpopular = junkdict.method(:has_key?)
+    end
+    
+    def find_longest_match(alo, ahi, blo, bhi)
+      besti, bestj, bestsize = alo, blo, 0
+      
+      j2len = {}
+      
+      (alo..ahi).step do |i|
+        newj2len = {}
+        (@b2j[@a[i]] || []).each do |j|
+          if j < blo
+            next
+          end
+          if j >= bhi
+            break
+          end
+          
+          k = newj2len[j] = (j2len[j - 1] || 0) + 1
+          if k > bestsize
+            besti, bestj, bestsize = i - k + 1, j - k + 1, k
+          end
+        end
+        j2len = newj2len
+      end
+      
+      while besti > alo and bestj > blo and
+          not @isbjunk.call(@b[bestj-1]) and
+          @a[besti-1] == @b[bestj-1]
+        besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
+      end
+      
+      while besti+bestsize < ahi and bestj+bestsize < bhi and
+          not @isbjunk.call(@b[bestj+bestsize]) and
+          @a[besti+bestsize] == @b[bestj+bestsize]
+        bestsize += 1
+      end
+      
+      while besti > alo and bestj > blo and
+          @isbjunk.call(@b[bestj-1]) and
+          @a[besti-1] == @b[bestj-1]
+        besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
+      end
+      
+      while besti+bestsize < ahi and bestj+bestsize < bhi and
+          @isbjunk.call(@b[bestj+bestsize]) and
+          @a[besti+bestsize] == @b[bestj+bestsize]
+        bestsize += 1
+      end
+      
+      [besti, bestj, bestsize]
+    end
+    
+    def get_matching_blocks
+      return @matching_blocks unless @matching_blocks.nil? or 
+        @matching_blocks.empty?
+      
+      @matching_blocks = []
+      la, lb = @a.length, @b.length
+      match_block_helper(0, la, 0, lb, @matching_blocks)
+      @matching_blocks.push [la, lb, 0]
+    end
+    
+    def match_block_helper(alo, ahi, blo, bhi, answer)
+      i, j, k = x = find_longest_match(alo, ahi, blo, bhi)
+      if not k.zero?
+        if alo < i and blo < j
+          match_block_helper(alo, i, blo, j, answer)
+        end
+        answer.push x
+        if i + k < ahi and j + k < bhi
+          match_block_helper(i + k, ahi, j + k, bhi, answer)
+        end
+      end
+    end
+    
+    def get_opcodes
+      unless @opcodes.nil? or @opcodes.empty?
+        return @opcodes
+      end
+
+      i = j = 0
+      @opcodes = answer = []
+      get_matching_blocks.each do |ai, bj, size|
+        tag = if i < ai and j < bj
+                :replace
+              elsif i < ai
+                :delete
+              elsif j < bj 
+                :insert
+              end
+
+        answer.push [tag, i, ai, j, bj] if tag
+        
+        i, j = ai + size, bj + size
+        
+        answer.push [:equal, ai, i, bj, j] unless size.zero?
+        
+      end
+      return answer
+    end
+
+    # XXX: untested
+    def get_grouped_opcodes(n=3)
+      codes = get_opcodes
+      if codes[0][0] == :equal
+        tag, i1, i2, j1, j2 = codes[0]
+        codes[0] = tag, [i1, i2 - n].max, i2, [j1, j2-n].max, j2
+      end
+      
+      if codes[-1][0] == :equal
+        tag, i1, i2, j1, j2 = codes[-1]
+        codes[-1] = tag, i1, min(i2, i1+n), j1, min(j2, j1+n)
+      end
+      nn = n + n
+      group = []
+      codes.each do |tag, i1, i2, j1, j2|
+        if tag == :equal and i2-i1 > nn
+          group.push [tag, i1, [i2, i1 + n].min, j1, [j2, j1 + n].min]
+          yield group
+          group = []
+          i1, j1 = [i1, i2-n].max, [j1, j2-n].max
+          group.push [tag, i1, i2, j1 ,j2]
+        end
+      end
+      if group and group.length != 1 and group[0][0] == :equal
+        yield group
+      end
+    end
+
+    def ratio
+      matches = get_matching_blocks.reduce(0) do |sum, triple|
+        sum + triple[-1]
+      end
+      Diff.calculate_ratio(matches, @a.length + @b.length)
+    end
+
+    def quick_ratio
+      if @fullbcount.nil? or @fullbcount.empty?
+        @fullbcount = {}
+        @b.each do |elt|
+          @fullbcount[elt] = (@fullbcount[elt] || 0) + 1
+        end
+      end
+      
+      avail = {}
+      matches = 0
+      @a.each do |elt|
+        if avail.has_key? elt
+          numb = avail[elt]
+        else
+          numb = @fullbcount[elt] || 0
+        end
+        avail[elt] = numb - 1
+        if numb > 0
+          matches += 1
+        end
+      end
+      Diff.calculate_ratio matches, @a.length + @b.length
+    end
+
+    def real_quick_ratio
+      la, lb = @a.length, @b.length
+      Diff.calculate_ratio([la, lb].min, la + lb)
+    end
+
+    protected :chain_b, :match_block_helper
+  end # end class SequenceMatcher
+
+  def self.calculate_ratio(matches, length)
+    return 1.0 if length.zero?
+    2.0 * matches / length
+  end
+
+  # XXX: untested
+  def self.get_close_matches(word, possibilities, n=3, cutoff=0.6)
+    unless n > 0
+      raise "n must be > 0: #{n}"
+    end
+    unless 0.0 <= cutoff and cutoff <= 1.0
+      raise "cutoff must be in (0.0..1.0): #{cutoff}"
+    end
+
+    result = []
+    s = SequenceMatcher.new
+    s.set_seq_b word
+    possibilities.each do |x|
+      s.set_seq_a x
+      if s.real_quick_ratio >= cutoff and
+          s.quick_ratio >= cutoff and
+          s.ratio >= cutoff
+        result.push [s.ratio, x]
+      end
+    end
+    
+    unless result.nil? or result.empty?
+      result.sort
+      result.reverse!
+      result = result[-n..-1]
+    end
+    result.collect { |score, x| x }
+  end
+
+  def self.count_leading(line, ch)
+    i, n = 0, line.length
+    while i < n and line[i].chr == ch
+      i += 1
+    end
+    i
+  end
+end
+
+
+module HTMLDiff
+  include Diff
+  class Builder
+    VALID_METHODS = [:replace, :insert, :delete, :equal]
+    def initialize(a, b)
+      @a = a
+      @b = b
+      @content = []
+    end
+
+    def do_op(opcode)
+      @opcode = opcode
+      op = @opcode[0]
+      VALID_METHODS.include?(op) or raise(NameError, "Invalid opcode #{op}")
+      self.method(op).call
+    end
+
+    def result
+      @content.join('')
+    end
+
+    #this methods have to be called via do_op(opcode) so that @opcode is set properly
+    private
+
+    def replace
+      delete("diffmod")
+      insert("diffmod")
+    end
+    
+    def insert(tagclass="diffins")
+      op_helper("ins", tagclass, @b[@opcode[3]...@opcode[4]])
+    end
+    
+    def delete(tagclass="diffdel")
+       op_helper("del", tagclass, @a[@opcode[1]...@opcode[2]])
+    end
+    
+    def equal
+      @content += @b[@opcode[3]...@opcode[4]]
+    end
+  
+    # using this as op_helper would be equivalent to the first version of diff.rb by Bill Atkins
+    def op_helper_simple(tagname, tagclass, to_add)
+      @content << "<#{tagname} class=\"#{tagclass}\">" 
+      @content += to_add
+      @content << "</#{tagname}>"
+    end
+    
+    # this tries to put <p> tags or newline chars before the opening diff tags (<ins> or <del>)
+    # or after the ending diff tags
+    # as a result the diff tags should be the "more inside" possible.
+    # this seems to work nice with html containing only paragraphs
+    # but not sure it works if there are other tags (div, span ... ? ) around
+    def op_helper(tagname, tagclass, to_add)
+      @content << to_add.shift while ( HTMLDiff.is_newline(to_add.first) or 
+                                         HTMLDiff.is_p_close_tag(to_add.first) or
+                                         HTMLDiff.is_p_open_tag(to_add.first) )
+      @content << "<#{tagname} class=\"#{tagclass}\">" 
+      @content += to_add
+      last_tags = []
+      last_tags.unshift(@content.pop) while ( HTMLDiff.is_newline(@content.last) or 
+                                         HTMLDiff.is_p_close_tag(@content.last) or
+                                         HTMLDiff.is_p_open_tag(@content.last) )
+      last_tags.unshift "</#{tagname}>"
+      @content += last_tags
+      remove_empty_diff(tagname, tagclass)
+    end
+
+    def remove_empty_diff(tagname, tagclass)
+      if @content[-2] == "<#{tagname} class=\"#{tagclass}\">" and @content[-1] == "</#{tagname}>" then
+        @content.pop
+        @content.pop
+      end
+    end
+
+  end
+  
+  def self.is_newline(x)
+    (x == "\n") or (x == "\r") or (x == "\t")
+  end
+
+  def self.is_p_open_tag(x)
+    x =~ /\A<(p|li|ul|ol|dir|dt|dl)/
+  end
+
+  def self.is_p_close_tag(x)
+    x =~ %r!\A</(p|li|ul|ol|dir|dt|dl)!
+  end
+
+  def self.diff(a, b)
+    a, b = a.split(//), b.split(//) if a.kind_of? String and b.kind_of? String
+    a, b = html2list(a), html2list(b)
+
+    out = Builder.new(a, b)
+    s = SequenceMatcher.new(a, b)
+
+    s.get_opcodes.each do |opcode|
+      out.do_op(opcode)
+    end
+
+    out.result 
+  end
+  
+  def self.html2list(x, b=false)
+    mode = 'char'
+    cur = ''
+    out = []
+    
+    x = x.split(//) if x.kind_of? String
+    
+    x.each do |c|
+      if mode == 'tag'
+        if c == '>'
+          if b
+            cur += ']'
+          else
+            cur += c
+          end
+          out.push(cur)
+          cur = ''
+          mode = 'char'
+        else
+          cur += c
+        end
+      elsif mode == 'char'
+        if c == '<'
+          out.push cur
+          if b
+            cur = '['
+          else
+            cur = c
+          end
+          mode = 'tag'
+        elsif /\s/.match c
+          out.push cur + c
+          cur = ''
+        else
+          cur += c
+        end
+      end
+    end
+    
+    out.push cur
+    # TODO: make something better here
+    out.each{|x| x.chomp! unless is_newline(x)}
+    out.find_all { |x| x != '' }
+  end
+  
+  
+end
+
+if __FILE__ == $0
+
+  require 'pp'
+  # a = "<p>this is the original string</p>" # \n<p>but around the world</p>"
+  # b = "<p>this is the original </p><p>other parag</p><p>string</p>"
+  a = "<ul>\n\t<li>one</li>\n\t<li>two</li>\n</ul>"
+  b = "<ul>\n\t<li>one</li>\n\t<li>two\n\t<ul><li>abc</li></ul></li>\n</ul>"
+  puts a
+  pp HTMLDiff.html2list(a)
+  puts
+  puts b
+  pp HTMLDiff.html2list(b)
+ puts
+  puts HTMLDiff.diff(a, b)
+end