RubyGems - clwiki - Versions diffs - 2.4.0 → 3.0.0 - Mend

clwiki 2.4.0 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (239) hide show

data/lib/cl_wiki/format/format.blockquote.rb CHANGED

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
 class FormatBlockquote < ClWiki::CustomFormatter
-  def FormatBlockquote.match_re
-    /\[\].*\[\/\]/m
+  def self.match_re
+    %r{\[\].*\[/\]}m
   end
-  def FormatBlockquote.format_content(content, page)
+  def self.format_content(content, page)
     if content
-      content.gsub!(/\[\]/, "<blockquote>")
-      content.gsub!(/\[\/\]/, "</blockquote>")
+      content.gsub!(/\[\]/, '<blockquote>')
+      content.gsub!(%r{\[/\]}, '</blockquote>')
       content
     end
   end

data/lib/cl_wiki/format/format.graphviz.digraph.rb CHANGED

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
 class FormatGraphVizDiGraph < ClWiki::CustomFormatter
-  def FormatGraphVizDiGraph.match_re
+  def self.match_re
     /digraph.*\}/m
   end
-  def FormatGraphVizDiGraph.format_content(content, page)
+  def self.format_content(content, page)
     content.sub!(/digraph.*\}/m,
-      '<a href="dot.rb?fn=' + page.fileFullPathAndName + '">' +
-      '<img src="dot.rb?fn=' + page.fileFullPathAndName + '">' +
-      '</a>'
-    )
+                 "<a href=\"dot.rb?fn=#{page.file_full_path_and_name}\">
+                  <img src=\"dot.rb?fn=#{page.file_full_path_and_name}\">
+                  </a>")
     content
   end
 end

data/lib/cl_wiki/format/format.opml.rb CHANGED

@@ -1,16 +1,18 @@
-if __FILE__ == $0
-  $LOAD_PATH << ".."
+# frozen_string_literal: true
+if $PROGRAM_NAME == __FILE__
+  $LOAD_PATH << '..'
   require 'clwikipage'
 end
 class FormatOPML < ClWiki::CustomFormatter
-  def FormatOPML.match_re
-    /<opml.*?>.*?<\/opml>/m
+  def self.match_re
+    %r{<opml.*?>.*?</opml>}m
   end
-  def FormatOPML.format_content(content, page)
+  def self.format_content(content, page)
     out = ['<NoWikiLinks>']
