sqliki_generator 0.0.1

data/USAGE

@@ -0,0 +1,46 @@
+NAME
+     sqliki - creates a SQL-based wiki within a rails application
+
+SYNOPSIS
+     sqliki [Controller name]
+     
+     Good names are Sqliki, Wiki, Chalkboard, Elmo, ...
+
+DESCRIPTION
+     This generator creates a rudimentary SQL-based wiki.
+
+     Included:
+      - a User model which uses sha1 encryption for passwords
+      - a Controller with signup, login, welcome and logoff actions
+      - a mixin which lets you easily add advanced authentication 
+        features to your abstract base controller
+      - a user_model.sql with the minimal sql required to get the model to work. 
+      - extensive unit and functional test cases to make sure nothing breaks.
+            
+EXAMPLE
+      ./script/generate sqliki Wiki
+
+     This will generate a Wiki controller with the following methods:
+
+           For users:
+              index (=list)
+              rollback
+              wanted
+              orphaned
+              recently_revised
+              find
+              list
+              show
+              new
+              edit
+           For control flow:
+              save
+              raw
+              html
+              inplace_edit
+              inplace_save
+              create
+              update
+              destroy
+
+     The tables are always called pages, drafts, and links

data/sqliki_generator-0.0.1.gemspec

@@ -0,0 +1,40 @@
+require 'rubygems'
+
+SPEC = Gem::Specification.new do |s|
+  s.name = %q{sqliki_generator}
+  s.version = "0.0.1"
+  s.date = %q{2005-08-25}
+  s.summary = %q{[Rails] SQL-based wiki generator.}
+  s.require_paths = ["."]
+  s.email = %q{Markus@reality.com}
+  s.homepage = %q{http://www.rubyonrails.org/show/Generators}
+  s.description = %q{Generates code for (primative) a SQL-based wiki within your Rails app.}
+  s.authors = ["Markus J. Q. Roberts"]
+  s.files = %w{
+        USAGE
+        templates/lib_sanitize_html.rb
+        templates/README
+        templates/model_draft.rb
+        templates/view_edit.rhtml
+        templates/view_find.rhtml
+        templates/view__form.rhtml
+        templates/view_inplace_edit.rhtml
+        templates/view_inplace_save.rhtml
+        templates/view_list.rhtml
+        templates/view_new.rhtml
+        templates/view_rollback.rhtml
+        templates/view_show.rhtml
+        templates/model_link.rb
+        templates/model_page.rb
+        templates/controller_sqliki_controller.rb
+        sqliki_generator.rb
+        sqliki_generator-0.0.1.gemspec
+      }
+  s.add_dependency(%q<rails>, [">= 0.13.1"])
+end
+
+if $0 == __FILE__
+    Gem::manage_gems
+    Gem::Builder.new(SPEC).build
+    end
+

data/sqliki_generator.rb

@@ -0,0 +1,39 @@
+class SqlikiGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      
+      #
+      # For v0.0.1, there's no renaming it
+      file_name = 'sqliki'
+
+      # Models.
+      %w{page draft link}.each do |x|
+        m.template "model_#{x}.rb",File.join("app/models", class_path, "#{x}.rb")
+      end
+
+      # Views. 
+      m.directory File.join("app/views", class_path, file_name)
+      %w{edit find _form inplace_edit inplace_save list new rollback show }.each do |x|
+        m.template "view_#{x}.rhtml",File.join("app/views", class_path, file_name, "#{x}.rhtml")
+      end
+
+      # Controller.
+      %w{sqliki}.each do |x|
+        m.template "controller_#{x}_controller.rb",File.join("app/controllers", class_path, "#{x}_controller.rb")
+      end
+
+      # Libs.
+      %w{sanitize_html}.each do |x|
+        m.template "lib_#{x}.rb",File.join("lib", class_path, "#{x}.rb")
+      end
+
+      m.template "README", "README_SQLIKI"
+    end
+  end
+
+  attr_accessor :controller_class_name
+  
+end
+
+
+

data/templates/README

@@ -0,0 +1,88 @@
+== Installation
+
+NOTE: THIS IS THE VERY FIRST ALPHA VERSION OF SQLIKI!!!
+
+Done generating SQLiki. but there are still a few things you have to
+do manually.
+
+* You will need a login system of some kind.  I have been using the simple
+  login generator.
+
+* SQLiki needs to know the current user; it looks for this in
+  User.current_user.  If your login system provides this, fine.  The simple
+  login generator does not, but you can add it reasonably easily.  Just add
+  something like the following to your application.rb:
+
+       class << User
+           cattr_accessor :current_user unless self.respond_to? :current_user
+           end
+
+       class ApplicationController < ActionController::Base
+           before_filter :note_the_current_user
+           def note_the_current_user
+               User.current_user = @session[:user] if User.respond_to? :current_user=
+               end
+           end
+
+
+* You will need Why T.L.S.'s RedCloth (which you probably already have)
+
+* You will need three tables (pages, drafts, and links):
+
+--
+-- Table structure for table 'pages'
+--         These are just the headers (page names); the text is in
+--         the draft identified by "current_draft_id"
+--
+
+CREATE TABLE pages (
+  id int(10) unsigned NOT NULL auto_increment,
+  type varchar(80) NOT NULL default '',
+  created_on datetime default NULL,
+  updated_on datetime default NULL,
+  lock_version int(11) default '0',
+  current_draft_id int(11) NOT NULL default '0',
+  title varchar(80) NOT NULL default '',
+  created_by int(11) NOT NULL default '0',
+  PRIMARY KEY  (id)
+) TYPE=MyISAM;
+
+--
+-- Table structure for table 'drafts'
+--         These are were the text is stored.  Note that drafts make
+--         a tree, since each derived-draft knows which draft it was
+--         based on.
+--
+
+CREATE TABLE drafts (
+  id int(10) unsigned NOT NULL auto_increment,
+  type varchar(80) NOT NULL default '',
+  created_on datetime default NULL,
+  draft_of_page_id int(11) default '0',
+  based_on_draft_id int(11) default '0',
+  body text NOT NULL,
+  created_by int(11) NOT NULL default '0',
+  PRIMARY KEY  (id)
+) TYPE=MyISAM;
+
+--
+-- Table structure for table 'links'
+--         These just keep track of which drafts refer to which pages;
+--         that is, whenever a draft of one page contains a WikiWord that
+--         generates a link to another page, that fact is noted here.
+--
+
+CREATE TABLE links (
+  draft_id int(11) NOT NULL default '0',
+  page_id int(11) NOT NULL default '0'
+) TYPE=MyISAM;
+
+
+== How to use it 
+
+== Tips & Tricks
+
+== Changelog
+
+0.0.1 First gem release
+

data/templates/controller_sqliki_controller.rb

@@ -0,0 +1,77 @@
+class SqlikiController < ApplicationController
+    model :draft
+    include LoginSystem
+    before_filter :login_required
+    def identify_page
+        @page ||= Page.find_by_title(params[:id]) #|| Page.find_by_id(params[:id])
+        end
+    def index
+        list
+        render :action => 'list'
+        end
+    def raw
+        render_text identify_page.current_draft.raw
+        end
+    def html
+        render_text identify_page.current_draft.html
+        end
+    def inplace_edit
+        edit
+        end
+    def rollback
+        identify_page
+        #@page.current_draft = ???
+        render :action => 'show'
+        end
+    def save
+        end
+    def inplace_save
+        save
+        end
+    def wanted
+        end
+    def orphaned
+        end
+    def recently_revised
+        end
+    def find
+        end
+    def list(condition=:all)
+        @page_pages, @pages = paginate :page, :per_page => 10
+        end
+    def show
+        identify_page || redirect_to(:action => 'new', :id => @params[:id])
+        end
+    def new
+        @page = Page.new_page(@params[:id])
+        end
+    def create
+        new
+        @page.save
+        if @page.update_attributes(params[:page])
+            #@page.current_draft.created_by = @session[:user]
+            #@page.save
+            flash[:notice] = 'Page was successfully created.'
+            redirect_to :action => 'list'
+          else
+            render :action => 'new'
+          end
+        end
+    def edit
+        identify_page || redirect_to(:action => 'new', :id => @params[:id])
+        end
+    def update
+        identify_page
+        if @page.update_attributes(params[:page])
+            flash[:notice] = 'Page was successfully updated.'
+            redirect_to :action => 'show', :id => @page.title
+          else
+            render :action => 'edit'
+          end
+        end
+    def destroy
+        identify_page.destroy
+        redirect_to :action => 'list'
+        end
+    end
+    

data/templates/lib_sanitize_html.rb

@@ -0,0 +1,143 @@
+#
+# Written from scratch to address specific problems I was having with instiki/RedCloth
+#
+#   * Mismatched tags (especially DIVs) seriously messed up the page layout
+#   * View Changes made code blocks hard to read (lost line breaks)
+#   * Inserting/deleting block-level tags caused messed up page layout
+#
+# See An_html_janitor.initialze for a birds-eye view of the algorithm.
+#
+# (c) 2005 By Markus J. Q. Roberts
+# Usage, modification, etc. of this program is permitted under the GPL, Ruby's License, Rail's
+#     License, or Instiki's License (your choice)
+#
+require 'ostruct'
+require 'cgi'
+
+class An_html_janitor < String
+    Tags_we_dont_expect_to_close = %w{ area br img input keygen li link meta p param td th thead tr }
+    Priority = Hash.new( 0 ).update({ 'ins' => 10, 'del' => 10 })
+    def initialize(raw_html)
+        replace raw_html
+        @safe_house = []
+        sequester!("previous protected zone",/@protected \w+ \d+@/)
+        sequester!("html comment",           /<!--.*?-->/m        )
+        #To do: sequester attributes that contain "<" and/or ">"
+        spiff_up('ins')
+        spiff_up('del')
+        ballance_tags
+        remove_empty_spans
+        unseal!("html comment","previous protected zone")
+        end
+    def stash(text)
+        @safe_house << [[],text.to_s,[]]
+        @safe_house.length - 1
+        end
+    def token_for(group,id)
+        "@protected #{group} #{id}@"
+        end
+    def sequester!(group,reg_exp)
+        gsub!(reg_exp) { |match| token_for(group,stash(match)) }
+        end
+    def unseal!(*groups)
+        gsub!(/@protected (?:#{groups.join('|')}) (\d+)@/) { |n| @safe_house[$1.to_i] }
+        end
+    def wrap(token,new_pre,new_post)
+        pre,core,post = @safe_house[token]
+        @safe_house[token].replace [pre+[new_pre],core,[new_post]+post]
+        end
+    def escape_core(token)
+        pre,core,post = @safe_house[token]
+        @safe_house[token].replace [[],CGI.escapeHTML(core),[]]
+        end
+    def spiff_up(tag)
+        gsub!(%r{<#{tag}(.*?)>(.*?)</#{tag}>}) {
+            "<#{tag}#{$1}>#{CGI.escapeHTML($2.gsub(%r{<(/?\w+).*?>}) {"<#{$1}>"})}</#{tag}>"
+            }
+        end
+    def ballance_tags
+        stack = []
+        gsub!(%r{<(.*?)>}) { |chunk| case $1
+            when %r{/$}       #self-closing tag
+              chunk
+            when %r{^(\w+)}    #opening tag
+              tag = $1.downcase
+              #print "opening #{tag}  \n    #{stack.collect {|q| q.desc}.inspect}\n    #{@safe_house.inspect}#\n"
+              if Tags_we_dont_expect_to_close.include? tag
+                  chunk
+                else
+                  stack.push OpenStruct.new(
+                      :tag => tag,
+                      :priority => Priority[tag],
+                      :text => chunk,
+                      :start_tag => stash(chunk),
+                      :expected_close => "</#{tag}>",
+                      :desc => "#{chunk}...</#{tag}>"
+                      )
+                  token_for("start tag",stack.last.start_tag)
+                end
+            when %r{^/(\w+)}  #closing tag
+              tag = $1.downcase
+              #print "closing #{tag}\n    #{stack.collect {|q| q.tag}.inspect}\n    #{@safe_house.inspect}\n"
+              if Tags_we_dont_expect_to_close.include? tag
+                  mode = :ignore
+                else
+                  pre  = []
+                  priority = Priority[tag]
+                  outranked = false
+                  while s = stack.pop and tag != s.tag
+                      outranked ||= s.priority > priority
+                      pre << s
+                      end
+                  mode = if !s or outranked
+                      :escape_it
+                    elsif tag != 'div'
+                      :breaking_this_one
+                    else
+                      :breaking_others
+                    end
+                  stack.push *pre.reverse
+                  end
+              case mode
+                when :breaking_this_one
+                  pre.collect {|s| s.expected_close }.join  + chunk + pre.reverse.collect {|s| s.text }.join
+                when :breaking_others
+                  this_head = s.text
+                  pre.each { |s| wrap(s.start_tag,chunk,this_head) }
+                  chunk
+                when :ignore
+                  ''
+                else
+                  escape_core(s.start_tag) if s
+                  CGI.escapeHTML(chunk)
+                end
+            else
+              chunk
+            end }
+        replace self+stack.reverse.collect { |open_tag| open_tag.expected_close }.join
+        unseal!("start tag")
+        end
+    def remove_empty_spans
+        while gsub!(%r{<(\w+)[^>]*?></\1>},''); end
+        end
+    def remove_attributes(*attributes_to_remove)
+        return self if attributes_to_remove.length == 0
+        kill_pattern = /(#{attributes_to_remove.join('|')})(=(".*?"|\S*))?/i
+        gsub!(%r{<(\w+) +(.*?)>}) { |match| "<#{$1} #{$2.gsub(kill_pattern,'')}>" }
+        self
+        end
+    def remove_styles(*styles_to_remove)
+        return self if styles_to_remove.length == 0
+        style_kill_pattern = /(#{styles_to_remove.join('|')}).*?(;|$)/i
+        gsub!(%r{<(\w+) +(.*?)>}i) { |match|
+            "<#{$1} #{$2.gsub!(%r{style="(.*?)"}) { |match| "style=""#{$1.gsub(style_kill_pattern,'')}""" }}>"
+            }
+        self
+        end
+    end
+
+def sanitize_html(raw_html)
+    An_html_janitor.new(raw_html)
+    end
+
+

data/templates/model_draft.rb

@@ -0,0 +1,145 @@
+require 'sanitize_html'
+require '/usr/local/lib/ruby/gems/1.8/gems/RedCloth-3.0.3/lib/redcloth'
+
+class Draft < ActiveRecord::Base
+    acts_as_tree :foreign_key => 'based_on_draft_id'
+    has_and_belongs_to_many :links,:class_name => 'Page',:join_table => 'links'
+    belongs_to :author, :class_name => 'User', :foreign_key => :created_by
+    belongs_to :page, :foreign_key => :draft_of_page_id
+    def before_create
+        html #this updates the cross reference (link) table
+        true
+        end
+    def raw
+        body
+        end
+    class RopaRojo < RedCloth
+        def hard_break(text)
+            make_divs text
+            super
+            end
+        def to_html(*rules,&callback)
+            @callback = callback
+            rules = DEFAULT_RULES if rules.empty?
+            text = super(*([:inline_wiki_words]+rules))
+            text << %q{
+                <script type="text/javascript" language="JavaScript">
+                <!--
+                     function toggle(name) {
+                         q=document.getElementById(name);
+                         if (q.style.display == 'none')
+                             {q.style.display  = 'block';}
+                           else
+                             {q.style.display  = 'none';};
+                         }
+                //-->
+                </script>
+                } if @need_toggle_function
+            text
+            end
+        def htmlesc(str,mode)
+            super
+            str
+            end
+        # Bracket free text consists of either
+        #      characters that are not "{" or "}",
+        #      one or two "{"s, not followed by a third "{",
+        #      one or two "}"s, not followed by a third "}",
+        #
+        BRACKET_FREE_TEXT = "((:?[^{}]|[{]{1,2}(?![{])|[}]{1,2}(?![}]))*?)"
+        DIV_BRACKETS = /\{\{\{#{BRACKET_FREE_TEXT}\}\}\}/m
+        ALT_TEXT = /
+                (
+                ([\s\[{(]|[#{PUNCT}])?     # $pre
+                "                          # start
+                (#{C})                     # $atts
+                ([^"]+?)                   # $text
+                \s?
+                (?:\(([^)]+?)\)(?="))?     # $title
+                ":
+                )?
+                /mx
+        XDIV_RE = /
+                (
+                ([\s\[{(]|[#{PUNCT}])?     # $pre
+                "                          # start
+                (#{C})                     # $atts
+                ([^"]+?)                   # $text
+                \s?
+                (?:\(([^)]+?)\)(?="))?     # $title
+                ":
+                )?
+                #{DIV_BRACKETS}            # $div_block
+            /mx
+        DIV_RE = /#{ALT_TEXT}#{DIV_BRACKETS}/m
+   
+        def make_divs( text )
+            ## break the text into <div> blocks based on {{{ ... }}}
+            while text.gsub!( DIV_RE ) { |m|
+                has_link,pre,atts,link_text,title,div_block = $~.captures
+                if has_link
+                    @need_toggle_function = true
+                    id   = "div_#{rand(100000)}"
+                    atts = shelve(" onclick=\"toggle('#{id}'); return false;\" #{ pba(atts) } title=\"#{ title||'more...' }\"")
+                    "#{ pre }<a#{ atts }>#{ link_text }</a><div id=\"#{id}\" style=\"display:none\">#{div_block}</div>"
+                  else
+                    "<div #{shelve(attrs) }>#{div_block}</div>"
+                  end
+                }; end
+            text
+            end
+        NOT_WIKI_WORD = /\\(([A-Z]+[a-z0-9]+){2,})/
+        WIKI_WORD = /#{ALT_TEXT}(([A-Z]+[a-z1-9]+){2,})/
+        WIKI_PHRASE = /#{ALT_TEXT}\[\[(.*?)\]\]/m
+        def split_wiki_word(ww)
+            ww.gsub(/([a-z0-9])([A-Z])/,'\1 \2');
+            end
+        def clean_wiki_word(ww)
+            ww.gsub(/ /,'_').gsub(/[^A-Za-z0-9$-_.+!*'(),]/,'')
+            end
+        include ActionView::Helpers::TagHelper
+        include ActionView::Helpers::UrlHelper
+        #def wiki_link(ww)
+        #    #link_to ww, {:controller => 'sqliki', :action => 'show', :id => clean_wiki_word(ww)}
+        #    link_to ww, "/sqliki/show/#{clean_wiki_word(ww)}"
+        #    end
+        def wiki_link(link_text,ww)
+            #link_to link_text, {:controller => 'sqliki', :action => 'show', :id => clean_wiki_word(ww)}
+            #(@callback && @callback.call(:wiki_link,link_text,ww)) || (link_to link_text, "/sqliki/show/#{clean_wiki_word(ww)}")
+            (@callback && @callback.call(:wiki_link,link_text,ww))
+            (link_to link_text, "/sqliki/show/#{clean_wiki_word(ww)}")
+            end
+        def inline_wiki_words(text)
+            text.gsub!(NOT_WIKI_WORD) { |m| shelve $1 }
+            [WIKI_PHRASE,WIKI_WORD].each {|pattern|
+                text.gsub!(pattern) { |m|
+                    has_link,pre,atts,link_text,title,ww = $~.captures
+                    ww = split_wiki_word(ww) if pattern == WIKI_WORD
+                    (pre||'') + wiki_link("<span #{shelve(pba(atts))}>#{link_text||ww}</span>"||ww,ww)
+                    }
+                }
+            text
+            end
+        end
+    #include ActionView::Helpers::TextHelper
+    def textilize(body) #html
+        if body.blank?
+            ""
+          else
+            RopaRojo.new(body, [:hard_breaks ]).to_html { |event,*details|
+                case event
+                  when :wiki_link
+                    link_text,ww = *details
+                    page = (Page.find_by_title(ww) || Page.new_page(ww))
+                    links << page unless links.include? page
+                    nil
+                  else
+                    nil
+                  end
+                }
+            end
+        end
+    def html
+        sanitize_html(textilize(body))
+        end
+    end

data/templates/model_link.rb

@@ -0,0 +1,2 @@
+class Link < ActiveRecord::Base
+end

data/templates/model_page.rb

@@ -0,0 +1,31 @@
+class Page < ActiveRecord::Base
+    belongs_to :current_draft, :class_name => 'Draft', :foreign_key => :current_draft_id
+    has_many :drafts, :foreign_key => :draft_of_page_id
+    has_and_belongs_to_many :links,:class_name => "Draft",:join_table => 'links'
+    belongs_to :author, :class_name => 'User', :foreign_key => :created_by
+    validates_uniqueness_of :title, :on => :create
+    validates_length_of :title, :within => 1..80
+    validates_presence_of :title
+    def self.new_page(title)
+        p = Page.new :created_by => User.current_user, :title => title
+        p.raw = ''
+        p
+        end
+    def raw
+        current_draft && current_draft.raw
+        end
+    def raw=(new_text)
+        d = Draft.new(
+            :body => new_text || '',
+            :based_on_draft_id => self.current_draft && self.current_draft.id,
+            :created_by => User.current_user
+            );
+        d.save;
+        self.current_draft = d
+        self.drafts << d
+        new_text
+        end
+    def html
+        current_draft.html
+        end
+    end

data/templates/view__form.rhtml

@@ -0,0 +1,12 @@
+<%%= error_messages_for 'page' %>
+
+<!--[form:page]-->
+
+<%% unless @page.title %>
+   <p><label for="page_title">Title</label><br/>
+   <%%= text_field 'page', 'title' %></p>
+   <%% end %>
+<%%= text_area 'page', 'raw'  %></p>
+
+<!--[eoform:page]-->
+

data/templates/view_edit.rhtml

@@ -0,0 +1,9 @@
+<h1><%%= @page.title %></h1>
+
+<%%= start_form_tag :action => 'update', :id => @page.title %>
+  <%%= render_partial 'form' %>
+  <%%= submit_tag 'Edit' %>
+<%%= end_form_tag %>
+
+<%%= link_to 'Show', :action => 'show', :id => @page.title %> |
+<%%= link_to 'List', :action => 'list' %>

data/templates/view_find.rhtml

@@ -0,0 +1,2 @@
+<h1>Page#find</h1>
+<p>Find me in app/views/page/find.rhtml</p>

data/templates/view_inplace_edit.rhtml

@@ -0,0 +1,2 @@
+<h1>Page#inplace_edit</h1>
+<p>Find me in app/views/page/inplace_edit.rhtml</p>

data/templates/view_inplace_save.rhtml

@@ -0,0 +1,2 @@
+<h1>Page#inplace_save</h1>
+<p>Find me in app/views/page/inplace_save.rhtml</p>

data/templates/view_list.rhtml

@@ -0,0 +1,26 @@
+<h1>Listing pages</h1>
+
+<table>
+  <tr><th>Title</th><th>Created by</th><th>on</th><th>Revised by</th><th>on</th>
+  </tr>
+  
+<%% for page in @pages %>
+  <tr>
+    <td><%%= page.title %></td>
+    <td><%%= page.author.login %></td>
+    <td><%%= page.created_on %></td>
+    <td><%%= page.current_draft.author.login %></td>
+    <td><%%= page.current_draft.created_on %></td>
+    <td><%%= link_to 'Show', :action => 'show', :id => page.title %></td>
+    <td><%%= link_to 'Edit', :action => 'edit', :id => page.title %></td>
+    <td><%%= link_to 'Destroy', {:action => 'destroy', :id => page.title}, :confirm => 'Are you sure?' %></td>
+  </tr>
+<%% end %>
+</table>
+
+<%%= link_to 'Previous page', { :page => @page_pages.current.previous } if @page_pages.current.previous %>
+<%%= link_to 'Next page', { :page => @page_pages.current.next } if @page_pages.current.next %> 
+
+<br />
+
+<%%= link_to 'New page', :action => 'new' %>

data/templates/view_new.rhtml

@@ -0,0 +1,8 @@
+<h1><%%= @page.title || "New page"  %></h1>
+
+<%%= start_form_tag :action => 'create', :id => @page.title %>
+  <%%= render_partial 'form' %>
+  <%%= submit_tag "Create" %>
+<%%= end_form_tag %>
+
+<%%= link_to 'Back', :action => 'list' %>

data/templates/view_rollback.rhtml

@@ -0,0 +1,2 @@
+<h1>Page#rollback</h1>
+<p>Find me in app/views/page/rollback.rhtml</p>

data/templates/view_show.rhtml

@@ -0,0 +1,18 @@
+<h1><%%= @page.title %></h1>
+
+<div style='background: #EFE; width: 80%; padding: 1ex 2ex 1ex 2ex'>
+     <%%= @page.html %>
+     </div>
+
+
+Created by <%%= @page.author.login %> on <%%= @page.created_on %><br>
+Revised by <%%= @page.current_draft.author.login %> on <%%= @page.current_draft.created_on %><br>
+Referenced from: <%% @page.links.each do |link| %>
+    <%% if link.id == link.page.current_draft.id  %>
+        <%%= link_to link.page.title, :action => 'show', :id => link.page.title %>
+        <%% end %>
+    <%% end %>
+<br>
+<%%= link_to 'Edit', :action => 'edit', :id => @page.title %> |
+<%%= link_to 'List All Pages', :action => 'list' %>
+

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: sqliki_generator
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2005-08-25
+summary: "[Rails] SQL-based wiki generator."
+require_paths: 
+  - "."
+email: Markus@reality.com
+homepage: http://www.rubyonrails.org/show/Generators
+rubyforge_project: 
+description: Generates code for (primative) a SQL-based wiki within your Rails app.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Markus J. Q. Roberts
+files: 
+  - USAGE
+  - templates/lib_sanitize_html.rb
+  - templates/README
+  - templates/model_draft.rb
+  - templates/view_edit.rhtml
+  - templates/view_find.rhtml
+  - templates/view__form.rhtml
+  - templates/view_inplace_edit.rhtml
+  - templates/view_inplace_save.rhtml
+  - templates/view_list.rhtml
+  - templates/view_new.rhtml
+  - templates/view_rollback.rhtml
+  - templates/view_show.rhtml
+  - templates/model_link.rb
+  - templates/model_page.rb
+  - templates/controller_sqliki_controller.rb
+  - sqliki_generator.rb
+  - sqliki_generator-0.0.1.gemspec
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rails
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: 0.13.1
+      version: