camaleon_cms 2.9.2 → 2.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fc3c9c70942e53b927d67366df21d19a549e0a349e8e87ca08f12977c3c5b08
-  data.tar.gz: d0b3948628d2c7c5d5efa55e6bc6c2ef1b90413d2a53764ac85ed281eceab630
+  metadata.gz: c6940e13676d23d32f7eddfc3cabe9cc6639914fc79f5d53497040dc2987fbfb
+  data.tar.gz: 8079bcd83ef28f77f628ad33fbc0bc89f17e2f6ae130868f3d49f112b4cfd1e3
 SHA512:
-  metadata.gz: f6795ac94a6097bafa86c8336f209cb395f2b102db44da96d091ad55b5373bb6a1ed5af876f6facb72ba313d6fa803201d0605e2e55b0f699304dab2df470c6b
-  data.tar.gz: 6045503558fb4aa769b6d3bbd8dfac05357c9e6427134ed2670b3dc08aae94df7b865d69a80f6bdbe950492a439d79345b1f57b94808fbeb78f6acb5868ec90e
+  metadata.gz: 99302745a2adbd3a0bce4c9e85153bd6d216f5fd3d6ed67c038b461e465339de41e386b114d1075dd1471fca07c70c72c8492a5e9fcae28bf49fcc3f91c71389
+  data.tar.gz: e5ee5c70326b92c29e9ca02be583930d1e2a1bc9a6308cf0bc90a090a29a2c2e4b9417ce9958065561b8d5844146844544d341464c268f2ff40baec939dc4b6c

data/README.md

@@ -81,14 +81,13 @@ https://camaleon.website/store/plugins
 * Image/iFrame Lazy Loader - https://github.com/brian-kephart/camaleon_lazy_loader
 * Import / Export - https://github.com/owen2345/camaleon_export_import
 * Lightbox - https://github.com/owen2345/CamaImageLightbox
-* Autocomplete - https://github.com/gaelfokou/cama_autocomplete
 * Permissions for External Menus - https://github.com/owen2345/cama_external_menu
 * TinyMCE Template Integration - https://github.com/owen2345/Camaleon-Tinymce-Templates
 * Download Manager - https://github.com/max2320/camaleon-download
 * OAuth - https://github.com/owen2345/camaleon_oauth
-* Visual Editor - Paid Plugin ($) - https://camaleon.website/store/plugins/camaleon_editor
-* Spree Commerce Integration - Paid Plugin ($) - https://camaleon.website/store/plugins/camaleon-spree
-* Admin AJAX - Paid Plugin ($) - https://camaleon.website/store/plugins/admin_ajax
+* Visual Editor - Paid Plugin ($) - https://camaleon.website/store/plugins/camaleon_editor (Github: https://github.com/owen2345/camaleon_editor)
+* Spree Commerce Integration - Paid Plugin ($) - https://camaleon.website/store/plugins/camaleon-spree (Github: https://github.com/owen2345/camaleon-spree)
+* Admin AJAX - Paid Plugin ($) - https://camaleon.website/store/plugins/admin_ajax (Github: https://github.com/owen2345/admin-ajax)
 * **See here for a complete Gemfile**: https://github.com/owen2345/camaleon-cms/blob/master/docs/example_gemfile.rb
 
 ## Camaleon CMS has many useful frontend Themes such as:
@@ -190,6 +189,13 @@ RAILS_ENV=test bundle exec rake app:db:test:prepare
 
 See [docs/security/permissions.md](docs/security/permissions.md) for details on manager permissions, custom fields, and security considerations.
 
+## Hooks
+
+Plugins and themes extend Camaleon by handling named hooks. See [docs/hooks.md](docs/hooks.md) for the
+mechanism (registration via `config.json`, the mutable `args` payload) and a code-derived inventory of the
+hooks core fires, including the session/auth hooks (`user_before_login`, `user_before_register`,
+`after_login`, …).
+
 ## Contributing
 * Fork it.
 * Create a branch (git checkout -b my_feature_branch)
@@ -197,6 +203,13 @@ See [docs/security/permissions.md](docs/security/permissions.md) for details on
 * Push to the branch (git push origin my_feature_branch)
 * Create a pull request from your branch into master (Please be sure to provide enough detail for us to understand what this change is doing)
 
