clwiki 2.4.0 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71fc0798c710ba213d639a8f4cff5ffc734679a002f862401ac9cec75c195019
-  data.tar.gz: d7ed5d896d504b742f681653b4717edf04901f7d295e3ac573dd79f64a8ff598
+  metadata.gz: b05c529c89a4963cc09ea1aa19fa4cc65009a6139d82fa6db3086206077d752b
+  data.tar.gz: 0df1b84af4db6bd0504c69c013755c54f94232c0b5ea32f4b82a5d940a218684
 SHA512:
-  metadata.gz: 33e5916f65f7f1c0708b8e99bd5aaeda2882dbcc153588e6f2775f5f89827c00c322e42e567df8e7029fa1e13b7650ea2f429a1e4677ad4fd06e689ce71db8fc
-  data.tar.gz: 76783cc36ba99086af87927c675a3260193e20e48b853d8ec6de082c5031bc746f9d6f0780d39157338e2f2af66c308b7b5d9cff78a4de30aee18b77657291a8
+  metadata.gz: d270c91ed7d9afafd8c6c83e220d9de90ec4a8104221d3f3ae483de431e114ce01be2940ec92d027464b98cf1c8099c1a7f49048b7f651aa53f98037f5194b76
+  data.tar.gz: 77fe601ea440d0b306f66a83e5fd64215e84e6d4983e6d0b3ba65f3afc87f5f3b6d1172c880aa9ccb56673e1890906e4cf1d838a4d53defaee58def378664aff

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'bundler/setup'
 rescue LoadError
@@ -14,7 +16,7 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
 load 'rails/tasks/engine.rake'
 
 Bundler::GemHelper.install_tasks
@@ -35,13 +37,11 @@ end
 RSpec::Core::RakeTask.new(:spec)
 
 task :tests do
-  errors = %w(test spec).collect do |task|
-    begin
-      Rake::Task[task].invoke
-      nil
-    rescue => e
-      { task: task, exception: e }
-    end
+  errors = %w[test spec].collect do |task|
+    Rake::Task[task].invoke
+    nil
+  rescue StandardError => e
+    {task: task, exception: e}
   end.compact
 
   if errors.any?
@@ -50,4 +50,14 @@ task :tests do
   end
 end
 
-task default: :tests
+task :rubocop do
+  sh 'bundle exec rubocop'
+end
+
+task :rubocop_metrics do
+  sh 'bundle exec rubocop -c .rubocop-metrics.yml'
+end
+
+task default: :tests
+task default: :rubocop
+task default: :rubocop_metrics

data/app/controllers/cl_wiki/application_controller.rb

@@ -1,4 +1,37 @@
+# frozen_string_literal: true
+
 module ClWiki
   class ApplicationController < ActionController::Base
+    before_action :expire_old_session, if: -> { $wiki_conf.use_authentication }
+    before_action :authorized, if: -> { $wiki_conf.use_authentication }
+    before_action :initialize_index, if: -> { $wiki_conf.use_authentication }
+    helper_method :current_user
+    helper_method :logged_in?
+
+    def expire_old_session
+      reset_session if session[:expire_at]&.< Time.now
+    end
+
+    def current_user
+      User.find(session[:username])&.tap do |user|
+        user.cached_encryption_key = Base64.decode64(session[:encryption_key])
+      end
+    end
+
+    def current_owner
+      current_user || ClWiki::PublicUser.new
+    end
+
+    def logged_in?
+      !current_user.nil?
+    end
+
+    def authorized
+      redirect_to login_url unless logged_in?
+    end
+
+    def initialize_index
+      ClWiki::MemoryIndexer.instance(page_owner: current_owner)
+    end
   end
-end
+end

data/app/controllers/cl_wiki/page_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cl_wiki/page'
 
 module ClWiki
@@ -5,24 +7,35 @@ module ClWiki
     before_action :redirect_legacy_cgi_urls
     before_action :initialize_formatter
     before_action :assign_page_name
-    before_action :redirect_to_front_page_if_bad_name, :only => :show
+    before_action :redirect_to_front_page_if_bad_name, only: :show
+    skip_before_action :expire_old_session, only: [:edit, :update]
 
     def show
-      @page = ClWiki::Page.new(@page_name)
+      @page = instantiate_page
       @page.read_content
       @page
     end
 
     def edit
-      @page = ClWiki::Page.new(@page_name)
+      @render_encryption_ui = $wiki_conf.use_authentication
+
+      @page = instantiate_page
+      @encrypt_default = determine_encryption_default
+
       @page.read_raw_content
       @page
     end
 
     def update
-      @page = ClWiki::Page.new(@page_name)
-      @page.update_content(params[:page_content], Time.at(params[:client_mod_time].to_s.to_i))
-      redirect_to params[:save_and_edit] ? page_edit_url(:page_name => @page.full_name.strip_slash_prefix) : page_show_url(:page_name => @page.full_name.strip_slash_prefix)
+      @page = instantiate_page
+
+      mtime = Time.at(params[:client_mod_time].to_s.to_i)
+      encrypt = params[:encrypt].present?
+      @page.update_content(params[:page_content], mtime, encrypt)
+
+      redirect_to params[:save_and_edit] ?
+                    page_edit_url(page_name: @page.page_name) :
+                    page_show_url(page_name: @page.page_name)
     end
 
     def find
