pages_core 3.4.3 → 3.7.0

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/templates.rb

@@ -1,11 +1,11 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-load "pages_core/templates/block_configuration.rb"
-load "pages_core/templates/configuration_proxy.rb"
-load "pages_core/templates/configuration_handler.rb"
-load "pages_core/templates/configuration.rb"
-load "pages_core/templates/controller_actions.rb"
-load "pages_core/templates/template_configuration.rb"
+require "pages_core/templates/block_configuration"
+require "pages_core/templates/configuration_proxy"
+require "pages_core/templates/configuration_handler"
+require "pages_core/templates/configuration"
+require "pages_core/templates/controller_actions"
+require "pages_core/templates/template_configuration"
 
 module PagesCore
   module Templates
@@ -18,8 +18,8 @@ module PagesCore
 
       def template_paths
         [
-          PagesCore.plugin_root.join("app", "views", "pages", "templates"),
-          Rails.root.join("app", "views", "pages", "templates")
+          PagesCore.plugin_root.join("app/views/pages/templates"),
+          Rails.root.join("app/views/pages/templates")
         ]
       end
 
@@ -30,7 +30,7 @@ module PagesCore
           .uniq
           .compact
           .sort
-          .map { |f| f.gsub(/\.[\w\.]+$/, "") }
+          .map { |f| f.gsub(/\.[\w.]+$/, "") }
       end
 
       def template_files_in_dir(dir)

data/lib/pages_core/templates/block_configuration.rb

@@ -1,16 +1,17 @@
-# encoding: utf-8
+# 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) ? true : false
+        @size == :small
       end
 
       def large?
-        (small?) ? false : true
+        small? ? false : true
       end
     end
   end

data/lib/pages_core/templates/configuration.rb

@@ -1,7 +1,87 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   module Templates
+    # = Template configuration
+    #
+    # Configuration DSL for the page templates. Can be accessed through
+    # +PagesCore::Templates.configure+.
+    #
+    #   PagesCore::Templates.configure do |config|
+    #     # Configuration goes here
+    #   end
+    #
+    # == Configuring templates
+    #
+    # Defaults for all templates can be configured with:
+    #
+    #   config.default do |default|
+    #     default.enabled_blocks %i[name headline body]
+    #     default.files :disabled
+    #   end
+    #
+    # Individual template configurations override the defaults.
+    #
+    #   config.template(:article, :article_alt) do |t|
+    #     t.enabled_blocks %i[name headline excerpt body boxout]
+    #     t.files :enabled
+    #   end
+    #
+    # == Options
+    #
+    # [blocks]
+    #   Yields the block configuration.
+    # [enabled_blocks]
+    #   List of enabled blocks. Default: +%i[headline excerpt body]+
+    # [template]
+    #   Template for all pages, unless overridden with +sub_template+.
+    #   It will attempt to guess based on the parent page if set to
+    #   +:autodetect+, which is the default value. Pass the +:root+
+    #   option to set template at root level.
+    # [image]
+    #   Enable images. Default: +:enabled+
+    # [files]
+    #   Enable file uploads. Default: +:disabled+
+    # [tags]
+    #   Enable tags. Default: +:disabled+
+    # [dates]
+    #   Enable dates. Default: +:disabled+
+    # [sub_template]
+    #   Children of the page will automatically have this template if
+    #   configured. Defaults to +nil+, which fall back to the behaviour
+    #   of +template+.
+    #
+    # == Block configuration
+    #
+    # Blocks can be configured at top level, or per template:
+    #
+    #   config.default do |default|
+    #     default.blocks do |block|
+    #       block.byline("Byline", size: :field)
+    #       block.embed("Video embed", size: :small, description: "Embed code")
+    #     end
+    #     default.enabled_blocks %i[headline byline body embed]
+    #   end
+    #
+    # Valid sizes for text blocks are +:field+ (single line), +:small+
+    # and +:large+.
+    #
+    # === Select blocks
+    #
+    # Blocks can also be selects:
+    #
+    #   block.foobar("Foobar", type: :select, options: %w[Foo Bar Baz])
+    #
+    # Pass a hash for multiple localizations:
+    #
+    #   block.foobar("Foobar", type: :select,
+    #                options: { en: %w[Foo Bar Baz],
+    #                           nb: %w[Fuu Baer Baez] })
+    #
+    # Options can be set at runtime using a Proc:
+    #
+    #   block.foobar("Foobar", type: :select,
+    #                options: -> { FooBar.template_options })
     class Configuration < PagesCore::Templates::ConfigurationHandler
       handle :default do |instance, name, *args|
         if name == :blocks