+## Releasing
+
+Releases are cut by the manually-started **Release** GitHub Actions workflow, which builds the gem,
+publishes it to RubyGems, tags the commit and creates the GitHub release. See
+[docs/releasing.md](docs/releasing.md) for the full procedure, what the workflow checks before it
+publishes, and the fully manual fallback.
+
 ## Version History
 
 https://camaleon.website/version-history.html

data/Rakefile

@@ -4,26 +4,13 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'CamaleonCms'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
 APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
 load 'rails/tasks/engine.rake'
 
-load 'rails/tasks/statistics.rake'
-
-Bundler::GemHelper.install_tasks
-
-Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each { |f| load f }
+# Deliberately no Bundler::GemHelper.install_tasks: its `rake release` would tag `v<version>` and
+# push a gem that none of the release checks had seen. Releases go through the Release workflow —
+# see docs/releasing.md, which also covers building and publishing by hand.
 
-require 'rspec/core'
 require 'rspec/core/rake_task'
 
 desc 'Run all specs in spec directory (excluding plugin specs)'

data/app/apps/plugins/attack/admin_controller.rb

@@ -6,12 +6,15 @@ module Plugins
       end
 
       def save_settings
-        current_site.set_meta('attack_config', { get: { sec: params[:attack][:get_sec], max: params[:attack][:get_max] },
-                                                 post: { sec: params[:attack][:post_sec] || 20,
-                                                         max: params[:attack][:post_max] },
-                                                 msg: params[:attack][:msg],
-                                                 ban: params[:attack][:ban],
-                                                 cleared: Time.now })
+        current_site.set_meta(
+          'attack_config', {
+            get: { sec: params[:attack][:get_sec], max: params[:attack][:get_max] },
+            post: { sec: params[:attack][:post_sec] || 20, max: params[:attack][:post_max] },
+            msg: params[:attack][:msg],
+            ban: params[:attack][:ban],
+            cleared: Time.zone.now.iso8601
+          }
+        )
         flash[:notice] = t('plugin.attack.messages.settings_saved').to_s
         redirect_to action: :settings
       end

data/app/apps/plugins/attack/attack_helper.rb

@@ -1,14 +1,14 @@
 module Plugins
   module Attack
     module AttackHelper
-      # here all actions on plugin destroying
+      # Here all actions on the plugin are destroyed
       # plugin: plugin model
       def attack_on_destroy(_plugin)
         current_site.attack.destroy_all
       end
 
-      # here all actions on going to active
-      # you can run sql commands like this:
+      # Here all actions on going to active
+      # you can run SQL commands like this:
       # results = ActiveRecord::Base.connection.execute(query);
       # plugin: plugin model
       def attack_on_active(_plugin)
@@ -16,15 +16,13 @@ module Plugins
                                                  post: { sec: 20, max: 5 },
                                                  msg: I18n.t('plugin.attack.form.request_limit_exceeded').to_s,
                                                  ban: 5,
-                                                 cleared: Time.now })
+                                                 cleared: Time.zone.now.iso8601 })
 
-        unless ActiveRecord::Base.connection.table_exists? 'plugins_attacks'
-          ActiveRecord::Base.connection.create_table :plugins_attacks do |t|
-            t.string :path, index: true
-            t.string :browser_key, index: true
-            t.belongs_to :site, index: true
-            t.datetime 'created_at'
-          end
+        ActiveRecord::Base.connection.create_table :plugins_attacks, if_not_exists: true do |t|
+          t.string :path, index: true
+          t.string :browser_key, index: true
+          t.belongs_to :site, index: true
+          t.datetime 'created_at'
         end
         CamaleonCms::Site.class_eval do
           has_many :attack, class_name: 'Plugins::Attack::Models::Attack'
@@ -38,9 +36,9 @@ module Plugins
       end
 
       def attack_app_before_load
-        cache_ban = Rails.cache.read(cama_get_session_id)
+        cache_ban = Rails.cache.read(attack_ban_cache_key)
         if cache_ban.present? # render banned message if it was banned
-          render html: cache_ban.html_safe, layout: false
+          render html: cache_ban.to_s, layout: false
           return
         end
 
@@ -50,44 +48,56 @@ module Plugins
 
       private
 
+      # Throttle and ban on the client IP, not the session id (audit finding H2). A cookieless /
+      # cookie-rotating request presented a fresh session id every time, so the per-key counter never
+      # accumulated: the throttle never tripped and its per-request DB insert ran unbounded. Keying on
+      # the IP makes the count accumulate, trip the limit, and stop inserting.
+      def attack_client_key
+        request.remote_ip.to_s
+      end
+
+      def attack_ban_cache_key
+        "plugins_attack_ban:#{attack_client_key}"
+      end
+
       def attack_check_request
         return unless current_site
 
         config = current_site.get_meta('attack_config')
-        q = current_site.attack.where(browser_key: cama_get_session_id, path: attack_request_key)
-        return unless config.present?
+        query = current_site.attack.where(browser_key: attack_client_key, path: attack_request_key)
+        return if config.blank?
 
         # clear past requests
         if begin
-          Time.parse(config[:cleared])
+          Time.zone.parse(config[:cleared])
         rescue StandardError
           2.hours.ago
         end < 1.hour.ago
           current_site.attack.where('plugins_attacks.created_at < ?', 1.hour.ago).delete_all
-          config[:cleared] = Time.now.to_s
+          config[:cleared] = Time.zone.now.iso8601 # Use ISO8601 for reliable parsing
           current_site.set_meta('attack_config', config)
         end
 
         # post request
         if request.post? || request.patch?
-          r = q.where(created_at: config[:post][:sec].to_i.seconds.ago..Time.now)
+          r = query.where(created_at: config[:post][:sec].to_i.seconds.ago..Time.zone.now)
           if r.count > config[:post][:max].to_i
-            Rails.cache.write(cama_get_session_id, config[:msg], expires_in: config[:ban].to_i.minutes)
-            # send an email to administrator with request info (ip, browser, if logged then send user info
-            render html: config[:msg].html_safe
+            Rails.cache.write(attack_ban_cache_key, config[:msg], expires_in: config[:ban].to_i.minutes)
+            # Email administrator with request info (ip, browser, if logged, then send user info
+            render html: config[:msg].to_s
             return
           end
 
         # get request
         else
-          r = q.where(created_at: config[:get][:sec].to_i.seconds.ago..Time.now)
+          r = query.where(created_at: config[:get][:sec].to_i.seconds.ago..Time.zone.now)
           if r.count > config[:get][:max].to_i
-            Rails.cache.write(cama_get_session_id, config[:msg], expires_in: config[:ban].to_i.minutes)
-            render html: config[:msg].html_safe
+            Rails.cache.write(attack_ban_cache_key, config[:msg], expires_in: config[:ban].to_i.minutes)
+            render html: config[:msg].to_s
             return
           end
         end
-        q.create
+        query.create
       end
 
       def attack_request_key(method = nil)

data/app/apps/plugins/authoring_post/authoring_post_helper.rb

@@ -24,27 +24,34 @@ module Plugins
       private
 
       def plugin_authoring_form_html(post)
-        "
-    <div class='form-group'>
-      <label class='control-label'>#{t('camaleon_cms.admin.table.author')}</label>
-      <select id='post_user_id' #{if can?(:edit_other,
-                                          post.post_type) && (can?(:edit_publish,
-                                                                   post.post_type) || !post.published?)
-                                    ''
-                                  else
-                                    'disabled'
-                                  end} name='post[user_id]' class='form-control select valid' aria-invalid='false'>#{plugin_authoring_authors_list(post)}</select>
-    </div>
-    "
+        disabled = !(can?(:edit_other, post.post_type) && (can?(:edit_publish, post.post_type) || !post.published?))
+
+        label = tag.label(t('camaleon_cms.admin.table.author'), class: 'control-label')
+        select = content_tag(
+          :select,
+          safe_join(plugin_authoring_authors_list(post)),
+          id: 'post_user_id', name: 'post[user_id]',
+          class: 'form-control select valid',
+          disabled: disabled,
+          'aria-invalid' => 'false'
+        )
+
+        tag.div(safe_join([label, select]), class: 'form-group')
       end
 
       def plugin_authoring_authors_list(post)
         author_id = post.new_record? ? cama_current_user.id : post.author.id
-        ret = ''
-        current_site.users.where('role <> ?', 'client').order(:username).each do |user|
-          ret += "<option value='#{user.id}' #{user.id.eql?(author_id) ? 'selected' : ''}>#{user.username.titleize}#{user.fullname.eql?(user.username.titleize) ? '' : " (#{user.fullname})"}</option>"
+
+        current_site.users.where('role <> ?', 'client').order(:username).map do |user|
+          selected = user.id == author_id
+          titleized_username = user.username.titleize
+          display = if user.fullname == titleized_username
+                      titleized_username
+                    else
+                      "#{titleized_username} (#{user.fullname})"
+                    end
+          tag.option(display, value: user.id, selected: selected)
         end
-        ret
       end
     end
   end

data/app/apps/plugins/front_cache/admin_controller.rb

@@ -5,19 +5,22 @@ module Plugins
 
       def settings
         @caches = current_site.get_meta('front_cache_elements', { paths: [] })
-        @caches[:paths] << '' unless @caches[:paths].present?
+        @caches[:paths] << '' if @caches[:paths].blank?
       end
 
       def save_settings
-        current_site.set_meta('front_cache_elements', { paths: (params[:cache][:paths] || []).compact_blank || [],
-                                                        posts: params[:cache][:posts] || [],
-                                                        post_types: params[:cache][:post_type] || [],
-                                                        skip_posts: params[:cache][:skip_posts] || [],
-                                                        cache_login: params[:cache][:cache_login],
-                                                        home: params[:cache][:home],
-                                                        preserve_cache_on_restart: params[:cache][:preserve_cache_on_restart],
-                                                        invalidate_only: params[:cache][:invalidate_only],
-                                                        cache_counter: current_site.get_meta('front_cache_elements')[:cache_counter] || 0 })
+        current_site.set_meta(
+          'front_cache_elements',
+          {
+            paths: (params[:cache][:paths] || []).compact_blank || [],
+            posts: params[:cache][:posts] || [],
+            post_types: params[:cache][:post_type] || [],
+            skip_posts: params[:cache][:skip_posts] || [],
+            cache_login: params[:cache][:cache_login],
+            home: params[:cache][:home],
+            preserve_cache_on_restart: params[:cache][:preserve_cache_on_restart]
+          }
+        )
         flash[:notice] = t('plugin.front_cache.message.settings_saved').to_s
         redirect_to action: :settings
       end
@@ -25,6 +28,7 @@ module Plugins
       def clean_cache
         flash[:notice] = t('plugin.front_cache.message.cache_destroyed').to_s
         front_cache_clean
+        front_cache_purge_stored_pages
         redirect_to(request.referer || '/admin/plugins')
       end
     end

data/app/apps/plugins/front_cache/config/initializer.rb

@@ -3,7 +3,7 @@ if begin
 rescue StandardError
   false
 end
-  CamaleonCms::Site.all.each do |site|
+  CamaleonCms::Site.find_each do |site|
     site.set_option('refresh_cache', true)
   end
 end

data/app/apps/plugins/front_cache/config/locales/translation.yml

@@ -13,7 +13,6 @@ en:
       pages_of: 'Pages of'
       skip_cache_pages: 'Skip Cache Pages'
       preserve_cache_on_restart: 'Preserve cache on restart'
-      invalidate_only: 'Invalidate the cache instead of deleting it. (Recommended only if you use custom caching in your views. Not recommended when using FileStore, which is the Rails default cache)'
       message:
         please_checkpost_need_cache: 'Please check all posts or post types you need to cache.'
         enabled_cache_inner_content_logged_users: 'Enable cache for inner content for logged users'
@@ -34,7 +33,6 @@ es:
       pages_of: 'Página de'
       skip_cache_pages: 'Saltar página del Caché'
       preserve_cache_on_restart: 'Preservar caché al reiniciar'
-      invalidate_only: 'Invalide el caché en lugar de eliminarlo. (Recomendado sólo si utiliza el almacenamiento en caché personalizado en sus vistas No se recomienda cuando se utiliza FileStore, que es la caché predeterminada de Rails)'
       message:
         please_checkpost_need_cache: 'Por favor, compruebe todos los mensajes o los tipos de correos que necesita para almacenar en caché.'
         enabled_cache_inner_content_logged_users: 'Habilitar caché de contenido interno para usuarios registrados'
@@ -56,7 +54,6 @@ nl:
       pages_of: "Inhoud van"
       skip_cache_pages: 'Cache overslaan'
       preserve_cache_on_restart: 'Bewaar cache bij herstarten'
-      invalidate_only: 'De cache ongeldig maken, in plaats van het te verwijderen. (Alleen aanbevolen als u aangepaste caching gebruikt in uw weergaven. Niet aanbevolen bij het gebruik van FileStore, wat is de standaard cache van de Rails)'
       message:
         please_checkpost_need_cache: "Kijk alle berichten of inhoud type's na die je wil cachen."
         enabled_cache_inner_content_logged_users: 'Activeer cache voor gelogde gebruikers'
@@ -77,7 +74,6 @@ pt-BR:
       pages_of: 'Páginas de'
       skip_cache_pages: 'Saltar Cache de Páginas'
       preserve_cache_on_restart: 'Preserve o cache no reinício'
-      invalidate_only: 'Invalide o cache em vez de excluí-lo. (Recomendado apenas se você usar cache personalizado em suas visualizações. Não recomendado quando usar FileStore, que é o cache padrão do Rails)'
       message:
         please_checkpost_need_cache: 'Por favor verifique todas as publicações ou o tipo do publicação que precisa colocar em cache.'
         enabled_cache_inner_content_logged_users: 'Permitir cache para conteúdo interno de utilizadores ligados'
@@ -98,7 +94,6 @@ pt-BR:
       pages_of: 'Páginas de'
       skip_cache_pages: 'Pular Cache de Páginas'
       preserve_cache_on_restart: 'Preserve o cache no reinício'
-      invalidate_only: 'Invalide o cache em vez de excluí-lo. (Recomendado apenas se você usar cache personalizado em suas visualizações. Não recomendado quando usar FileStore, que é o cache padrão do Rails)'
       message:
         please_checkpost_need_cache: 'Por favor cheque todos os posts ou o tipo do post que você precisa cachear.'
         enabled_cache_inner_content_logged_users: 'Permitir cache para conteúdo interno de usuários logados'
@@ -119,7 +114,6 @@ it:
       pages_of: 'Pagine di'
       skip_cache_pages: 'Pagine da non cachare'
       preserve_cache_on_restart: 'Conserva la cache al riavvio'
-      invalidate_only: 'Invalidate la cache invece di cancellarla. (Consigliato solo se si utilizza la cache personalizzata nelle tue viste. Non è consigliata quando si utilizza FileStore, che è la cache predefinita Rails)'
       message:
         please_checkpost_need_cache: 'Per favore, verifica tutti i tipi di messaggi o e-mail che è necessario memorizzare nella cache.'
         enabled_cache_inner_content_logged_users: 'Attiva il contenuto della cache interna per gli utenti registrati'
@@ -140,7 +134,6 @@ zh-CN:
       pages_of: '页'
       skip_cache_pages: '跳过缓存页面'
       preserve_cache_on_restart: '重新启动时保存缓存'
-      invalidate_only: '使缓存无效，而不是删除它。 （仅当您在视图中使用自定义缓存时才推荐使用FileStore时，建议不要使用Rails默认缓存）'
       message:
         please_checkpost_need_cache: '请检查您需要缓存位内容.'
         enabled_cache_inner_content_logged_users: '为已登录的用户启用内部内容的缓存'

data/app/apps/plugins/front_cache/front_cache_helper.rb

@@ -1,10 +1,18 @@
 module Plugins
   module FrontCache
     module FrontCacheHelper
+      # Upper bound on any stored page's life. Stores whose purge is rescued away (RedisCacheStore
+      # and MemCacheStore reject the matcher) would otherwise keep retired or never-revisited
+      # entries forever — and Redis's default maxmemory-policy is noeviction, so TTL-less bodies
+      # would grow until the shared store refuses writes. An expired entry is an ordinary miss: the
+      # page is re-rendered and re-cached.
+      FRONT_CACHE_EXPIRATION = 1.week
       # cache all pages configured in this plugin's settings for public users
       def front_cache_front_before_load
-        if current_site.get_option('refresh_cache') # clear cache every restart server unless option checked in settings
-          front_cache_clean unless current_site.get_meta('front_cache_elements')[:preserve_cache_on_restart]
+        # invalidate the site's cached pages on the first request after a (re)start, unless
+        # preserve_cache_on_restart is checked in the plugin settings
+        if current_site.get_option('refresh_cache')
+          front_cache_clean unless (current_site.get_meta('front_cache_elements') || {})[:preserve_cache_on_restart]
           current_site.set_option('refresh_cache', false)
         end
 
@@ -12,28 +20,45 @@ module Plugins
         return if signin? || Rails.env.development? || Rails.env.test? || !request.get?
 
         cache_key = front_cache_plugin_cache_key
-        @caches = current_site.get_meta('front_cache_elements')
-        if !flash.keys.present? && front_cache_exist?(cache_key) # recover cache item
+        # Fail closed on a missing settings meta: front_cache runs on every frontend request, so an
+        # absent front_cache_elements (never seeded, or hand-deleted) must degrade to "cache nothing"
+        # rather than raise NoMethodError and 500 the whole public site.
+        @caches = current_site.get_meta('front_cache_elements') || {}
+        # Single read: the old exist?-then-get pair issued two store reads, and an entry vanishing
+        # between them (a concurrent admin purge, TTL expiry) left .gsub running on nil — a
+        # visitor-facing 500.
+        cached_body = flash.keys.blank? ? front_cache_get(cache_key) : nil
+        if cached_body # recover cache item
           Rails.logger.info "Camaleon CMS - readed cache: #{front_cache_plugin_get_path(cache_key)}"
           response.headers['PLUGIN_FRONT_CACHE'] = 'TRUE'
-          args = { data: front_cache_get(cache_key).gsub('{{form_authenticity_token}}', form_authenticity_token) }
+          args = { data: cached_body.gsub('{{form_authenticity_token}}', form_authenticity_token) }
           hooks_run('front_cache_reading_cache', args)
+          # rubocop:disable Rails/OutputSafety -- This replays a trusted cached page body that was already rendered by Rails.
           render html: args[:data].html_safe
+          # rubocop:enable Rails/OutputSafety
           return
         end
 
         @_plugin_do_cache = false
-        if @caches[:paths].include?(request.original_url) || @caches[:paths].include?(request.path_info) || front_cache_plugin_match_path_patterns?(request.original_url, request.path_info) || (params[:action] == 'index' && params[:controller] == 'camaleon_cms/frontend' && @caches[:home].present?) # cache paths and home page
+        # cache paths and home page
+        paths = @caches[:paths] || []
+        if paths.include?(request.original_url) || paths.include?(request.path_info) ||
+           front_cache_plugin_match_path_patterns?(request.original_url, request.path_info) ||
+           (params[:action] == 'index' && params[:controller] == 'camaleon_cms/frontend' && @caches[:home].present?)
           @_plugin_do_cache = true
-        elsif params[:action] == 'post' && params[:controller] == 'camaleon_cms/frontend' && !params[:draft_id].present?
-          if (post = current_site.the_posts.find_by_slug(params[:slug]))
-            post = post.decorate
-            if post.can_visit? && post.visibility != 'private'
-              if (@caches[:skip_posts] || []).include?(post.id.to_s)
-                @_plugin_do_cache = false
-              elsif (@caches[:post_types] || []).include?(post.post_type_id.to_s) || (@caches[:posts] || []).include?(post.id.to_s)
-                @_plugin_do_cache = true
-              end
+        elsif params[:action] == 'post' && params[:controller] == 'camaleon_cms/frontend' && params[:draft_id].blank?
+          # the_post is a single-record lookup (eager: false) -- no listing preloads for one post
+          # Never cache non-public posts. A password-protected post is unlocked per session (visibility_post
+          # audit M2), but the page cache is keyed on the URL alone, so caching an unlocked render would
+          # serve the protected body to visitors who never entered the password. Private posts are already
+          # excluded; password posts must be too.
+          if (post = current_site.the_post(params[:slug])) && post.can_visit? && !%w[private
+                                                                                     password].include?(post.visibility)
+            if (@caches[:skip_posts] || []).include?(post.id.to_s)
+              @_plugin_do_cache = false
+            elsif (@caches[:post_types] || []).include?(post.post_type_id.to_s) ||
+                  (@caches[:posts] || []).include?(post.id.to_s)
+              @_plugin_do_cache = true
             end
           end
         end
@@ -43,7 +68,7 @@ module Plugins
 
       def front_cache_front_after_load
         cache_key = front_cache_plugin_cache_key
-        return unless @_plugin_do_cache && !flash.keys.present?
+        return unless @_plugin_do_cache && flash.keys.blank?
 
         body =
           response
@@ -69,8 +94,7 @@ module Plugins
             post_types: [current_site.post_types.where(slug: 'page').first.id],
             skip_posts: [],
             home: true,
-            cache_login: true,
-            cache_counter: 0
+            cache_login: true
           }
         )
       end
@@ -91,56 +115,104 @@ module Plugins
         arg[:links] << link_to(t('plugin.front_cache.clean_cache'), admin_plugins_front_cache_clean_path)
       end
 
-      # save as cache all post requests
+      # invalidate the page cache on any content-changing request. PUT and DELETE count: a permanent
+      # post deletion rides DELETE (Rack::MethodOverride makes request.post? false for
+      # _method=delete forms), and without a bump the deleted page kept being served from cache.
       def front_cache_post_requests
-        return unless request.post? || request.patch?
+        return unless request.post? || request.put? || request.patch? || request.delete?
+        # A draft autosave (posts/drafts) writes a private draft_child buffer, never published
+        # output, so it must not retire the public page cache — otherwise an open editor's
+        # per-minute autosave keeps the whole site's cache from ever warming.
+        return if params[:controller].to_s.end_with?('posts/drafts')
 
         front_cache_clean
       end
 
-      # clear all frontend cache items
+      # invalidate all cached pages of the current site
       def front_cache_clean
-        @caches = current_site.get_meta('front_cache_elements')
-        if @caches[:invalidate_only]
-          @caches[:cache_counter] += 1
-        else
-          Rails.cache.clear
-          @caches[:cache_counter] = 0
-        end
-        current_site.set_meta('front_cache_elements', @caches)
+        # Security: never Rails.cache.clear — the store is shared, and clearing it on every POST also
+        # destroyed unrelated entries such as the per-IP login brute-force counter (CaptchaHelper),
+        # silently defeating it. Bumping the version compared on every page-cache read (ActiveSupport
+        # `version:`) retires all of this site's pages on any store, with no store enumeration.
+        #
+        # The version lives in its own meta key, apart from the front_cache_elements settings hash:
+        # save_settings rewrites that hash wholesale from an earlier read, so a version stored inside
+        # it could be reverted by a settings save racing a concurrent bump — and a reverted version
+        # resurrects a retired generation as servable.
+        current_site.set_meta('front_cache_counter', front_cache_version + 1)
       end
 
       private
 