@@ -33,40 +46,30 @@ module ClWiki
         hits = search(@search_text)
 
         hits.each do |full_name|
-          @formatter.fullName = full_name
-          @results << "#{@formatter.convertToLink(full_name)}"
+          @formatter.full_name = full_name
+          @results << @formatter.convert_to_link(full_name).to_s
         end
       end
     end
 
     def search(text)
-      case $wiki_conf.useIndex
-        when ClWiki::Configuration::USE_INDEX_NO
-          finder = FindInFile.new($wiki_path)
-          finder.find(text)
-          finder.files.collect do |filename|
-            filename.sub($wikiPageExt, '')
-          end
-        else
-          ClWiki::IndexClient.new.search(text)
-      end
+      ClWiki::MemoryIndexer.instance.search(text)
     end
 
+    # recent _published_ pages.
     def recent
-      finder = FindInFile.new($wiki_path)
-      finder.find($wiki_conf.publishTag || '.')
-      @pages = finder.files.collect do |filename|
-        p = ClWiki::Page.new(filename.sub($wikiPageExt, ''))
-        p.read_page_attributes
-        p
-      end
-      @pages = @pages.sort { |a, b| b.mtime <=> a.mtime }[0..9]
+      page_names = ClWiki::MemoryIndexer.instance.recent(10, text: $wiki_conf.publishTag)
+
       without_header_and_footer = false
-      @pages.each { |p| p.read_content(without_header_and_footer) }
+      @pages = page_names.map do |page_name|
+        ClWiki::Page.new(page_name, owner: current_owner).tap do |page|
+          page.read_content(without_header_and_footer)
+        end
+      end
 
       respond_to do |format|
         format.html
-        format.rss { render :layout => false }
+        format.rss { render layout: false }
       end
     end
 
@@ -77,30 +80,42 @@ module ClWiki
     def redirect_legacy_cgi_urls
       if request.fullpath.start_with?(legacy_path)
         page_name = (params[:page] || front_page_name).split('/')[-1]
-        case
-          when request.query_parameters.include?('edit')
-            redirect_to page_edit_url(:page_name => page_name), status: '301'
-          else
-            redirect_to page_show_url(:page_name => page_name), status: '301'
+        if request.query_parameters.include?('edit')
+          redirect_to page_edit_url(page_name: page_name), status: '301'
+        else
+          redirect_to page_show_url(page_name: page_name), status: '301'
         end
       end
     end
 
     def assign_page_name
       @page_name = params[:page_name]
-      @page_name = @page_name.ensure_slash_prefix if @page_name
     end
 
     def redirect_to_front_page_if_bad_name
-      if ((@page_name.blank?) || (!@formatter.is_wiki_name?(@page_name))) ||
-          (!$wiki_conf.editable && !ClWiki::Page.page_exists?(@page_name.ensure_slash_prefix))
-        redirect_to page_show_url(:page_name => front_page_name)
-        return
+      if (@page_name.blank? || !@formatter.is_wiki_name?(@page_name)) ||
+         (!$wiki_conf.editable && !ClWiki::Page.page_exists?(@page_name))
+        redirect_to page_show_url(page_name: front_page_name)
+        nil
       end
     end
 
     def initialize_formatter
       @formatter = ClWiki::PageFormatter.new
     end
+
+    private
+
+    def instantiate_page
+      ClWiki::Page.new(@page_name, owner: current_owner)
+    end
+
+    def determine_encryption_default
+      if $wiki_conf.use_authentication
+        @page.is_new? ? $wiki_conf.encryption_default : @page.content_encrypted?
+      else
+        false
+      end
+    end
   end
 end

data/app/controllers/cl_wiki/sessions_controller.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ClWiki
+  class SessionsController < ApplicationController
+    before_action :skip_all_if_not_using_authentication
+    skip_before_action :authorized, only: %i[new create]
+    skip_before_action :initialize_index, only: %i[new create]
+
+    def new
+    end
+
+    def create
+      auth_user_and_setup_session ?
+        redirect_to(root_url) :
+        redirect_to(login_url)
+    end
+
+    def destroy
+      reset_session
+      redirect_to login_url
+    end
+
+    private
+
+    def auth_user_and_setup_session
+      @user = User.find(params[:username])
+      password = params[:password]
+      authenticated = @user&.username == $wiki_conf.owner && @user&.authenticate(password)
+      if authenticated
+        session[:username] = @user.username
+        session[:expire_at] = 48.hours.from_now
+        session[:encryption_key] = Base64.encode64(@user.derive_encryption_key(password))
+      end
+      authenticated
+    end
+
+    def skip_all_if_not_using_authentication
+      redirect_to root_url unless $wiki_conf.use_authentication
+    end
+  end
+end

