clwiki 2.4.0 → 3.0.0

data/config/initializers/clwiki.rb

@@ -1,8 +1,9 @@
-require 'cl_wiki/configuration'
+# frozen_string_literal: true
+
+require_dependency 'cl_wiki/configuration'
 
 filename = File.join(File.dirname(__FILE__), '..', '..', 'config', 'clwiki.yml')
 
-conf_hash = YAML::load(::File.open(filename))[Rails.env]
+conf_hash = YAML.safe_load(::File.open(filename))[Rails.env]
 conf_hash['wiki_path'] = ::File.expand_path(conf_hash['wiki_path'], Rails.root)
 $wiki_conf = ClWiki::Configuration.new(conf_hash)
-$wiki_path = $wiki_conf.wiki_path

data/config/routes.rb

@@ -1,14 +1,23 @@
+# frozen_string_literal: true
+
 ClWiki::Engine.routes.draw do
   root to: 'page#show'
 
   # legacy CGI
   match '/clwikicgi.rb', to: 'page#show', via: [:get], as: 'legacy'
 
+  # Ordering of routes matters! Anything specific, like `find` needs to be
+  # _before_ the `/:page_name` route, otherwise it matches on `/:page_name`
+  # before matching on the specific route.
+
   get '/find' => 'page#find', as: 'page_find'
   post '/find' => 'page#find'
 
   get '/recent' => 'page#recent', as: 'recent'
 
+  get '/login', to: 'sessions#new'
+  post '/login', to: 'sessions#create'
+
   get '/:page_name' => 'page#show', as: 'page_show'
   get '/:page_name/edit' => 'page#edit', as: 'page_edit'
   post '/:page_name' => 'page#update'

data/lib/cl_wiki.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 require 'cl_wiki/engine'
 
+require_relative 'cl_wiki_lib'
+
 module ClWiki
 =begin
   http://edgeguides.rubyonrails.org/engines.html#inside-an-engine
@@ -9,4 +13,4 @@ module ClWiki
   options, the file where your engine's module is defined is perfect for that. Place
   the methods inside the module and you'll be good to go.
 =end
-end
+end

data/lib/cl_wiki/configuration.rb

@@ -1,83 +1,43 @@
-require File.dirname(__FILE__) + '/index'
+# frozen_string_literal: true
+
 require 'yaml'
 
 $defaultConfFile = 'clwiki.yml'
 
 module ClWiki
+  # noinspection RubyTooManyInstanceVariablesInspection
   class Configuration
+    attr_accessor :wiki_path, :cssHref, :template, :publishTag, :url_prefix,
+                  :global_edits, :page_update_format, :use_authentication,
+                  :owner, :encryption_default
+    attr_reader :custom_formatter_load_path, :edit_rows, :edit_cols, :editable
 
-    USE_INDEX_NO = 0
-    USE_INDEX_DRB = 1
-    USE_INDEX_LOCAL = 2
-
-    attr_accessor :wiki_path, :cgifn, :indexPort, :cssHref, :template, :useGmt,
-                  :publishTag, :url_prefix, :global_edits, :cgifn_from_rss, :stats_name,
-                  :index_log_fn, :page_update_format
-    attr_reader   :custom_formatter_load_path
-
-    def wait_on_threads
-      # Ruby kills any threads as soon as the main process is done. Any
-      # threads created should be registered here. The last
-      # line of the CGI script should call out to wait_on_threads to make
-      # sure nothing running async in the background is terminated too early
-      @threads.each do |thread|
-        thread.join
-      end if !@threads.nil?
-    end
-
-    def wait_on_thread(thread)
-      @threads = [] if !@threads
-      @threads << thread
-    end
-
-    def useIndex
-      @useIndex
-    end
-
-    def useIndex=(value)
-      @useIndex = value.to_i
+    def initialize(hash = {})
+      default_hash.merge(hash).each do |k, v|
+        instance_variable_set(:"@#{k}", v)
+      end
     end
 
-    def edit_rows
-      @edit_rows
+    def default_hash
+      {
+        url_prefix: '/',
+        publishTag: nil,
+        useIndexForPageExists: false,
+        edit_rows: 25,
+        edit_cols: 80,
+        custom_formatter_load_path: [],
+        use_authentication: false
+      }
     end
 
     def edit_rows=(value)
       @edit_rows = value.to_i
     end
 
-    def edit_cols
-      @edit_cols
-    end
-
     def edit_cols=(value)
       @edit_cols = value.to_i
     end
 