-    content.grep(/<outline.*?>|<\/outline>/).each do |ln|
+    content.grep(%r{<outline.*?>|</outline>}).each do |ln|
       title = ln.scan(/title=\"(.*?)\"/).compact
       html = ln.scan(/htmlUrl=\"(.*?)\"/).compact
       xml = ln.scan(/xmlUrl=\"(.*?)\"/).compact
@@ -31,7 +33,7 @@ end
 ClWiki::CustomFormatters.instance.register(FormatOPML)
-if __FILE__ == $0
+if $PROGRAM_NAME == __FILE__
   sample_opml = <<-OPMLTEXT
     <opml xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
       <head>

data/lib/cl_wiki/format/format.pre.blockquote.rb CHANGED

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
 require 'cgi'
 class FormatPreBlockquote < ClWiki::CustomFormatter
-  def FormatPreBlockquote.match_re
-    /\[p\].*?\[\/p\]/mi
+  def self.match_re
+    %r{\[p\].*?\[/p\]}mi
   end
-  def FormatPreBlockquote.format_content(content, page)
+  def self.format_content(content, page)
     content = CGI.escapeHTML(content)
-    content.gsub!(/\[p\]/i, "<blockquote><pre>")
-    content.gsub!(/\[\/p\]/i, "</pre></blockquote>")
+    content.gsub!(/\[p\]/i, '<blockquote><pre>')
+    content.gsub!(%r{\[/p\]}i, '</pre></blockquote>')
   end
 end

data/lib/cl_wiki/format/format.simpletable.rb CHANGED

@@ -1,24 +1,26 @@
+# frozen_string_literal: true
 class FormatSimpleTable < ClWiki::CustomFormatter
-  def FormatSimpleTable.match_re
-    /<simpletable.*?>.*?<\/simpletable>/m
+  def self.match_re
+    %r{<simpletable.*?>.*?</simpletable>}m
   end
-  def FormatSimpleTable.format_content(content, page=nil)
+  def self.format_content(content, page = nil)
     table_attr = content.scan(/<simpletable(.*?)>/m).to_s.strip
     table_attr = 'border="1"' if table_attr.empty?
     content.gsub!(/<simpletable.*?>/m, '')
-    content.gsub!(/<\/simpletable>/m, '')
+    content.gsub!(%r{</simpletable>}m, '')
     content.strip!
     lines = content.split("\n")
     lines.collect! do |ln|
       ln.gsub!(/\t/, '  ')
       '<tr><td>' + ln.gsub(/  +/, '</td><td>') + '</td></tr>'
     end
-    lines.collect! do |ln| ln.gsub(/<td>\s*?<\/td>/, '<td>&nbsp;</td>') end
+    lines.collect! { |ln| ln.gsub(%r{<td>\s*?</td>}, '<td>&nbsp;</td>') }
     # if you do a .join("\n"), then the \n will be converted to <br>
-    # ... so don't do that
-    "<table #{table_attr}>\n" + lines.join("") + "</table>"
+    # ... so don't do that
+    "<table #{table_attr}>\n#{lines.join('')}</table>"
   end
 end

data/lib/cl_wiki/memory_index.rb ADDED

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+gem 'clindex'
+require 'index'
+module ClWiki
+  class MemoryIndexer
+    attr_reader :index, :pages
+    WAIT = true
+    def self.instance(page_owner: PublicUser.new)
+      @instance ||= self.new(page_owner: page_owner)
+    end
+    def initialize(page_owner: PublicUser.new)
+      @page_owner = page_owner
+      @wiki_conf = $wiki_conf
+      @root_dir = @wiki_conf.wiki_path
+      @index = ClIndex.new
+      @recent = ClIndex.new
+      @pages = ClIndex.new
+      build
+    end
+    def recent(top = -1, text: '')
+      pages_desc_mtime = @recent.do_read(WAIT) do
+        hash = @recent.index
+        hash.sort { |a, b| b[0] <=> a[0] }
+      end.map { |_, page_names| page_names }.flatten
+      if text && !text.empty?
+        hit_page_names = search(text)
+        pages_desc_mtime &= hit_page_names
+      end
+      pages_desc_mtime[0..top]
+    end
+    def search(text, titles_only: false)
+      terms = text.split(' ')
+      all_hits = []
+      terms.each do |term|
+        term_hits = []
+        @index.search(term, term_hits, WAIT)
+        term_hits.flatten!
+        all_hits = all_hits.empty? ? term_hits : all_hits & term_hits
+      end
+      all_hits.flatten!
+      all_hits.uniq!
+      all_hits.sort!
+      all_hits.delete_if { |name| name !~ /#{text}/i } if titles_only
+      all_hits
+    end
+    def page_exists?(full_name)
+      @pages.term_exists?(full_name, WAIT)
+    end
+    def reindex_page(page_name)
+      remove_page_from_index(page_name)
+      index_page(page_name)
+    end
+    private
+    def build
+      files = Dir[::File.join(@root_dir, '**/*' + ClWiki::FILE_EXT)]
+      files.each do |fn|
+        next unless ::File.file?(fn)
+        page_name = ::File.basename(fn, ClWiki::FILE_EXT)
+        index_page(page_name)
+      end
+    end
+    def index_page(page_name)
+      pg = ClWiki::Page.new(page_name, wiki_path: @root_dir, owner: @page_owner)
+      pg.read_raw_content
+      formatter = ClWiki::PageFormatter.new(pg.raw_content, page_name)
+      formatter.format_links { |word| @index.add(word.downcase, page_name, WAIT) }
+      add_to_indexes(pg)
+    end
+    def add_to_indexes(page)
+      @index.add(page.page_name, page.page_name, WAIT)
+      @pages.add(page.page_name, nil, WAIT)
+      @recent.remove(page.page_name, WAIT)
+      @recent.add(page.mtime.strftime('%Y-%m-%dT%H:%M:%S'), page.page_name, WAIT)
+    end
+    def remove_page_from_index(page_name)
+      @index.remove(page_name, WAIT)
+      @recent.remove(page_name, WAIT)
+    end
+  end
+end

data/lib/cl_wiki/page.rb CHANGED

@@ -1,99 +1,80 @@
+# frozen_string_literal: true
 require 'cgi'
 require 'singleton'
-require File.dirname(__FILE__) + '/file'
-require File.dirname(__FILE__) + '/find_in_file'
-$FIND_PAGE_NAME = "Find"
-$FIND_RESULTS_NAME = "Find Results"
 module ClWiki
   class Page
-    attr_reader :content, :mtime, :name, :full_name, :pagePath, :raw_content,
-                :fileFullPathAndName
-    @@wikiIndexClient = nil
+    attr_reader :content, :mtime, :name, :page_name, :raw_content,
+                :file_full_path_and_name
-    #Refactor clwikifile out of here into a storage class that will
-    # require in the appropriate storage file clwikifile, clwikisql
+    def initialize(page_name, wiki_path: $wiki_conf.wiki_path, owner: PublicUser.new)
+      raise "Fix this - no slashes! #{page_name}" if %r{/}.match?(page_name)
-    # refactor away wikiPath ... should be taken care of elsewhere, otherwise
-    # ClWiki must know it, and it should be storage independent
-    def initialize(fullName, wiki_path=$wiki_path)
-      @full_name = fullName
+      @page_name = page_name
       @wiki_path = wiki_path
-      @wikiFile = ClWiki::File.new(@full_name, @wiki_path)
-      @pagePath = @wikiFile.pagePath
-      @name = @wikiFile.name
+      @owner = owner
+      @wiki_file = ClWiki::File.new(@page_name, @wiki_path, owner: @owner)
+      @name = @wiki_file.name
     end
-    # <pre> text in 1.13.2 had extra line feeds, because the \n were xformed to
-    # <br>\n, which results in two line feeds when rendered by Mozilla.
-    # The change a few versions ago inside convert_newline_to_br which started
-    # converting \n to <br>\n is the culprit here. I did this for more readable
-    # html, but that does screw up <pre> sections, so it's put back now.
     def convert_newline_to_br
-      new_content = ""
-      insideHtmlTags = false
+      new_content = ''
+      inside_html_tags = false
       @content.each_line do |substr|
-        insideHtmlTags = true if (substr =~ /#{'<html>'}/)
-        insideHtmlTags = false if (substr =~ /#{'</html>'}/)
-        if ((!ClWiki::PageFormatter.only_html(substr)) or (substr == "\n")) and !insideHtmlTags
-          new_content = new_content + substr.gsub(/\n/, "<br>")
-        else
-          new_content = new_content + substr
-        end
+        inside_html_tags = true if /<html>/.match?(substr)
+        inside_html_tags = false if /<\/html>/.match?(substr)
+        new_content += if (!ClWiki::PageFormatter.only_html(substr) || (substr == "\n")) && !inside_html_tags
+                         substr.gsub(/\n/, '<br>')
+                       else
+                         substr
+                       end
       end
       @content = new_content
     end
-    def self.wikiIndexClient
-      @@wikiIndexClient = ClWikiIndexClient.new if !@@wikiIndexClient
-      @@wikiIndexClient
+    def is_new?
+      @wiki_file.has_default_content?
     end
     def read_raw_content
-      @raw_content = @wikiFile.content.join.gsub(/\r\n/, "\n")
+      @raw_content = @wiki_file.content
       read_page_attributes
-      ClWiki::Page.wikiIndexClient.add_hit(@full_name) if $wiki_conf.access_log_index
-    end
-    def content_never_edited?
-      @wikiFile.content_is_default?
     end
     def delete
-      @wikiFile.delete
+      @wiki_file.delete
     end
-    def self.read_file_full_path_and_name(full_name, wiki_path=$wiki_path)
-      wiki_file = ClWikiFile.new(full_name, wiki_path, $wikiPageExt, false)
-      wiki_file.fullPathAndName
+    def read_page_attributes
+      wiki_file = @wiki_file
+      @mtime = wiki_file.mod_time_at_last_read
+      # TODO: kill this - not needed except in graphviz renderer?
+      @file_full_path_and_name = wiki_file.full_path_and_name
     end
-    def read_page_attributes
-      wikiFile = @wikiFile # ClWikiFile.new(@fullName, @wikiPath)
-      @mtime = wikiFile.modTimeAtLastRead
-      @fileFullPathAndName = wikiFile.fullPathAndName
+    def content_encrypted?
+      @wiki_file.content_encrypted?
     end
     def read_raw_content_with_forwarding(full_page_name)
       stack = []
       history = []
-      content = ''
+      content = String.new
       final_page_name = full_page_name
       stack.push(full_page_name)
-      while !stack.empty?
+      until stack.empty?
         this_pg_name = stack.pop
         if history.index(this_pg_name)
           pg_content = '-= CIRCULAR FORWARDING DETECTED =-'
         else
-          pg = ClWiki::Page.new(this_pg_name)
+          pg = ClWiki::Page.new(this_pg_name, owner: @owner)
           pg.read_raw_content
           pg_content = pg.raw_content
           fwd_full_page_name = get_forward_ref(pg_content)
           if fwd_full_page_name
-            pg_content = "Auto forwarded from #{this_pg_name.strip_slash_prefix}<br><br>#{fwd_full_page_name}<br><br>"
+            pg_content = "Auto forwarded from #{this_pg_name}<br><br>#{fwd_full_page_name}<br><br>"
             stack.push fwd_full_page_name
           else
             final_page_name = this_pg_name
@@ -105,24 +86,22 @@ module ClWiki
       [content, final_page_name]
     end
-    def read_content(include_header_and_footer=true, include_diff=false)
+    def read_content(include_header_and_footer = true, include_diff = false)
       read_page_attributes
-      @content, final_page_name = read_raw_content_with_forwarding(@full_name)
+      @content, final_page_name = read_raw_content_with_forwarding(@page_name)
       process_custom_renderers
       convert_newline_to_br
       f = ClWiki::PageFormatter.new(@content, final_page_name)
-      @content = "<div class='wikiBody'>#{f.formatLinks}</div>"
-      if include_header_and_footer
-        @content = get_header + @content + get_footer
-      end
-      @content = CLabs::WikiDiffFormatter.format_diff(@wikiFile.diff) + @content if include_diff
+      @content = "<div class='wikiBody'>#{f.format_links}</div>"
+      @content = get_header + @content + get_footer if include_header_and_footer
+      @content = CLabs::WikiDiffFormatter.format_diff(@wiki_file.diff) + @content if include_diff
       @content
     end
     def process_custom_renderers
       root_dirs = [::File.join(::File.dirname(__FILE__), 'format')] + $wiki_conf.custom_formatter_load_path
       root_dirs.each do |root_dir|
-        Dir[::File.join(root_dir, 'format.*')].each do |fn|
+        Dir[::File.join(root_dir, 'format.*')].sort.each do |fn|
           require fn
         end
       end
@@ -131,91 +110,77 @@ module ClWiki
     end
     def get_header
-      f = ClWiki::PageFormatter.new(nil, @full_name)
-      f.header(@full_name, self)
+      ClWiki::PageFormatter.new(nil, @page_name).header(@page_name, self)
     end
     def get_footer
-      f = ClWiki::PageFormatter.new(nil, @full_name)
-      f.footer(self)
+      ClWiki::PageFormatter.new(nil, @page_name).footer(self)
     end
     def get_forward_ref(content)
       content_ary = content.split("\n")
       res = (content_ary.collect { |ln| ln.strip.empty? ? nil : ln }.compact.length == 1)
-      if res
-        res = content_ary[0] =~ /^see (.*)/i
-      end
+      res = content_ary[0] =~ /^see (.*)/i if res
       if res
-        page_name = $1
-        f = ClWiki::PageFormatter.new(content, @full_name)
+        page_name = Regexp.last_match(1)
+        f = ClWiki::PageFormatter.new(content, @page_name)
         res = f.is_wiki_name?(page_name)
-        if res
-          res = ClWiki::Page.page_exists?(page_name)
-        end
-      end
-      if res
-        page_name
-      else
-        nil
+        res = ClWiki::Page.page_exists?(page_name) if res
       end
+      page_name if res
     end
-    def update_content(newcontent, mtime)
-      wikiFile = @wikiFile # ClWikiFile.new(@fullName, @wikiPath)
-      wikiFile.clientLastReadModTime = mtime
-      wikiFile.content = newcontent
-      if $wiki_conf.useIndex != ClWiki::Configuration::USE_INDEX_NO
-        wikiIndexClient = ClWiki::IndexClient.new
-        wikiIndexClient.reindex_page_and_save_async(@full_name)
-      end
+    def update_content(new_content, mtime, encrypt = false)
+      @wiki_file.client_last_read_mod_time = mtime
+      encrypt ? @wiki_file.encrypt_content! : @wiki_file.do_not_encrypt_content!
+      @wiki_file.content = new_content
+      ClWiki::MemoryIndexer.instance(page_owner: @owner).reindex_page(@page_name)
     end
+    # TODO: if this is the 1st time the index is instantiated, it won't have owner.
+    # and this will blow up waaay down the stack as it tries to do all of the indexing
+    # without an owner.
+    #
+    # For this query, however, it doesn't need owner, since it's just looking for
+    # existence. Hmmm. The index could be lazy-loaded, with names and metadata
+    # first, and not content if owner doesn't match. But ... I dunno.
     def self.page_exists?(page_name)
-      if ($wiki_conf.useIndex != ClWiki::Configuration::USE_INDEX_NO) &&
-          ($wiki_conf.useIndexForPageExists)
-        res = ClWiki::Page.wikiIndexClient.page_exists?(page_name)
-      else
-        wiki_file = ClWiki::File.new(page_name, $wiki_path, $wikiPageExt, false)
-        res = wiki_file.file_exists?
-      end
-      res
+      ClWiki::MemoryIndexer.instance.page_exists?(page_name)
     end
   end
   class PageFormatter
+    FIND_PAGE_NAME = 'Find'
+    FIND_RESULTS_NAME = 'Find Results'
+    attr_reader :full_name
     attr_accessor :content
-    def initialize(content=nil, aFullName=nil)
+    def initialize(content = nil, full_name = nil)
       @content = content
-      self.fullName = aFullName
-      @wikiIndex = nil
+      self.full_name = full_name
+      @wiki_index = nil
     end
-    def fullName=(value)
+    def full_name=(value)
       @full_name = value
       if @full_name
         @full_name = @full_name[1..-1] if @full_name[0..1] == '//'
       end
     end
-    def fullName
-      @full_name
-    end
     def header(full_page_name, page = nil)
       search_text = ::File.basename(full_page_name)
       page_path, page_name = ::File.split(full_page_name)
       page_path = '/' if page_path == '.'
       dirs = page_path.split('/')
       dirs = dirs[1..-1] if !dirs.empty? && dirs[0].empty?
-      full_dirs = (0..dirs.length-1).each { |i| full_dirs[i] = ('/' + dirs[0..i].join('/')) }
-      head = '<div class=\'wikiHeader\'>'
-      if (full_page_name != $FIND_PAGE_NAME) and
-          (full_page_name != $FIND_RESULTS_NAME) and
-          (full_page_name != $wiki_conf.recent_changes_name) and
-          (full_page_name != $wiki_conf.stats_name)
+      full_dirs = (0..dirs.length - 1).each { |i| full_dirs[i] = ('/' + dirs[0..i].join('/')) }
+      head = String.new('<div class=\'wikiHeader\'>')
+      if [FIND_PAGE_NAME, FIND_RESULTS_NAME].include?(full_page_name)
+        head << "<span class='pageName'>#{full_page_name}</span>"
+      else
         head << "<span class='pageName'><a href='find?search_text=#{search_text}'>#{page_name}</a></span><br/>"
         full_dirs.each do |dir|
           head << '<span class=\'pageTag\'>'
@@ -223,8 +188,6 @@ module ClWiki
         end
         head << '<br/>'
         head << "<span class='wikiPageData'>#{page_update_time(page)}</span><br/>" if page
-      else
-        head << '<span class=\'pageName\'>' + full_page_name + '</span>'
       end
       head << '</div>'
     end
@@ -240,7 +203,7 @@ module ClWiki
     end
     def process_custom_footers(page)
-      Dir[::File.dirname(__FILE__) + '/footer/footer.*'].each do |fn|
+      Dir["#{::File.dirname(__FILE__)}/footer/footer.*"].sort.each do |fn|
         require fn
       end
@@ -248,102 +211,70 @@ module ClWiki
     end
     def footer(page)
-      return '' if !page.is_a? ClWiki::Page # blogki does this
+      return String.new unless page.is_a? ClWiki::Page
       custom_footer = process_custom_footers(page)
-      wiki_name = page.full_name
+      wiki_name = page.page_name
       # refactor string constants
-      footer = "<div class='wikiFooter'>"
-      footer << "<ul>"
-      if (wiki_name != $FIND_PAGE_NAME) and
-          (wiki_name != $FIND_RESULTS_NAME) and
-          (wiki_name != $wiki_conf.recent_changes_name) and
-          (wiki_name != $wiki_conf.stats_name)
-        if $wiki_conf.editable
-          footer << ("<li><span class='wikiAction'><a href='" + wiki_name.strip_slash_prefix + "/edit'>Edit</a></span></li>")
+      footer = String.new("<div class='wikiFooter'>")
+      footer << '<ul>'
+      if $wiki_conf.editable
+        unless [FIND_PAGE_NAME, FIND_RESULTS_NAME].include?(wiki_name)
+          footer << "<li><span class='wikiAction'><a href='#{wiki_name}/edit'>Edit</a></span></li>"
         end
       end
       footer << "<li><span class='wikiAction'><a href='find'>Find</a></span></li>"
       footer << "<li><span class='wikiAction'><a href='recent'>Recent</a></span></li>"
-      # footer << "<li><span class='wikiAction'><a href=#{cgifn}?about=true>About</a></span></li>" if wiki_name == "/FrontPage"
-      footer << "</ul></div>"
-      return custom_footer << footer
+      footer << '</ul></div>'
+      custom_footer << footer
     end
     def src_url
       "file://#{ClWiki::Page.read_file_full_path_and_name(@full_name)}"
     end
-    def reload_url(with_global_edit_links=false)
+    def reload_url(with_global_edit_links = false)
       result = "#{full_url}?page=#{@full_name}"
-      if with_global_edit_links
-        result << "&globaledits=true"
-      else
-        result << "&globaledits=false"
-      end
+      result << (with_global_edit_links ? '&globaledits=true' : '&globaledits=false')
     end
     def mailto_url
       "mailto:?Subject=wikifyi:%20#{@full_name}&Body=#{reload_url}"
     end
-    def gsubWords
-      @content.gsub(/<.+?>|<\/.+?>|\w+/) { |word| yield word }
-    end
-    def convert_relative_wikinames_to_absolute
-      # do not go ahead without testing here
-      #formatLinks do |word|
-      #  if isWikiName?(word)
-      #end
-      # problem here is we should obey the NoWikiLinks and Html tag rules,
-      # and those variables aren't being yielded right now. If we change
-      # how the yield works, it affects the indexer. And we can't just
-      # tack on additional yield params and have existing code that only
-      # pays attention to the first keep working:
-      #
-      # irb(main):001:0> def test
-      # irb(main):002:1>   yield 1,2,3
-      # irb(main):003:1> end
-      # nil
-      # irb(main):004:0> test do |a|
-      # irb(main):005:1* puts a
-      # irb(main):006:1> end
-      # 1
-      # 2
-      # 3
+    def gsub_words
+      @content.gsub(%r{<.+?>|</.+?>|\w+}) { |word| yield word }
     end
-    def formatLinks
+    def format_links
       no_wiki_link_in_effect = false
       inside_html_tags = false
-      gsubWords do |word|
-        if (word[0, 1] == '<') and (word[-1, 1] == '>')
+      gsub_words do |word|
+        if (word[0, 1] == '<') && (word[-1, 1] == '>')
           # refactor to class,local constant, instead of global
-          if word =~ /#{'<NoWikiLinks>'}/i
+          if /<NoWikiLinks>/i.match?(word)
             no_wiki_link_in_effect = true
             word = ''
             # refactor to class,local constant, instead of global
-          elsif word =~ /#{'</NoWikiLinks>'}/i
+          elsif /<\/NoWikiLinks>/i.match?(word)
             no_wiki_link_in_effect = false
             word = ''
           end
-          if word =~ /#{'<html>'}/i
+          if /<html>/i.match?(word)
             inside_html_tags = true
             word = ''
-          elsif word =~ /#{'</html>'}/i
+          elsif /<\/html>/i.match?(word)
             inside_html_tags = false
             word = ''
           end
         elsif is_wiki_name?(word)
-          if !no_wiki_link_in_effect and !inside_html_tags
+          if !no_wiki_link_in_effect && !inside_html_tags
             # code smell here y'all
-            word = convertToLink(word) if !block_given?
+            word = convert_to_link(word) unless block_given?
           end
         end
         if block_given?
@@ -355,9 +286,9 @@ module ClWiki
     end
     def self.only_html(str)
-      onlyOneTag = /\A[^<]*<[^<>]*>[^>]*\z/
-      headerTagLine = /\A\s*<h.>.*<\/h.>\s*\z/
-      (str =~ onlyOneTag) || (str =~ headerTagLine)
+      only_one_tag = /\A[^<]*<[^<>]*>[^>]*\z/
+      header_tag_line = %r{\A\s*<h.>.*</h.>\s*\z}
+      (str =~ only_one_tag) || (str =~ header_tag_line)
       # str.scan(/<.*>/).to_s == str.chomp
     end
@@ -366,38 +297,30 @@ module ClWiki
     end
     def cgifn
-      $wiki_conf.cgifn if $wiki_conf
+      $wiki_conf&.cgifn
     end
     def full_url
       ($wiki_conf.url_prefix + cgifn) if $wiki_conf
     end
-    def convertToLink(page_name)
+    def convert_to_link(page_name)
       if ClWiki::Page.page_exists?(page_name)
-        "<a href='#{page_name.strip_slash_prefix}'>#{page_name.strip_slash_prefix}</a>"
+        "<a href='#{page_name}'>#{page_name}</a>"
       else
-        if $wiki_conf.useIndex == ClWiki::Configuration::USE_INDEX_NO
-          finder = FindInFile.new($wiki_path)
-          finder.find(page_name, FindInFile::FILE_NAME_ONLY)
-          hits = finder.files.collect { |f| f.sub($wikiPageExt, '') }
-        else
-          @wikiIndex = ClWiki::IndexClient.new if @wikiIndex.nil?
-          titles_only = true
-          hits = @wikiIndex.search(page_name, titles_only)
-          hits = GlobalHitReducer.reduce_to_exact_if_exists(page_name, hits)
-        end
-        case hits.length
-          when 0
-            result = page_name
-          when 1
-            result = "<a href='#{hits[0]}'>#{page_name}</a>"
-          else
-            result = "<a href='find?search_text=#{page_name}'>#{page_name}</a>"
-        end
-        if ($wiki_conf.editable) && ((hits.length == 0) || ($wiki_conf.global_edits))
+        @wiki_index ||= ClWiki::MemoryIndexer.instance
+        hits = @wiki_index.search(page_name, titles_only: true)
+        result = case hits.length
+                 when 0
+                   page_name
+                 when 1
+                   "<a href='#{hits[0]}'>#{page_name}</a>"
+                 else
+                   "<a href='find?search_text=#{page_name}'>#{page_name}</a>"
+                 end
+        if $wiki_conf.editable && (hits.empty? || $wiki_conf.global_edits)
           result << "<a href='#{page_name}/edit'>?</a>"
         end
         result
@@ -405,36 +328,12 @@ module ClWiki
     end
     def is_wiki_name?(string)
-      all_wiki_names = true
-      names = string.split(/[\\\/]/)
-      # if first character is a slash, then split puts an empty string into names[0]
-      names.delete_if { |name| name.empty? }
-      all_wiki_names = false if names.empty?
-      names.each do |name|
-        all_wiki_names =
-            (
-            all_wiki_names and
-                # the number of all capitals followed by a lowercase is greater than 1
-                (name.scan(/[A-Z][a-z]/).length > 1) and
-                # the first letter is capitalized or slash
-                (
-                (name[0, 1] == name[0, 1].capitalize) or (name[0, 1] == '/') or (name[0, 1] == "\\")
-                ) and
-                # there are no non-word characters in the string (count is 0)
-                # ^[\w|\\|\/] is read:
-                # _____________[_____  _^_  ____\w_________  _|  __\\______  _|  ___\/________]
-                # characters that are  not  word characters  or  back-slash  or  forward-slash
-                # (the not negates the *whole* character set (stuff in brackets))
-                (name.scan(/[^\w\\\/]/).length == 0)
-            )
-      end
-      return all_wiki_names
+      return false if string.empty?
+      /\A[A-Z][a-z]\w*?[A-Z][a-z]\w*\z/.match?(string)
     end
   end
   class CustomFooters
     include Singleton
@@ -444,11 +343,11 @@ module ClWiki
     end
     def process_footers(page)
-      content = ''
-      @footers.each do |f|
-        content << f.footer_html(page)
-      end if @footers
-      return content
+      String.new.tap do |content|
+        @footers&.each do |f|
+          content << f.footer_html(page)
+        end
+      end
     end
   end
@@ -470,11 +369,11 @@ module ClWiki
     end
     def process_formatters(content, page)
-      @formatters.each do |f|
-        if content =~ f.match_re
+      @formatters&.each do |f|
+        if content&.match?(f.match_re)
           content.gsub!(f.match_re) { |match| f.format_content(match, page) }
         end
-      end if @formatters
+      end
     end
   end
@@ -482,39 +381,12 @@ module ClWiki
   # directory and imitate.
   class CustomFormatter
   end
-  class GlobalHitReducer
-    def GlobalHitReducer.reduce_to_exact_if_exists(term, hits)
-      reduced = hits.dup
-      reduced.delete_if do |hit|
-        parts = hit.split('/')
-        exact = (parts[-1] =~ /^#{term}$/i)
-        !exact
-      end
-      if !reduced.empty?
-        reduced
-      else
-        hits
-      end
-    end
-  end
 end
 module CLabs
   class WikiDiffFormatter
-    def WikiDiffFormatter.format_diff(diff)
+    def self.format_diff(diff)
       "<b>Diff</b><br><pre>\n#{CGI.escapeHTML(diff)}\n</pre><br><hr=width\"50%\">"
     end
   end
 end
-class String
-  def ensure_slash_prefix
-    self[0..0] != '/' ? "/#{self}" : self
-  end
-  def strip_slash_prefix
-    self.gsub(/^\//, '')
-  end
-end