@@ -14,43 +94,34 @@ module PagesCore
       end
 
       def valid_template_options
-        [
-          :template, :image, :images, :files, :text_filter, :blocks,
-          :enabled_blocks, :sub_template, :comments, :comments_allowed, :tags
-        ]
+        %i[template image images files text_filter blocks
+           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
-        title ||= block_name.to_s.humanize
-        options[:title] = title
+        opts = {
+          title: title || block_name.to_s.humanize,
+          localized: true
+        }.merge(options)
         if tpl_name == :_defaults
-          set([:default, :blocks, block_name], options)
+          set([:default, :blocks, block_name], opts)
         else
-          set([:templates, tpl_name, :blocks, block_name], options)
+          set([:templates, tpl_name, :blocks, block_name], opts)
         end
       end
 
       def configure_template(template_name, setting, value, options = {})
         template_name = template_name.to_sym
         setting = setting.to_sym
-        if valid_template_options.include?(setting)
-          value = true  if value == :enabled
-          value = false if value == :disabled
-          template_config = {
-            setting => {
-              value:   value,
-              options: options
-            }
-          }
-          if template_name == :_defaults
-            set([:default], template_config)
-          else
-            set([:templates, template_name], template_config)
-          end
-        else
-          fail "Invalid template configuration value: #{setting.inspect}"
+        unless valid_template_options.include?(setting)
+          raise "Invalid template configuration value: #{setting.inspect}"
         end
+
+        set(
+          template_path(template_name),
+          template_config(setting, value, options)
+        )
       end
 
       def blocks(template_name = :_defaults, &block)
@@ -60,22 +131,32 @@ module PagesCore
       end
 
       def templates(*tpl_args, &block)
-        template_names = tpl_args.flatten.map(&:to_sym)
+        names = tpl_args.flatten.map(&:to_sym)
         proxy(block) do |name, *args|
           if name == :blocks
             proxy(args.first.is_a?(Proc) ? args.first : nil) do |n2, *a2|
-              template_names.each do |template_name|
-                configure_block(template_name, n2, *a2)
-              end
+              names.each { |t| configure_block(t, n2, *a2) }
             end
           else
-            template_names.each do |template_name|
-              configure_template(template_name, name, *args)
-            end
+            names.each { |t| configure_template(t, name, *args) }
           end
         end
       end
-      alias_method :template, :templates
+      alias template templates
+
+      private
+
+      def template_config(setting, value, options)
+        value = true if value == :enabled
+        value = false if value == :disabled
+        { setting => { value: value, options: options } }
+      end
+
+      def template_path(name)
+        return [:default] if name == :_defaults
+
+        [:templates, name]
+      end
     end
   end
 end

data/lib/pages_core/templates/configuration_handler.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   module Templates
@@ -21,12 +21,12 @@ module PagesCore
       end
 
       def method_missing(method_name, *args, &block)
-        if self.class.handle_blocks.keys.include?(method_name)
+        if self.class.handle_blocks.key?(method_name)
           proxy = PagesCore::Templates::ConfigurationProxy.new(
             self.class.handle_blocks[method_name],
             self
           )
-          block.call(proxy) if block
+          yield(proxy) if block
           proxy
         else
           super
@@ -35,10 +35,14 @@ 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
 
+      def respond_to_missing?(method_name)
+        self.class.handle_blocks.key?(method_name)
+      end
+
       def set(stack, value)
         @configuration ||= {}
         value = true  if value == :enabled
@@ -54,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,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   module Templates
@@ -9,20 +9,20 @@ module PagesCore
       end
 
       def method_missing(method_name, *args, &block)
-        if @parent
-          if block_given?
-            @callback.call(@parent, method_name, block)
-          else
-            @callback.call(@parent, method_name, *args)
-          end
+        if @parent && block_given?
+          @callback.call(@parent, method_name, block)
+        elsif @parent
+          @callback.call(@parent, method_name, *args)
+        elsif block_given?
+          @callback.call(method_name, block)
         else
-          if block_given?
-            @callback.call(method_name, block)
-          else
-            @callback.call(method_name, *args)
-          end
+          @callback.call(method_name, *args)
         end
       end
+
+      def respond_to_missing?
+        true
+      end
     end
   end
 end

data/lib/pages_core/templates/controller_actions.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   module Templates