-    def useIndexForPageExists
-      @useIndexForPageExists
-    end
-
-    def useIndexForPageExists=(value)
-      if value.class == String
-        @useIndexForPageExists = (value =~ /true/i)
-      else
-        @useIndexForPageExists = value
-      end
-    end
-
-    def access_log_index
-      @access_log_index
-    end
-
-    def access_log_index=(value)
-      if value.class == String
-        @access_log_index = (value =~ /true/i)
-      else
-        @access_log_index = value
-      end
-    end
-
     def override_access_log_index
       @orig_access_log_index_value = @access_log_index
       @access_log_index = false
@@ -87,85 +47,16 @@ module ClWiki
       @access_log_index = @orig_access_log_index_value if @orig_access_log_index_value
     end
 
-    def editable
-      @editable
-    end
-
     def editable=(value)
-      if value.class == String
-        @editable = (value =~ /true/i)
-      else
-        @editable = value
-      end
-    end
-
-    def showSourceLink
-      @showSourceLink
-    end
-
-    def showSourceLink=(value)
-      if value.class == String
-        @showSourceLink = (value =~ /true/i)
-      else
-        @showSourceLink = value
-      end
+      @editable = if value.class == String
+                    (value =~ /true/i)
+                  else
+                    value
+                  end
     end
 
-    def self.load(filename=$defaultConfFile)
-      $wiki_conf = self.new(YAML::load(::File.open(filename)))
-      $wiki_path = $wiki_conf.wiki_path
-      $wiki_conf
+    def self.load(filename = $defaultConfFile)
+      $wiki_conf = self.new(YAML.safe_load(::File.open(filename)))
     end
-
-    def initialize(hash={})
-      default_hash.merge(hash).each do |k, v|
-        instance_variable_set(:"@#{k.to_s}", v)
-      end
-    end
-
-    def default_hash
-      {
-          :url_prefix => '/',
-          :indexPort => ClWiki::Indexer.defaultPort,
-          :cgifn => 'clwikicgi.rb',
-          :default_recent_changes_name => "Recent Changes",
-          :recent_changes_name => "Recent Changes",
-          :stats_name => "Hit Counts",
-          :useGmt => false,
-          :publishTag => nil,
-          :useIndexForPageExists => false,
-          :showSourceLink => false,
-          :cgifn_from_rss => 'blogki.rb',
-          :edit_rows => 25,
-          :edit_cols => 80,
-          :access_log_index => false,
-          :index_log_fn => nil,
-          :custom_formatter_load_path => []
-      }
-    end
-
-    def default_recent_changes_name=(value)
-      if @recent_changes_name == @default_recent_changes_name
-        @recent_changes_name = value
-      end
-      @default_recent_changes_name = default_recent_changes_name
-    end
-
-    def default_recent_changes_name
-      @default_recent_changes_name
-    end
-
-    def recentChangesName=(value)
-      @recent_changes_name = value
-      @recent_changes_name = @default_recent_changes_name if @recent_changes_name.empty?
-    end
-
-    alias recent_changes_name= recentChangesName=
-
-    def recentChangesName
-      @recent_changes_name
-    end
-
-    alias recent_changes_name recentChangesName
   end
 end

data/lib/cl_wiki/engine.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ClWiki
   class Engine < ::Rails::Engine
     isolate_namespace ClWiki
 
     initializer 'cl_wiki.assets.precompile' do |app|
-      app.config.assets.precompile += %w(application.css application.js)
+      app.config.assets.precompile += %w[application.css application.js]
     end
   end
 end

data/lib/cl_wiki/file.rb

@@ -1,168 +1,196 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'time'
 
-require_relative 'page'
-
-$wikiPageExt = '.txt'
-
 module ClWiki
+  FILE_EXT = '.txt'
+
   class File
-    attr_reader :name, :fileExt, :wikiRootPath, :pagePath, :modTimeAtLastRead, :metadata
-    attr_accessor :clientLastReadModTime
-
-    def initialize(fullPageName, wikiRootPath, fileExt=$wikiPageExt, autocreate=true)
-      # fullPageName must start with / ?
-      @wikiRootPath = wikiRootPath
-      fullPageName = ClWiki::Util.convertToNativePath(fullPageName)
-      fullPageName.ensure_slash_prefix
-      @pagePath, @name = ::File.split(fullPageName)
-      @pagePath = '/' if @pagePath == '.'
-      @fileExt = fileExt
-      @metadata = {}
-      @metadata_keys = ['mtime']
-      if autocreate
-        if file_exists?
-          readFile
-        else
-          writeToFile(default_content, false)
-        end
+    attr_reader :name, :mod_time_at_last_read, :metadata, :owner
+    attr_accessor :client_last_read_mod_time
+
+    def initialize(page_name, wiki_root_path, auto_create: true, owner: PublicUser.new)
+      @wiki_root_path = wiki_root_path
+      @owner = owner
+      @name = ::File.basename(ClWiki::Util.convert_to_native_path(page_name))
+      @metadata = Metadata.new
+      if auto_create
+        file_exists? ? read_file : write_to_file(default_content, false)
       end
     end
 
