Moving back some model classes to where they belong. Model classes need not map to database entities to be model classes

app/models/author.rb

@@ -0,0 +1,18 @@
+class Author < String
+  attr_accessor :ip
+  attr_reader :name
+  def initialize(name, ip = nil) 
+    @ip = ip
+    super(name)
+  end
+
+  def name=(value)
+    self.gsub!(/.+/, value)
+  end
+  
+  alias_method :name, :to_s
+  
+  def <=>(other)
+    name <=> other.to_s
+  end
+end

app/models/page_set.rb

@@ -0,0 +1,89 @@
+# Container for a set of pages with methods for manipulation.
+
+class PageSet < Array
+  attr_reader :web
+
+  def initialize(web, pages = nil, condition = nil)
+    @web = web
+    # if pages is not specified, make a list of all pages in the web
+    if pages.nil?
+      super(web.pages)
+    # otherwise use specified pages and condition to produce a set of pages
+    elsif condition.nil?
+      super(pages)
+    else
+      super(pages.select { |page| condition[page] })
+    end
+  end
+
+  def most_recent_revision
+    self.map { |page| page.created_at }.max || Time.at(0)
+  end
+
+
+  def by_name
+    PageSet.new(@web, sort_by { |page| page.name })
+  end
+
+  alias :sort :by_name
+
+  def by_revision
+    PageSet.new(@web, sort_by { |page| page.created_at }).reverse 
+  end
+  
+  def pages_that_reference(page_name)
+    self.select { |page| page.wiki_references.include?(page_name) }
+  end
+  
+  def pages_that_link_to(page_name)
+    self.select { |page| page.wiki_words.include?(page_name) }
+  end
+
+  def pages_that_include(page_name)
+    self.select { |page| page.wiki_includes.include?(page_name) }
+  end
+
+  def pages_authored_by(author)
+    self.select { |page| page.authors.include?(author) }
+  end
+
+  def characters
+    self.inject(0) { |chars,page| chars += page.content.size }
+  end
+
+  # Returns all the orphaned pages in this page set. That is,
+  # pages in this set for which there is no reference in the web.
+  # The HomePage and author pages are always assumed to have
+  # references and so cannot be orphans
+  # Pages that refer to themselves and have no links from outside are oprphans.
+  def orphaned_pages
+    never_orphans = web.select.authors + ['HomePage']
+    self.select { |page|
+      if never_orphans.include? page.name
+        false
+      else
+        references = pages_that_reference(page.name)
+        references.empty? or references == [page]
+      end
+    }
+  end
+
+  # Returns all the wiki words in this page set for which
+  # there are no pages in this page set's web
+  def wanted_pages
+    wiki_words - web.select.names
+  end
+
+  def names
+    self.map { |page| page.name }
+  end
+
+  def wiki_words
+    self.inject([]) { |wiki_words, page| wiki_words << page.wiki_words }.flatten.uniq
+  end
+
+  def authors
+    self.inject([]) { |authors, page| authors << page.authors }.flatten.uniq.sort
+  end
+
+end

app/models/wiki.rb

@@ -0,0 +1,96 @@
+class Wiki
+  cattr_accessor :storage_path, :logger
+  self.storage_path = "#{RAILS_ROOT}/storage/"
+  self.logger = RAILS_DEFAULT_LOGGER
+
+  def authenticate(password)
+    password == (system.password || 'instiki')
+  end
+
+  def create_web(name, address, password = nil)
+    @webs = nil
+    Web.create(:name => name, :address => address, :password => password) 
+  end
+
+  def delete_web(address)
+    web = Web.find_by_address(address)
+    unless web.nil?
+      web.destroy
+      @webs = nil
+    end
+  end
+
+  def file_yard(web)
+    web.file_yard
+  end
+
+  def edit_web(old_address, new_address, name, markup, color, additional_style, safe_mode = false, 
+      password = nil, published = false, brackets_only = false, count_pages = false, 
+      allow_uploads = true, max_upload_size = nil)
+
+    if not (web = Web.find_by_address(old_address))
+      raise Instiki::ValidationError.new("Web with address '#{old_address}' does not exist")
+    end
+    
+    web.refresh_revisions if web.settings_changed?(markup, safe_mode, brackets_only)
+    web.update_attributes(:address => new_address, :name => name, :markup => markup, :color => color, 
+      :additional_style => additional_style, :safe_mode => safe_mode, :password => password, :published => published,
+      :brackets_only => brackets_only, :count_pages => count_pages, :allow_uploads => allow_uploads, :max_upload_size => max_upload_size)
+    @webs = nil
+    raise Instiki::ValidationError.new("There is already a web with address '#{new_address}'") unless web.errors.on(:address).nil?
+    web
+  end
+
+  def read_page(web_address, page_name)
+    self.class.logger.debug "Reading page '#{page_name}' from web '#{web_address}'"
+    web = Web.find_by_address(web_address)
+    if web.nil?
+      self.class.logger.debug "Web '#{web_address}' not found"
+      return nil
+    else
+      page = web.pages.find(:first, :conditions => ['name = ?', page_name])
+      self.class.logger.debug "Page '#{page_name}' #{page.nil? ? 'not' : ''} found"
+      return page
+    end
+  end
+  
+  def remove_orphaned_pages(web_address)
+    web = Web.find_by_address(web_address)
+    web.remove_pages(web.select.orphaned_pages)
+  end
+  
+  def revise_page(web_address, page_name, content, revised_on, author)
+    page = read_page(web_address, page_name)
+    page.revise(content, revised_on, author)
+  end
+
+  def rollback_page(web_address, page_name, revision_number, created_at, author_id = nil)
+    page = read_page(web_address, page_name)
+    page.rollback(revision_number, created_at, author_id)
+  end
+  
+  def setup(password, web_name, web_address)
+    system.update_attribute(:password, password)
+    create_web(web_name, web_address)
+  end
+
+  def system
+    @system ||= (System.find(:first) || System.create)
+  end
+
+  def setup?
+    Web.count > 0
+  end
+
+  def webs
+    @webs ||= Web.find(:all).inject({}) { |webs, web| webs.merge(web.address => web) }
+  end
+
+  def storage_path
+    self.class.storage_path
+  end
+  
+  def write_page(web_address, page_name, content, written_on, author)
+    Web.find_by_address(web_address).add_page(page_name, content, written_on, author)
+  end
+end