pages_core 3.6.2 → 3.8.2

data/lib/pages_core/cache_sweeper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   class CacheSweeper
     class << self
@@ -6,125 +8,25 @@ module PagesCore
       def disable(&_block)
         old_value = enabled
         self.enabled = false
-        yield
+        yield if block_given?
         self.enabled = old_value
       end
 
       def once(&block)
         disable(&block)
-        PagesCore::SweepCacheJob.perform_later
+        PagesCore::StaticCache.handler.sweep!
       end
 
-      # Returns the configuration. Accepts a block, ie:
-      #
-      #   PagesCore::CacheSweeper.config do |c|
-      #     c.patterns += [/^\/arkiv(.*)$/, /^\/tests(.*)$/]
-      #   end
       def config
-        @configuration ||= default_config
-        yield @configuration if block_given?
-        @configuration
-      end
-
-      # Purge the entire pages cache
-      def purge!
-        cache_dir = config.cache_path
-        FileUtils.rm_rf(Dir.glob("#{cache_dir}/*")) if File.exist?(cache_dir)
-      end
-
-      # Sweep all cached pages
-      def sweep!
-        return [] unless enabled
-        cache_dirs.flat_map { |d| sweep_dir(d) }
-      end
-
-      private
-
-      def cache_dirs
-        if PagesCore.config(:domain_based_cache)
-          Dir.entries(config.cache_path)
-             .select { |d| visible_dir?(d) }
-             .map { |d| File.join(config.cache_path, d).to_s }
-        else
-          [config.cache_path.to_s]
-        end
-      end
-
-      # Returns the default configuration.
-      def default_config
-        OpenStruct.new(cache_path: ActionController::Base.page_cache_directory,
-                       patterns: [%r{^/index\.[\w]+$},
-                                  %r{^/sitemap\.[\w]+$},
-                                  %r{^/pages/[\w]{2,3}[/\.](.*)$},
-                                  %r{^/[\w]{2,3}/(.*)$}])
-      end
-
-      def visible_dir?(dir)
-        dir !~ /^\./ && File.directory?(File.join(config.cache_path, dir))
-      end
-
-      def sweep_dir(cache_dir)
-        PagesCore::CacheSweeper.new(cache_dir).sweep!
+        ActiveSupport::Deprecation.warn(
+          "PagesCore::CacheSweeper.config is no longer used."
+        )
+        configuration = OpenStruct.new(patterns: [])
+        yield configuration if block_given?
+        configuration
       end
     end
 
-    attr_reader :cache_dir
-
     self.enabled ||= true
-
-    def initialize(cache_dir)
-      @cache_dir = cache_dir
-    end
-
-    def sweep!
-      return [] unless File.exist?(cache_dir)
-      swept_files = []
-
-      Find.find(cache_dir + "/") do |path|
-        Find.prune if skip_path?(path) || !File.exist?(path)
-
-        if sweep_file?(path)
-          swept_files << path
-          FileUtils.rm_rf(path)
-        end
-      end
-      swept_files
-    end
-
-    private
-
-    def locales
-      return [I18n.default_locale.to_s] unless PagesCore.config.locales
-
-      ([I18n.default_locale.to_s] +
-        PagesCore.config.locales.keys.map(&:to_s)).uniq
-    end
-
-    def page_path?(relative)
-      return false unless relative =~ /\.html$/
-      page_paths.each do |p|
-        return true if relative.start_with?(p)
-      end
-      false
-    end
-
-    def page_paths
-      @page_paths ||= PagePath.all.flat_map do |p|
-        ["/#{p.path}"] + locales.map { |l| "/#{l}/#{p.path}" }
-      end
-    end
-
-    def pattern_match?(path)
-      PagesCore::CacheSweeper.config.patterns.select { |p| p =~ path }.any?
-    end
-
-    def skip_path?(path)
-      path =~ Regexp.new("^#{cache_dir}/dynamic_image[s]?")
-    end
-
-    def sweep_file?(path)
-      relative = path.gsub(Regexp.new("^#{cache_dir}"), "")
-      pattern_match?(relative) || page_path?(relative)
-    end
   end
 end

data/lib/pages_core/configuration/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module Configuration
     class Base
@@ -25,6 +27,7 @@ module PagesCore
 
       def get(key)
         raise InvalidConfigurationKey unless setting?(key)
+
         if configuration.key?(key)
           configuration[key]
         else
@@ -34,6 +37,7 @@ module PagesCore
 
       def set(key, value)
         raise InvalidConfigurationKey unless setting?(key)