-    def content_is_default?
+    def has_default_content?
       @contents.to_s == default_content
     end
 
-    def delete
-      File.delete(fullPathAndName) if File.exists?(fullPathAndName)
+    def default_content
+      "Describe #{@name} here."
     end
 
-    def default_content
-      "Describe " + @name + " here."
+    def delete
+      ::File.delete(full_path_and_name) if file_exists?
     end
 
     def file_exists?
-      FileTest.exist?(fullPathAndName)
+      FileTest.exist?(full_path_and_name)
     end
 
-    def fullPath
-      res = ::File.expand_path(::File.join(@wikiRootPath, @pagePath))
-      raise 'no dirs in fullPath' if res.split('/').empty?
-      res
+    def full_path_and_name
+      ::File.expand_path(@name + FILE_EXT, @wiki_root_path)
     end
 
-    def fullPathAndName
-      ::File.expand_path(@name + @fileExt, fullPath)
+    def content
+      @contents
     end
 
-    def fileName
-      raise Exception, 'ClWikiFile.fileName is deprecated, use fullPathAndName'
-      # fullPathAndName
+    def content=(new_content)
+      write_to_file(new_content)
     end
 
-    def content
-      @contents
+    def write_to_file(content, check_mod_time = true)
+      do_mod_time_check if check_mod_time
+
+      update_metadata
+      file_contents = String.new.tap do |s|
+        s << @metadata.to_s
+        s << (content_encrypted? ? @owner.lockbox.encrypt(content) : content)
+      end
+      ::File.binwrite(full_path_and_name, file_contents)
+      ::File.utime(@metadata['mtime'], @metadata['mtime'], full_path_and_name)
+      read_file
     end
 
-    def content=(newContent)
-      writeToFile(newContent)
+    def read_file
+      @mod_time_at_last_read = ::File.mtime(full_path_and_name)
+
+      # positive lookbehind regex is used here to retain the end of line
+      # newline, because this used to just be `File.readlines` which also keeps
+      # the newline characters.
+      raw_lines = ::File.binread(full_path_and_name).split(/(?<=\n)/)
+      @metadata, raw_content = Metadata.split_file_contents(raw_lines)
+      raw_content = raw_content.join
+
+      apply_metadata
+
+      @contents = content_encrypted? ? @owner.lockbox.decrypt_str(raw_content) : raw_content
     end
 
-    def writeToFile(content, checkModTime=true)
-      if checkModTime
-        # refactor, bring raiseIfMTimeNotEqual back into this class
-        ClWiki::Util.raiseIfMTimeNotEqual(@modTimeAtLastRead, fullPathAndName)
-        unless @clientLastReadModTime.nil?
-          ClWiki::Util.raiseIfMTimeNotEqual(@clientLastReadModTime, fullPathAndName)
-        end
-      end
+    def read_metadata(lines)
+      @metadata = Metadata.new(lines)
+    end
 
-      make_dirs(fullPath)
-      ding_mtime
-      ::File.open(fullPathAndName, 'w+') do |f|
-        f.print(metadata_to_write)
-        f.print(content)
-      end
-      ::File.utime(@metadata['mtime'], @metadata['mtime'], fullPathAndName)
-      readFile
+    def apply_metadata
+      @mod_time_at_last_read = Time.parse(@metadata['mtime']) if @metadata.has? 'mtime'
+      ensure_same_owner!
     end
 
-    def ding_mtime
-      @metadata['mtime'] = Time.now
+    def content_encrypted?
+      @metadata['encrypted'] == 'true'
     end
 
-    def metadata_to_write
-      @metadata.collect { |k, v| "#{k}: #{v}" }.join("\n") + "\n\n\n"
+    def encrypt_content!
+      raise "Owner <#{@owner.name}> cannot encrypt" unless @owner.can_encrypt?
+
+      @metadata['encrypted'] = 'true'
     end
 
-    def make_dirs(dir)
-      # need to commit each dir as we make it, which is why we just don't
-      # call File::makedirs. Core code copied from ftools.rb
-      parent = ::File.dirname(dir)
-      return if parent == dir or FileTest.directory? dir
-      make_dirs parent unless FileTest.directory? parent
-      if ::File.basename(dir) != ""
-        Dir.mkdir dir, 0755
+    def do_not_encrypt_content!
+      @metadata['encrypted'] = 'false'
+    end
+
+    private
+
+    def do_mod_time_check
+      ClWiki::Util.raise_if_mtime_not_equal(@mod_time_at_last_read, full_path_and_name)
+      unless @client_last_read_mod_time.nil?
+        ClWiki::Util.raise_if_mtime_not_equal(@client_last_read_mod_time, full_path_and_name)
       end
     end
 
