junebug 0.0.3

data/lib/junebug/diff.rb

@@ -0,0 +1,317 @@
+module HTMLDiff
+
+  Match = Struct.new(:start_in_old, :start_in_new, :size)
+  class Match
+    def end_in_old
+      self.start_in_old + self.size
+    end
+    
+    def end_in_new
+      self.start_in_new + self.size
+    end
+  end
+  
+  Operation = Struct.new(:action, :start_in_old, :end_in_old, :start_in_new, :end_in_new)
+
+  class DiffBuilder
+
+    def initialize(old_version, new_version)
+      @old_version, @new_version = old_version, new_version
+      @content = []
+    end
+
+    def build
+      split_inputs_to_words
+      index_new_words
+      operations.each { |op| perform_operation(op) }
+      return @content.join
+    end
+
+    def split_inputs_to_words
+      @old_words = convert_html_to_list_of_words(explode(@old_version))
+      @new_words = convert_html_to_list_of_words(explode(@new_version))
+    end
+
+    def index_new_words
+      @word_indices = Hash.new { |h, word| h[word] = [] }
+      @new_words.each_with_index { |word, i| @word_indices[word] << i }
+    end
+
+    def operations
+      position_in_old = position_in_new = 0
+      operations = []
+      
+      matches = matching_blocks
+      # an empty match at the end forces the loop below to handle the unmatched tails
+      # I'm sure it can be done more gracefully, but not at 23:52
+      matches << Match.new(@old_words.length, @new_words.length, 0)
+      
+      matches.each_with_index do |match, i|
+        match_starts_at_current_position_in_old = (position_in_old == match.start_in_old)
+        match_starts_at_current_position_in_new = (position_in_new == match.start_in_new)
+        
+        action_upto_match_positions = 
+          case [match_starts_at_current_position_in_old, match_starts_at_current_position_in_new]
+          when [false, false]
+            :replace
+          when [true, false]
+            :insert
+          when [false, true]
+            :delete
+          else
+            # this happens if the first few words are same in both versions
+            :none
+          end
+
+        if action_upto_match_positions != :none
+          operation_upto_match_positions = 
+              Operation.new(action_upto_match_positions, 
+                  position_in_old, match.start_in_old, 
+                  position_in_new, match.start_in_new)
+          operations << operation_upto_match_positions
+        end
+        if match.size != 0
+          match_operation = Operation.new(:equal, 
+              match.start_in_old, match.end_in_old, 
+              match.start_in_new, match.end_in_new)
+          operations << match_operation
+        end
+
+        position_in_old = match.end_in_old
+        position_in_new = match.end_in_new
+      end
+      
+      operations
+    end
+
+    def matching_blocks
+      matching_blocks = []
+      recursively_find_matching_blocks(0, @old_words.size, 0, @new_words.size, matching_blocks)
+      matching_blocks
+    end
+
+    def recursively_find_matching_blocks(start_in_old, end_in_old, start_in_new, end_in_new, matching_blocks)
+      match = find_match(start_in_old, end_in_old, start_in_new, end_in_new)
+      if match
+        if start_in_old < match.start_in_old and start_in_new < match.start_in_new
+          recursively_find_matching_blocks(
+              start_in_old, match.start_in_old, start_in_new, match.start_in_new, matching_blocks) 
+        end
+        matching_blocks << match
+        if match.end_in_old < end_in_old and match.end_in_new < end_in_new
+          recursively_find_matching_blocks(
+              match.end_in_old, end_in_old, match.end_in_new, end_in_new, matching_blocks)
+        end
+      end
+    end
+
+    def find_match(start_in_old, end_in_old, start_in_new, end_in_new)
+
+      best_match_in_old = start_in_old
+      best_match_in_new = start_in_new
+      best_match_size = 0
+      
+      match_length_at = Hash.new { |h, index| h[index] = 0 }
+      
+      start_in_old.upto(end_in_old - 1) do |index_in_old|
+
+        new_match_length_at = Hash.new { |h, index| h[index] = 0 }
+
+        @word_indices[@old_words[index_in_old]].each do |index_in_new|
+          next  if index_in_new < start_in_new
+          break if index_in_new >= end_in_new
+
+          new_match_length = match_length_at[index_in_new - 1] + 1
+          new_match_length_at[index_in_new] = new_match_length
+
+          if new_match_length > best_match_size
+            best_match_in_old = index_in_old - new_match_length + 1
+            best_match_in_new = index_in_new - new_match_length + 1
+            best_match_size = new_match_length
+          end
+        end
+        match_length_at = new_match_length_at
+      end
+
+#      best_match_in_old, best_match_in_new, best_match_size = add_matching_words_left(
+#          best_match_in_old, best_match_in_new, best_match_size, start_in_old, start_in_new)
+#      best_match_in_old, best_match_in_new, match_size = add_matching_words_right(
+#          best_match_in_old, best_match_in_new, best_match_size, end_in_old, end_in_new)
+
+      return (best_match_size != 0 ? Match.new(best_match_in_old, best_match_in_new, best_match_size) : nil)
+    end
+
+    def add_matching_words_left(match_in_old, match_in_new, match_size, start_in_old, start_in_new)
+      while match_in_old > start_in_old and 
+            match_in_new > start_in_new and 
+            @old_words[match_in_old - 1] == @new_words[match_in_new - 1]
+        match_in_old -= 1
+        match_in_new -= 1
+        match_size += 1
+      end
+      [match_in_old, match_in_new, match_size]
+    end
+
+    def add_matching_words_right(match_in_old, match_in_new, match_size, end_in_old, end_in_new)
+      while match_in_old + match_size < end_in_old and 
+            match_in_new + match_size < end_in_new and
+            @old_words[match_in_old + match_size] == @new_words[match_in_new + match_size]
+        match_size += 1
+      end
+      [match_in_old, match_in_new, match_size]
+    end
+    
+    VALID_METHODS = [:replace, :insert, :delete, :equal]
+
+    def perform_operation(operation)
+      @operation = operation
+      self.send operation.action, operation
+    end
+
+    def replace(operation)
+      delete(operation, 'diffmod')
+      insert(operation, 'diffmod')
+    end
+    
+    def insert(operation, tagclass = 'diffins')
+      insert_tag('ins', tagclass, @new_words[operation.start_in_new...operation.end_in_new])
+    end
+    
+    def delete(operation, tagclass = 'diffdel')
+       insert_tag('del', tagclass, @old_words[operation.start_in_old...operation.end_in_old])
+    end
+    
+    def equal(operation)
+      # no tags to insert, simply copy the matching words from one of the versions
+      @content += @new_words[operation.start_in_new...operation.end_in_new]
+    end
+  
+    def opening_tag?(item)
+      item =~ %r!^\s*<[^>]+>\s*$!
+    end
+
+    def closing_tag?(item)
+      item =~ %r!^\s*</[^>]+>\s*$!
+    end
+
+    def tag?(item)
+      opening_tag?(item) or closing_tag?(item)
+    end
+
+    def extract_consecutive_words(words, &condition)
+      index_of_first_tag = nil
+      words.each_with_index do |word, i| 
+        if !condition.call(word)
+          index_of_first_tag = i
+          break
+        end
+      end
+      if index_of_first_tag
+        return words.slice!(0...index_of_first_tag)
+      else
+        return words.slice!(0..words.length)
+      end
+    end
+
+    # This method encloses words within a specified tag (ins or del), and adds this into @content, 
+    # with a twist: if there are words contain tags, it actually creates multiple ins or del, 
+    # so that they don't include any ins or del. This handles cases like
+    # old: '<p>a</p>'
+    # new: '<p>ab</p><p>c</b>'
+    # diff result: '<p>a<ins>b</ins></p><p><ins>c</ins></p>'
+    # this still doesn't guarantee valid HTML (hint: think about diffing a text containing ins or
+    # del tags), but handles correctly more cases than the earlier version.
+    # 
+    # P.S.: Spare a thought for people who write HTML browsers. They live in this ... every day.
+
+    def insert_tag(tagname, cssclass, words)
+      loop do
+        break if words.empty?
+        non_tags = extract_consecutive_words(words) { |word| not tag?(word) }
+        @content << wrap_text(non_tags.join, tagname, cssclass) unless non_tags.empty?
+
+        break if words.empty?
+        @content += extract_consecutive_words(words) { |word| tag?(word) }
+      end
+    end
+
+    def wrap_text(text, tagname, cssclass)
+      %(<#{tagname} class="#{cssclass}">#{text}</#{tagname}>)
+    end
+
+    def explode(sequence)
+      sequence.is_a?(String) ? sequence.split(//) : sequence
+    end
+  
+    def end_of_tag?(char)
+      char == '>'
+    end
+  
+    def start_of_tag?(char)
+      char == '<'
+    end
+    
+    def whitespace?(char)
+      char =~ /\s/
+    end
+  
+    def convert_html_to_list_of_words(x, use_brackets = false)
+      mode = :char
+      current_word  = ''
+      words = []
+      
+      explode(x).each do |char|
+        case mode
+        when :tag
+          if end_of_tag? char
+            current_word << (use_brackets ? ']' : '>')
+            words << current_word
+            current_word = ''
+            if whitespace?(char) 
+              mode = :whitespace 
+            else
+              mode = :char
+            end
+          else
+            current_word << char
+          end
+        when :char
+          if start_of_tag? char
+            words << current_word unless current_word.empty?
+            current_word = (use_brackets ? '[' : '<')
+            mode = :tag
+          elsif /\s/.match char
+            words << current_word unless current_word.empty?
+            current_word = char
+            mode = :whitespace
+          else
+            current_word << char
+          end
+        when :whitespace
+          if start_of_tag? char
+            words << current_word unless current_word.empty?
+            current_word = (use_brackets ? '[' : '<')
+            mode = :tag
+          elsif /\s/.match char
+            current_word << char
+          else
+            words << current_word unless current_word.empty?
+            current_word = char
+            mode = :char
+          end
+        else 
+          raise "Unknown mode #{mode.inspect}"
+        end
+      end
+      words << current_word unless current_word.empty?
+      words
+    end
+
+  end # of class Diff Builder
+  
+  def diff(a, b)
+    DiffBuilder.new(a, b).build
+  end
+
+end
+

data/lib/junebug/generator.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+
+module Junebug
+  module Generator
+    extend self
+  
+    def generate(args)
+      src_root = File.dirname(__FILE__) + '/../../deploy'
+      app = ARGV.first
+      FileUtils.cp_r(src_root, app)
+      FileUtils.chmod(0755, app+'/wiki')
+    end
+    
+  end
+end

data/lib/junebug/helpers.rb

@@ -0,0 +1,18 @@
+
+module Junebug::Helpers
+  def last_updated(page)
+    from = page.updated_at.to_i
+    to = Time.now.to_i
+    from = from.to_time if from.respond_to?(:to_time)
+    to = to.to_time if to.respond_to?(:to_time)
+    distance = (((to - from).abs)/60).round
+    case distance
+      when 0..1      : return (distance==0) ? 'less than a minute' : '1 minute'
+      when 2..45     : "#{distance} minutes"
+      when 46..90    : 'about 1 hour'
+      when 90..1440  : "about #{(distance.to_f / 60.0).round} hours"
+      when 1441..2880: '1 day'
+      else             "#{(distance / 1440).round} days"
+    end
+  end
+end

data/lib/junebug/models.rb

@@ -0,0 +1,62 @@
+require 'active_record'
+require 'acts_as_versioned'
+
+module Junebug::Models
+
+  class User < Base
+    validates_length_of :username, :within=>3..30
+    validates_length_of :password, :within=>5..30
+    has_many :pages
+  end
+
+  class Page < Base
+    belongs_to :user
+    #PAGE_LINK = /\[\[([^\]|]*)[|]?([^\]]*)\]\]/
+    #before_save { |r| r.title = r.title.underscore }
+    PAGE_LINK = /([A-Z][a-z]+[A-Z]\w+)/
+    validates_uniqueness_of :title
+    validates_format_of :title, :with => PAGE_LINK
+    validates_presence_of :title
+    acts_as_versioned
+    non_versioned_fields.push 'title'
+  end
+  
+  class Page::Version < Base
+    belongs_to :user
+  end
+
+  class CreateJunebug < V 1.0
+    def self.up
+      create_table :junebug_users do |t|
+        t.column :id,       :integer, :null => false
+        t.column :username, :string
+        t.column :password, :string
+      end
+      create_table :junebug_pages do |t|
+        t.column :title, :string, :limit => 255
+        t.column :body, :text
+        t.column :user_id, :integer, :null => false
+        t.column :readonly, :boolean
+        t.column :created_at, :datetime
+        t.column :updated_at, :datetime
+      end
+      Page.create_versioned_table
+      Page.reset_column_information
+      
+      # Create admin account
+      admin = User.create :username => 'admin', :password => 'password'
+      
+      # Install some default pages
+      pages_file = File.dirname(__FILE__) + "/../../fixtures/junebug_pages.yml"
+      #puts pages_file
+      #pages_file = '../fixtures/junebug_pages.yml'
+      YAML.load_file(pages_file).each {|page_data|Page.create(page_data) } if File.exist?(pages_file)
+    end
+    def self.down
+      drop_table :junebug_pages
+      drop_table :junebug_users
+      Page.drop_versioned_table
+    end
+  end
+
+end

data/lib/junebug/views.rb

@@ -0,0 +1,289 @@
+require 'redcloth'
+
+module Junebug::Views
+  def layout
+    html {
+      head {
+        title @page_title ? @page_title : @page.title
+        link :href=>'/static/yui/reset.css', :type=>'text/css', :rel=>'stylesheet'
+        link :href=>'/static/yui/fonts.css', :type=>'text/css', :rel=>'stylesheet'
+        link :href=>'/static/yui/grids.css', :type=>'text/css', :rel=>'stylesheet'
+        link :href=>'/static/base.css',      :type=>'text/css', :rel=>'stylesheet'
+      }
+      body {
+        div :id=>'doc', :class=>'yui-t7' do
+          self << yield
+        end
+      }
+    }
+  end
+
+  def show
+    _header (@version.version == @page.version ? :show : :backlinks), @page.title
+    _body {
+      div.content {
+        _button 'Edit page', {:href => R(Edit, @page.title, @version.version), :style=>'float: right; margin: 0 0 5px 5px;'} if @version.version == @page.version
+        _markup @version.body
+      }
+    }
+    _footer {
+      text "Last edited by <b>#{@version.user.username}</b> on #{@page.updated_at.strftime('%B %d, %Y %I:%M %p')}"
+      if @version.version > 1
+        text " ("
+        a 'diff', :href => R(Diff,@page.title,@version.version-1,@version.version)
+        text ")"
+      end
+      br
+      span.actions {
+        text "Version #{@version.version} "
+        text "(current) " if @version.version == @page.version
+        #text 'Other versions: '
+        a '«older', :href => R(Show, @page.title, @version.version-1) unless @version.version == 1
+        a 'newer»', :href => R(Show, @page.title, @version.version+1) unless @version.version == @page.version
+        a 'current', :href => R(Show, @page.title) unless @version.version == @page.version
+        a 'show all', :href => R(Versions, @page.title)
+      }
+    }
+  end
+
+  def edit
+    _header :backlinks, @page.title
+    _body {
+        h1 @page_title
+        div.formbox {
+          form :method => 'post', :action => R(Edit, @page.title) do
+            p { 
+              label 'Page Title'
+              br
+              input :value => @page.title, :name => 'post_title', :size => 30, 
+                    :type => 'text'
+              small " [ CamelCase only ]"
+            }
+            p {
+              label 'Page Content'
+              br
+              textarea @page.body, :name => 'post_body', :rows => 20, :cols => 80
+            }
+            input :type => 'submit', :value=>'save'
+          end
+          _button 'cancel', :href => R(Show, @page.title, @page.version); text '&nbsp;'
+          a 'syntax help', :href => 'http://hobix.com/textile/', :target=>'_blank'
+          br :clear=>'all'
+        }
+    }
+    _footer { '' }
+  end
+
+  def versions
+    _header :backlinks, @page.title
+    _body {
+      h1 @page_title
+      ul {
+        @versions.each_with_index do |page,i|
+          li {
+            a "version #{page.version}", :href => R(Show, @page.title, page.version)
+            if page.version > 1
+              text ' ('
+              a 'diff', :href => R(Diff, @page.title, page.version-1, page.version)
+              text ')'
+            end
+            text' - created '
+            text last_updated(page)
+            text ' ago by '
+            strong page.user.username
+            text ' (current)' if i == 0
+          }
+        end
+      }
+    }
+    _footer { '' }
+  end
+
+  def backlinks
+    _header :static, @page.title
+    _body {
+      h1 "Backlinks to #{@page.title}"
+      ul {
+        @pages.each { |p| li{ a p.title, :href => R(Show, p.title) } }
+      }
+    }
+    _footer { '' }
+  end
+
+  def list
+    _header :backlinks, Junebug.config['startpage']
+    _body {
+      h1 "All Wiki Pages"
+      ul {
+        @pages.each { |p| li{ a p.title, :href => R(Show, p.title) } }
+      }
+    }
+    _footer { '' }
+  end
+
+
+  def recent
+    _header :static, @page_title
+    _body {
+      h1 "Updates in the last 30 days"
+      page = @pages.shift 
+      while page
+        yday = page.updated_at.yday
+        h2 page.updated_at.strftime('%B %d, %Y')
+        ul {
+          loop do
+            li {
+              a page.title, :href => R(Show, page.title)
+              text ' ('
+              a 'versions', :href => R(Versions, page.title)
+              text ') '
+              span page.updated_at.strftime('%I:%M %p')
+            }
+            page = @pages.shift
+            break unless page && (page.updated_at.yday == yday)
+          end
+        }
+      end
+    }
+    _footer { '' }
+  end
+  
+  def diff
+    _header :backlinks, @page.title
+    _body {
+      text 'Comparing '
+      span "version #{@v2.version}", :style=>"background-color: #cfc; padding: 1px 4px;"
+      text ' and '
+      span "version #{@v1.version}", :style=>"background-color: #ddd; padding: 1px 4px;"
+      text ' '
+      a "back", :href => R(Show, @page.title)
+      br
+      br
+      div.diff {
+        text @difftext
+      }
+    }
+    _footer { '' }
+  end
+  
+  def login
+    div.login {
+      h1 @page_title
+      p.notice { @notice } if @notice
+      form :action => R(Login), :method => 'post' do
+        label 'Username', :for => 'username'; br
+        input :name => 'username', :type => 'text', :value=>( @user ? @user.username : '') ; br
+
+        label 'Password', :for => 'password'; br
+        input :name => 'password', :type => 'password'; br
+
+        input :type => 'submit', :name => 'login', :value => 'Login'
+      end
+    }
+  end
+
+  def _button(text, options={})
+    form :method=>:get, :action=>options[:href] do
+      input.button :type=>'submit', :name=>'submit', :value=>text, :style=>options[:style]
+    end
+  end
+
+  def _markup txt
+    return '' if txt.blank?
+    txt.gsub!(Junebug::Models::Page::PAGE_LINK) do
+      page = title = $1
+#      title = $2 unless $2.empty?
+#      page = page.gsub /\W/, '_'
+      if Junebug::Models::Page.find(:all, :select => 'title').collect { |p| p.title }.include?(page)
+        %Q{<a href="#{self/R(Show, page)}">#{title}</a>}
+      else
+        %Q{<span>#{title}<a href="#{self/R(Edit, page, 1)}">?</a></span>}
+      end
+    end
+    text RedCloth.new(txt, [ ]).to_html
+  end
+
+  def _header type, page_title
+    div :id=>'hd' do
+      span :id=>'userlinks', :style=>'float: right;' do
+        @state.user_id.blank? ? a('login', :href=>R(Login)) : (text "#{@state.user_username} - " ; a('logout', :href=>R(Logout)))
+      end
+      if type == :static
+        h1 page_title
+      elsif type == :show
+        h1 { a page_title, :href => R(Backlinks, page_title) }
+      else
+        h1 { a page_title, :href => R(Show, page_title) }
+      end
+      span {
+        a 'Home',  :href => R(Show, Junebug.config['startpage'])
+        text ' | '
+        a 'RecentChanges', :href => R(Recent)
+        text ' | '
+        a 'All Pages', :href => R(List)
+        text ' | '
+        a 'Help', :href => R(Show, "JunebugHelp") 
+      }
+    end
+  end
+
+  def _body
+    div.content {
+      div :id=>'bd' do
+        div :id=>'yui-main' do
+          div :class=>'yui-b' do
+            yield
+          end
+        end
+      end
+    }
+  end
+
+  def _footer
+    div :id=>'ft' do
+      span :style=>'float: right;' do
+        text 'Powered by '
+        a 'JunebugWiki', :href => 'http://www.junebugwiki.com/'
+      end
+      yield
+      br :clear=>'all'
+    end
+    text <<END
+<p>
+  <a href="http://validator.w3.org/check?uri=referer"><img
+      src="http://www.w3.org/Icons/valid-xhtml10"
+      alt="Valid XHTML 1.0 Transitional" height="31" width="88" /></a>
+</p>
+END
+  end
+
+  def self.feed
+    xml = Builder::XmlMarkup.new(:indent => 2)
+
+    xml.instruct!
+    xml.feed "xmlns"=>"http://www.w3.org/2005/Atom" do
+
+      xml.title "Recently Updated Wiki Pages"
+      xml.id Junebug.config['url'] + '/'
+      xml.link "rel" => "self", "href" => Junebug.config['feed']
+
+      pages = Junebug::Models::Page.find(:all, :order => 'updated_at DESC', :limit => 20)
+      xml.updated pages.first.updated_at.xmlschema
+
+      pages.each do |page|
+        xml.entry do
+          xml.id Junebug.config['url'] + '/s/' + page.title
+          xml.title page.title
+          xml.author { xml.name "Anonymous" }
+          xml.updated page.updated_at.xmlschema
+          xml.link "rel" => "alternate", "href" => Junebug.config['url'] + '/s/' + page.title
+          xml.summary "#{page.title}"
+          xml.content 'type' => 'html' do 
+            xml.text! page.body.gsub("\n", '<br/>').gsub("\r", '') 
+          end
+        end
+      end   
+    end
+  end
+
+end