+      # Current page-cache version of the site. `.to_i` covers a site that has never invalidated
+      # (missing meta) as version 0 — it must never be nil: an entry written with `version: nil`
+      # would match ANY requested version and become immune to invalidation.
+      def front_cache_version
+        current_site.get_meta('front_cache_counter').to_i
+      end
+
+      # Physically remove every stored page entry of the current site. Only the explicit admin
+      # "Clean cache" action calls this — per-request invalidation is the version bump alone, so the
+      # request path never pays a store walk. The pattern is ^-anchored on purpose: with a store
+      # :namespace, ActiveSupport's key_matcher recognizes only a leading ^ (composing /^ns:<rest>/);
+      # any other source becomes /^ns:.*<source>/, where \A can never match, silently deleting
+      # nothing. Keys are single-line, so ^ cannot over-match. Best-effort: delete_matched is
+      # optional store API (MemCacheStore raises NotImplementedError, RedisCacheStore accepts only
+      # glob Strings, third-party stores raise their own classes) and the version bump has already
+      # retired the pages, so any store error is logged and swallowed.
+      def front_cache_purge_stored_pages
+        Rails.cache.delete_matched(%r{^cama_front_cache/#{current_site.id}/})
+      rescue StandardError, NotImplementedError => e
+        Rails.logger.warn "Camaleon CMS - front_cache purge skipped: #{e.class}: #{e.message}"
+      end
+
       def front_cache_exist?(key)
-        !Rails.cache.read(front_cache_plugin_get_path(key)).nil?
+        !front_cache_get(key).nil?
       end
 
       def front_cache_get(key)
-        Rails.cache.read(front_cache_plugin_get_path(key))
+        Rails.cache.read(front_cache_plugin_get_path(key), version: front_cache_version)
       end
 
+      # One entry per URL: the version is stored inside the entry, so re-caching a page after an
+      # invalidation overwrites the retired body in place on every store — storage is bounded at one
+      # entry per cached URL instead of one per URL per invalidation.
       def front_cache_plugin_cache_create(key, content)
-        Rails.cache.write(front_cache_plugin_get_path(key), content)
+        Rails.cache.write(front_cache_plugin_get_path(key), content,
+                          version: front_cache_version, expires_in: FRONT_CACHE_EXPIRATION)
       end
 
-      # return the physical path of cache directory
+      # return the cache key of a stored page
       # key: (string, optional) the key of the cached page
       def front_cache_plugin_get_path(key = nil)
         if key.nil?
-          "pages/#{@caches[:cache_counter]}/#{current_site.id}"
+          "cama_front_cache/#{current_site.id}"
         else
-          "pages/#{@caches[:cache_counter]}/#{current_site.id}/#{key}"
+          "cama_front_cache/#{current_site.id}/#{key}"
         end
       end
 
       def front_cache_plugin_match_path_patterns?(key, key2)
-        @caches[:paths].any? { |path_pattern| key =~ Regexp.new(path_pattern) || key2 =~ Regexp.new(path_pattern) }
+        front_cache_compiled_path_patterns.any? { |pattern| key =~ pattern || key2 =~ pattern }
+      end
+
+      # Security (audit Low): compile the admin-configured patterns once per request and skip any that
+      # are malformed -- Regexp.new was rebuilt on every request and raised (500) on an invalid pattern
+      # (RegexpError) or a non-String pattern reachable via crafted settings params (TypeError).
+      def front_cache_compiled_path_patterns
+        @front_cache_compiled_path_patterns ||= (@caches[:paths] || []).filter_map do |pattern|
+          Regexp.new(pattern)
+        rescue RegexpError, TypeError
+          nil
+        end
       end
 
       def front_cache_plugin_cache_key
         uri = [request.protocol + request.host_with_port, request.fullpath].join('/')
-        uri.parameterize
+        # Security (audit Low): a lossless key. parameterize lowercased and collapsed every run of
+        # non-alphanumerics to '-', so distinct URLs shared one cache entry -- a visitor to one
+        # cacheable URL could be served the cached body of another.
+        Digest::SHA256.hexdigest(uri)
       end
     end
   end

data/app/apps/plugins/front_cache/views/admin/settings.html.erb

@@ -61,11 +61,6 @@
             <%= check_box_tag("cache[preserve_cache_on_restart]", 1, @caches[:preserve_cache_on_restart]) %>
         </div>
 
-        <div class="form-group">
-            <label><%= t('plugin.front_cache.invalidate_only') %></label><br>
-            <%= check_box_tag("cache[invalidate_only]", 1, @caches[:invalidate_only]) %>
-        </div>
-
         <!--<div class="form-group">-->
             <!--<label><%#= t('plugin.front_cache.message.enabled_cache_inner_content_logged_users') %></label><br>-->
             <!--<%#= check_box_tag("cache[cache_login]", 1, @caches[:cache_login]) %>-->

data/app/apps/plugins/visibility_post/config/config.json

@@ -17,6 +17,7 @@
     "created_post":["plugin_visibility_create_post"],
     "updated_post":["plugin_visibility_create_post"],
     "post_the_content": ["plugin_visibility_post_the_content"],
+    "post_the_excerpt": ["plugin_visibility_post_the_excerpt"],
     "filter_post": ["plugin_visibility_filter_post"],
     "post_can_visit": ["plugin_visibility_can_visit"],
     "list_post_extra_columns": ["plugin_visibility_extra_columns"]