-    def readFile
-      ::File.open(fullPathAndName, 'r') do |f|
-        @modTimeAtLastRead = f.mtime
-        raw_lines = f.readlines
-        metadata_lines, content = split_metadata(raw_lines)
-        read_metadata(metadata_lines)
-        apply_metadata
-        @contents = content
+    def update_metadata
+      @metadata['mtime'] = Time.now
+      @metadata['owner'] = @owner.name
+    end
+
+    def ensure_same_owner!
+      meta_owner = @metadata['owner']
+      is_legacy_file = meta_owner.to_s.empty?
+      unless is_legacy_file || meta_owner == @owner.name
+        raise "Owner must match: <#{meta_owner}> - <#{@owner.name}>"
       end
     end
+  end
 
-    def split_metadata(raw_lines)
-      start_index = 0
-      raw_lines.each_with_index do |ln, index|
-        if ln.chomp.empty?
-          next_line = raw_lines[index+1]
-          if next_line.nil? || next_line.chomp.empty?
-            if all_lines_are_metadata_lines(raw_lines[0..index-1])
-              start_index = index + 2
-            end
-            break
-          end
+  class Metadata
+    def self.split_file_contents(lines)
+      st_idx = 0
+      lines.each_with_index do |ln, index|
+        next unless ln.chomp.empty?
+
+        next_line = lines[index + 1]
+        if next_line.nil? || next_line.chomp.empty?
+          st_idx = index + 2 if all_lines_are_metadata_lines(lines[0..index - 1])
+          break
         end
       end
 
-      if start_index > 0
-        [raw_lines[0..start_index-3], raw_lines[start_index..-1]]
-      else
-        [[], raw_lines]
-      end
+      m, c = st_idx > 0 ? [lines[0..st_idx - 3], lines[st_idx..-1]] : [[], lines]
+      [self.new(m), c]
     end
 
-    def all_lines_are_metadata_lines(lines)
+    def self.all_lines_are_metadata_lines(lines)
       lines.map { |ln| ln.scan(/\A(\w+):?/) }.flatten.
-        map { |k| @metadata_keys.include?(k) }.uniq == [true]
+        map { |k| supported_keys.include?(k) }.uniq == [true]
     end
 
-    def read_metadata(lines)
-      @metadata = {}
+    def self.supported_keys
+      %w[mtime encrypted owner]
+    end
+
+    def initialize(lines = [])
+      @hash = {}
+      @keys = Metadata.supported_keys
+      parse_lines(lines)
+    end
+
+    def [](key)
+      @hash[key]
+    end
+
+    def []=(key, value)
+      raise "Unexpected key: #{key}" unless @keys.include?(key)
+
+      @hash[key] = value
+    end
+
+    def has?(key)
+      @hash.key?(key)
+    end
+
+    def to_s
+      @hash.collect { |k, v| "#{k}: #{v}" }.join("\n") + "\n\n\n"
+    end
+
+    def to_h
+      @hash
+    end
+
+    private
+
+    def parse_lines(lines)
       lines.each do |ln|
         key, value = ln.split(': ')
-        @metadata[key] = value if @metadata_keys.include?(key)
+        @hash[key] = value.chomp if @keys.include?(key)
       end
     end
-
-    def apply_metadata
-      @modTimeAtLastRead = Time.parse(@metadata['mtime']) if @metadata.keys.include? 'mtime'
-    end
   end
 
   class Util
-    def self.raiseIfMTimeNotEqual(mtime_to_compare, file_name)
+    def self.raise_if_mtime_not_equal(mtime_to_compare, file_name)
       # reading the instance .mtime appears to take Windows DST into account,
       # whereas the static File.mtime(filename) method does not
-      current_mtime = ::File.open(file_name) do |f|
-        f.mtime
-      end
+      current_mtime = ::File.open(file_name, &:mtime)
       compare_read_times!(mtime_to_compare, current_mtime)
     end
 
@@ -176,25 +204,20 @@ module ClWiki
     end
 
     def self.dump_time(time)
-      ''.tap do |s|
-        s << "#{time}"
+      String.new.tap do |s|
+        s << time.to_s
         s << ".#{time.usec}" if time.respond_to?(:usec)
       end
     end
 
-    def self.convertToNativePath(path)
-      newpath = path.gsub(/\//, ::File::SEPARATOR)
-      newpath = newpath.gsub(/\\/, ::File::SEPARATOR)
-      return newpath
+    def self.convert_to_native_path(path)
+      path.gsub(%r{/}, ::File::SEPARATOR).gsub(/\\/, ::File::SEPARATOR)
     end
   end
 
-  class FileError < Exception
+  class FileError < RuntimeError
   end
 
   class FileModifiedSinceRead < FileError
   end
-
-  class FileMustUseWriteNewContent < FileError
-  end
 end