+
         value = parse_value(key, value)
         unless valid_type?(key, value)
           raise(
@@ -60,6 +64,7 @@ module PagesCore
 
       def valid_type?(key, value)
         return true if value.nil?
+
         if type_for(key) == :boolean
           value.is_a?(TrueClass) || value.is_a?(FalseClass)
         else

data/lib/pages_core/configuration/pages.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "pages_core/attachment_embedder"
+require "pages_core/static_cache"
 
 module PagesCore
   module Configuration
@@ -8,13 +11,12 @@ module PagesCore
       setting :localizations,         :boolean, false
       setting :locales,               :hash
       setting :text_filter,           :symbol, :textile
-      setting :page_cache,            :boolean, true
-      setting :domain_based_cache,    :boolean, false
       setting :rss_fulltext,          :boolean, true
       setting :image_fallback_url,    :string
       setting :default_author,        :string
       setting :error_404_layout,      :string
       setting :attachment_embedder,   :object, PagesCore::AttachmentEmbedder
+      setting :static_cache_handler,  :object
     end
   end
 end

data/lib/pages_core/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "pages_core/configuration/base"
 require "pages_core/configuration/pages"
 

data/lib/pages_core/digest_verifier.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   # = Digest Verifier
@@ -42,13 +42,13 @@ module PagesCore
 
     private
 
-    def secure_compare(a, b)
-      return false unless a.bytesize == b.bytesize
+    def secure_compare(value, other)
+      return false unless value.bytesize == other.bytesize
 
-      l = a.unpack "C#{a.bytesize}"
+      l = value.unpack "C#{value.bytesize}"
 
       res = 0
-      b.each_byte { |byte| res |= byte ^ l.shift }
+      other.each_byte { |byte| res |= byte ^ l.shift }
       res.zero?
     end
 

data/lib/pages_core/engine.rb

@@ -1,9 +1,21 @@
+# frozen_string_literal: true
+
 module PagesCore
   class Engine < Rails::Engine
     # config.autoload_paths += Dir["#{config.root}/lib/"]
     # config.autoload_paths += Dir["#{config.root}/lib/pages_core/**/"]
     # config.eager_load_paths += Dir["#{config.root}/lib/pages_core/**/"]
 
+    initializer :factory_bot_definitions do |app|
+      path = File.expand_path("../../spec/factories", __dir__)
+
+      if defined?(FactoryBotRails)
+        app.config.factory_bot.definition_file_paths << path
+        FactoryBot.definition_file_paths =
+          Rails.application.config.factory_bot.definition_file_paths
+      end
+    end
+
     initializer :append_migrations do |app|
       unless app.root.to_s.match root.to_s
         config.paths["db/migrate"].expanded.each do |expanded_path|
@@ -15,21 +27,57 @@ module PagesCore
     # Enable asset precompilation
     initializer :assets do |_config|
       Rails.application.config.assets.precompile += %w[
-        pages/admin.js
+        pages_core/admin-dist.js
         pages/admin.css
         pages/errors.css
+        pages/favicon.gif
+        pages/admin/icon.png
         pages/*.gif
         pages/*.png
         pages/*.jpg
       ]
     end
 
-    initializer :enable_recursive_serialization do |_app|
-      ActiveModelSerializers.config.default_includes = "**"
-    end
-
     initializer :handle_exceptions do |app|
       app.config.exceptions_app = app.routes
+      ActionDispatch::ExceptionWrapper.rescue_responses.merge!(
+        "PagesCore::NotAuthorized" => :forbidden
+      )
+    end
+
+    initializer :healthcheck do |_app|
+      Healthcheck.configure do |config|
+        config.success = 200
+        config.error = 503
+        config.verbose = true
+        config.route = "/healthcheck"
+        config.method = :get
+
+        # -- Checks --
+        config.add_check :database, lambda {
+          ActiveRecord::Base.connection.execute("select 1")
+        }
+        # config.add_check :migrations, lambda {
+        #   ActiveRecord::Migration.check_pending!
+        # }
+        # config.add_check :cache, -> { Rails.cache.read("some_key") }
+      end
+    end
+
+    initializer :lograge do |app|
+      app.config.lograge.enabled = true if ENV["ENABLE_LOGRAGE"]
+      app.config.lograge.formatter = Lograge::Formatters::Json.new
+      app.config.lograge.ignore_actions =
+        ["Healthcheck::HealthchecksController#check"]
+
+      app.config.lograge.custom_options = lambda do |event|
+        exclude_params = %w[controller action format id]
+        { remote_ip: event.payload[:remote_ip],
+          user_id: event.payload[:user_id],
+          user_email: event.payload[:user_email],
+          params: event.payload[:params]
+                       .except(*exclude_params) }
+      end
     end
 
     # React configuration

data/lib/pages_core/extensions/string_extensions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module Extensions
     module StringExtensions
@@ -12,4 +14,4 @@ module PagesCore
   end
 end
 
-String.send(:include, PagesCore::Extensions::StringExtensions)
+String.include PagesCore::Extensions::StringExtensions

data/lib/pages_core/extensions.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require "pages_core/extensions/string_extensions"

data/lib/pages_core/page_path_constraint.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   class PagePathConstraint
     def matches?(request)

data/lib/pages_core/pages_plugin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   class PagesPlugin < Plugin
     class << self
@@ -14,7 +16,7 @@ module PagesCore
     paths["db/migrate"] = "db/migrate"
 
     admin_menu_item "News",  proc { news_admin_pages_path(@locale) }, :pages,
-                    if:      proc { Page.news_pages.any? },
+                    if: proc { Page.news_pages.any? },
                     current: proc { @page && @page.parent.try(&:news_page?) }
 
     admin_menu_item "Pages", proc { admin_pages_path(@locale) }, :pages

data/lib/pages_core/plugin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # module PagesGallery
 #  class Plugin < PagesCore::Plugin
 #    paths['db/migrate'] = 'template/db/migrate'
@@ -21,6 +23,7 @@ module PagesCore
             end
           )
         end
+        super
       end
 
       def admin_menu_item(label, path, group = :custom, options = {})
@@ -35,38 +38,10 @@ module PagesCore
         end
       end
 
-      def migrations
-        plugins.map { |p| p.new.migrations }.flatten.compact
-      end
-
-      def removed_migrations
-        plugins.map { |p| p.new.removed_migrations }.flatten.compact
-      end
-
-      def existing_removed_migrations
-        removed_migrations
-          .select { |m| File.exist?(Rails.root.join("db", "migrate", m)) }
-      end
-
-      def existing_migrations
-        migrations
-          .map { |m| Rails.root.join("db", "migrate", m.basename) }
-          .select { |m| File.exist?(m) }
-      end
-
-      def remove_old_migrations!
-        (existing_removed_migrations + existing_migrations).each do |migration|
-          File.unlink Rails.root.join("db", "migrate", migration)
-        end
-      end
-
       private
 
       def default_paths
-        {
-          "db/migrate"                    => "db/migrate",
-          "config/removed_migrations.yml" => "config/removed_migrations.yml"
-        }
+        { "db/migrate" => "db/migrate" }
       end
     end
 
@@ -78,29 +53,6 @@ module PagesCore
       self.class.paths
     end
 
-    def migrations_path
-      root.join(paths["db/migrate"])
-    end
-
-    def removed_migrations_path
-      root.join(paths["config/removed_migrations.yml"])
-    end
-
-    def migrations?
-      File.exist?(migrations_path) && File.directory?(migrations_path)
-    end
-
-    def migrations
-      Dir.entries(migrations_path)
-         .select { |f| f =~ /\.rb$/ }
-         .map { |f| migrations_path.join(f) }
-    end
-
-    def removed_migrations
-      return unless File.exist?(removed_migrations_path)
-      YAML.load_file(removed_migrations_path)
-    end
-
     protected
 
     def find_root_with_subfolder(subfolder)

data/lib/pages_core/pub_sub.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module PubSub
     class << self

data/lib/pages_core/static_cache/null_handler.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module StaticCache
+    class NullHandler
+      def cache_page(_controller, _request, _response); end
+
+      def cache_page_permanently(_controller, _request, _response); end
+
+      def purge!; end
+
+      def sweep!; end
+
+      def sweep_now!; end
+    end
+  end
+end

data/lib/pages_core/static_cache/page_cache_handler.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module StaticCache
+    class PageCacheHandler
+      def cache_page(controller, _request, _response)
+        controller.class.page_cache_directory = page_cache_directory
+        controller.cache_page
+      end
+
+      def cache_page_permanently(controller, _request, _response)
+        controller.class.page_cache_directory = permanent_page_cache_directory
+        controller.cache_page
+      end
+
+      def purge!
+        return unless PagesCore::CacheSweeper.enabled
+
+        clear_directory(page_cache_directory)
+        clear_directory(permanent_page_cache_directory)
+      end
+
+      def sweep!
+        return unless PagesCore::CacheSweeper.enabled
+
+        PagesCore::SweepCacheJob.perform_later
+      end
+
+      def sweep_now!
+        return unless PagesCore::CacheSweeper.enabled
+
+        clear_directory(page_cache_directory)
+      end
+
+      private
+
+      def cache_root
+        Rails.root.join("public")
+      end
+
+      def clear_directory(path)
+        return unless File.exist?(path)
+
+        FileUtils.rm_rf(Dir.glob("#{path}/*"))
+      end
+
+      def page_cache_directory
+        cache_root.join("static_cache")
+      end
+
+      def permanent_page_cache_directory
+        cache_root.join("cache")
+      end
+    end
+  end
+end

data/lib/pages_core/static_cache/varnish_handler.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module StaticCache
+    class VarnishHandler
+      attr_reader :varnish_url
+
+      def initialize(varnish_url)
+        @varnish_url = varnish_url
+      end
+
+      def cache_page(_controller, request, response)
+        response.set_header("X-Cache-Tags", "static")
+        request.session_options[:skip] = true
+        # controller.expires_in 1.hour, public: true
+      end
+
+      def cache_page_permanently(controller, request, response)
+        response.set_header("X-Cache-Tags", "permanent")
+        request.session_options[:skip] = true
+        controller.expires_in 1.year, public: true
+      end
+
+      def purge!
+        return unless PagesCore::CacheSweeper.enabled
+
+        hydra = Typhoeus::Hydra.hydra
+        hydra.queue(ban_request("static"))
+        hydra.queue(ban_request("permanent"))
+        hydra.run
+      end
+
+      def sweep!
+        return unless PagesCore::CacheSweeper.enabled
+
+        # PagesCore::SweepCacheJob.perform_later
+        sweep_now!
+      end
+
+      def sweep_now!
+        return unless PagesCore::CacheSweeper.enabled
+
+        ban_request("static").run
+      end
+
+      private
+
+      def ban_request(cache_tag)
+        Typhoeus::Request.new(varnish_url,
+                              method: :ban,
+                              headers: { "X-Cache-Tags": cache_tag })
+      end
+    end
+  end
+end

data/lib/pages_core/static_cache.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "pages_core/static_cache/null_handler"
+require "pages_core/static_cache/page_cache_handler"
+require "pages_core/static_cache/varnish_handler"
+
+module PagesCore
+  module StaticCache
+    class << self
+      def handler
+        PagesCore.config.static_cache_handler || default_handler
+      end
+
+      private
+
+      def default_handler
+        if ENV["VARNISH_URL"]
+          return PagesCore::StaticCache::VarnishHandler.new(ENV["VARNISH_URL"])
+        end
+
+        # PagesCore::StaticCache::NullHandler.new
+        PagesCore::StaticCache::PageCacheHandler.new
+      end
+    end
+  end
+end

data/lib/pages_core/templates/block_configuration.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 module PagesCore
   module Templates
     # Configuration for the blocks on an individual template
     class BlockConfiguration
       attr_reader :name, :title, :description, :optional, :enforced
+
       def small?
         @size == :small
       end
 
       def large?
-        small? ? false : true
+        !small?
       end
     end
   end

data/lib/pages_core/templates/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module Templates
     # = Template configuration
@@ -96,7 +98,7 @@ module PagesCore
            enabled_blocks sub_template tags dates]
       end
 
-      def configure_block(tpl_name, block_name, title = false, options = {})
+      def configure_block(tpl_name, block_name, title = nil, options = {})
         block_name = block_name.to_sym
         opts = {
           title: title || block_name.to_s.humanize,
@@ -115,6 +117,7 @@ module PagesCore
         unless valid_template_options.include?(setting)
           raise "Invalid template configuration value: #{setting.inspect}"
         end
+
         set(
           template_path(template_name),
           template_config(setting, value, options)
@@ -151,6 +154,7 @@ module PagesCore
 
       def template_path(name)
         return [:default] if name == :_defaults
+
         [:templates, name]
       end
     end

data/lib/pages_core/templates/configuration_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module Templates
     class ConfigurationHandler
@@ -33,7 +35,7 @@ module PagesCore
 
       def proxy(proxy_block = nil, &callback)
         proxy_object = PagesCore::Templates::ConfigurationProxy.new(callback)
-        proxy_block.call(proxy_object) if proxy_block
+        proxy_block&.call(proxy_object)
         proxy_object
       end
 
@@ -47,7 +49,7 @@ module PagesCore
         value = false if value == :disabled
         stack = [stack] unless stack.is_a?(Enumerable)
         partial_hash = stack.reverse.inject(value) do |hash, key|
-          Hash[key => hash]
+          { key => hash }
         end
         @configuration = @configuration.deep_merge(partial_hash)
         value
@@ -56,7 +58,7 @@ module PagesCore
       def get(*path)
         @configuration ||= {}
         path.inject(@configuration) do |value, key|
-          value && value.is_a?(Hash) && value.key?(key) ? value[key] : nil
+          value.is_a?(Hash) && value&.key?(key) ? value[key] : nil
         end
       end
     end

data/lib/pages_core/templates/configuration_proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module Templates
     class ConfigurationProxy

data/lib/pages_core/templates/controller_actions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module Templates
     module ControllerActions