data/app/helpers/cl_wiki/application_helper.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module ClWiki
   module ApplicationHelper
   end
-end
+end

data/app/models/cl_wiki/user.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ClWiki
+  class User < ClWiki::UserBase
+    include ActiveModel::SecurePassword
+    include ActiveModel::Serializers::JSON
+
+    has_secure_password
+
+    attr_reader :encryption_key
+    attr_accessor :username, :password_digest
+
+    validates :username, presence: true
+
+    def attributes
+      {username: self.username,
+       password_digest: self.password_digest}
+    end
+
+    def attributes=(hash)
+      hash.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    def self.create(username, password)
+      self.new.tap do |u|
+        u.username = username
+        u.password = password
+        u.save
+      end
+    end
+
+    def self.find(username)
+      user_file = users_root("#{username}.json")
+      if ::File.exist?(user_file)
+        user = self.new
+        json = ::File.read(user_file)
+        user.from_json(json)
+      end
+    end
+
+    def save
+      ::File.open(User.users_root("#{username}.json"), 'w') do |f|
+        # as_json yields a Hash for some reason, which then can't be parsed
+        # when read from disk.
+        f.write(self.attributes.to_json)
+      end
+    end
+
+    def self.users_root(filename)
+      root = FileUtils.makedirs(::File.join($wiki_conf.wiki_path, 'users'))
+      ::File.join(root, filename)
+    end
+
+    # Generate a consistent key that can be used with Lockbox for encrypting
+    # content, and that is not persisted anywhere.
+    def derive_encryption_key(password)
+      if authenticate(password)
+        pass = 'secret'
+        salt = 'static salt' # so the same key is derived each time
+        iter = 10_000
+        hash = OpenSSL::Digest::SHA256.new
+        len = hash.digest_length
+        OpenSSL::KDF.pbkdf2_hmac(pass,
+                                 salt: salt,
+                                 iterations: iter,
+                                 length: len,
+                                 hash: hash)
+      else
+        raise 'Could not authenticate password'
+      end
+    end
+
+    # Never, never, persist this! It needs to be pushed in from the session
+    # store, for usage down deeper in the ClWiki `lib` code.
+    def cached_encryption_key=(value)
+      @encryption_key = value
+    end
+
+    def name
+      self.username
+    end
+
+    def can_encrypt?
+      true
+    end
+  end
+end

data/app/views/cl_wiki/page/edit.html.erb

@@ -1,8 +1,12 @@
-<%= form_tag(page_show_path(:page_name => @page.full_name)) do %>
+<%= form_tag(page_show_path(:page_name => @page.page_name)) do %>
   <%= hidden_field_tag 'client_mod_time', @page.mtime.to_i.to_s %>
 
   <%= text_area_tag 'page_content', @page.raw_content, rows: $wiki_conf.edit_rows, cols: $wiki_conf.edit_cols %>
   <br/>
   <%= submit_tag 'Save', name: 'save' %>
   <%= submit_tag 'Save and Continue Editing', name: 'save_and_edit' %>
+  <% if @render_encryption_ui %>
+    <%= label_tag 'encrypt', 'Encrypt contents:', class: 'findDetails' %>
+    <%= check_box_tag 'encrypt', 'yes', @encrypt_default %>
+  <% end %>
 <% end %>

data/app/views/cl_wiki/page/recent.html.erb

@@ -1,6 +1,6 @@
 <% @pages.each do |page| %>
   <div class='wikiHeader'>
-    <span class='pageName'><%= @formatter.convertToLink(page.name).html_safe %></span>
+    <span class='pageName'><%= @formatter.convert_to_link(page.name).html_safe %></span>
   </div>
   <%= page.content.html_safe %>
 <% end %>

data/app/views/cl_wiki/page/recent.rss.builder

@@ -1,18 +1,20 @@
-xml.instruct! :xml, :version => "1.0"
-xml.rss :version => "2.0" do
+# frozen_string_literal: true
+
+xml.instruct! :xml, version: '1.0'
+xml.rss version: '2.0' do
   xml.channel do
-    xml.title "clWiki"
-    xml.description "clWiki"
+    xml.title 'clWiki'
+    xml.description 'clWiki'
     xml.link root_url
 
-    for page in @pages
+    @pages.each do |page|
       xml.item do
         xml.title page.name
         xml.description page.content
         xml.pubDate page.mtime.to_s(:rfc822)
-        xml.link page_show_url(:page_name => page.name)
-        xml.guid page_show_url(:page_name => page.name)
+        xml.link page_show_url(page_name: page.name)
+        xml.guid page_show_url(page_name: page.name)
       end
     end
   end
-end
+end

data/app/views/cl_wiki/sessions/new.html.erb

@@ -0,0 +1,10 @@
+<h1>Login</h1>
+
+<%= form_tag login_path do%>
+  <%= label_tag :username%><br>
+  <%= text_field_tag :username%><br>
+  <%= label_tag :password%><br>
+  <%= password_field_tag :password%><br>
+
+  <%= submit_tag "Login" %>
+<%end%>