pages_core 3.4.3 → 3.7.0

data/lib/pages_core.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # Ruby Standard Library
 require "digest/sha1"
@@ -21,47 +21,51 @@ require "active_model_serializers"
 require "acts_as_list"
 require "bcrypt"
 require "coffee-script"
+require "country_select"
 require "delayed_job"
 require "dis"
 require "dynamic_image"
+require "healthcheck"
+require "localizable_model"
+require "lograge"
+require "nokogiri"
 require "json"
+require "progress_bar"
 require "rails_i18n"
-require "recaptcha/rails"
 require "RedCloth"
-require "sass"
-require "thinking-sphinx"
+require "sass-rails"
+require "typhoeus"
+require "will_paginate"
 
-# Javascript
+# Must be loaded so that PagesCore::LinkRender can resolve the constant.
+require "will_paginate/view_helpers/action_view"
+
+# Assets
+require "font-awesome-rails"
+require "jquery-ui-rails"
 require "jquery/rails/engine"
-require "jquery/ui/rails"
-require "jquery-cookie-rails"
-require "underscore-rails"
-require "jcrop/rails/v2"
+require "react-rails"
+
+# Pages
+require "pages_core/plugin"
+require "pages_core/admin_menu_item"
+require "pages_core/archive_finder"
+require "pages_core/attachment_embedder"
+require "pages_core/cache_sweeper"
+require "pages_core/digest_verifier"
+require "pages_core/configuration"
+require "pages_core/engine"
+require "pages_core/extensions"
+require "pages_core/page_path_constraint"
+require "pages_core/pages_plugin"
+require "pages_core/pub_sub"
+require "pages_core/templates"
+require "pages_core/version"
 
 module PagesCore
   class NotAuthorized < StandardError; end
 
   class << self
-    def load_dependencies!
-      load "pages_core/plugin.rb"
-
-      load "pages_core/admin_menu_item.rb"
-      load "pages_core/archive_finder.rb"
-      load "pages_core/cache_sweeper.rb"
-      load "pages_core/configuration.rb"
-      load "pages_core/engine.rb"
-      load "pages_core/extensions.rb"
-      load "pages_core/localizable.rb"
-      load "pages_core/pages_plugin.rb"
-      load "pages_core/paginates.rb"
-      load "pages_core/templates.rb"
-      load "pages_core/version.rb"
-    end
-
-    def init!
-      load_dependencies!
-    end
-
     def version
       VERSION
     end
@@ -82,8 +86,6 @@ module PagesCore
         @configuration
       end
     end
-    alias_method :config, :configuration
+    alias config configuration
   end
 end
-
-PagesCore.init!

data/lib/pages_core/admin_menu_item.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   class AdminMenuItem
@@ -6,17 +6,31 @@ module PagesCore
 
     class << self
       def items
-        @items ||= []
+        return [] unless @menu_items
+
+        @menu_items.map { |_, v| v }
       end
 
       def register(label, path, group = :custom, options = {})
         entry = new(label, path, group, options)
-        items << entry unless items.include?(entry)
+        @menu_items ||= {}
+        @menu_items[[group, label]] = entry
       end
     end
 
     def initialize(label, path, group = :custom, options = {})
-      @label, @path, @group, @options = label, path, group, options
+      @label = label
+      @path = path
+      @group = group
+      @options = options
+    end
+
+    def ==(other)
+      other &&
+        other.label == label &&
+        other.path == path &&
+        other.group == group &&
+        other.options == options
     end
   end
 end

data/lib/pages_core/archive_finder.rb

@@ -1,40 +1,46 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   class ArchiveFinder
     def initialize(relation, options = {})
-      @relation, @options = relation, options
+      @relation = relation
+      @options = options
     end
 
     def by_year(year)
       filter_by_time(range_for_year(year))
     end
 
+    def by_year_and_maybe_month(year, month = nil)
+      return by_year(year) unless month
+
+      by_year_and_month(year, month)
+    end
+
     def by_year_and_month(year, month)
       filter_by_time(range_for_year_and_month(year, month))
     end
 
+    def latest_year
+      latest_year_and_month&.first
+    end
+
     def latest_year_and_month
       ordered_relation.first.try do |record|
-        [
-          record[timestamp_attribute].year,
-          record[timestamp_attribute].month
-        ]
+        [record[timestamp_attribute].year,
+         record[timestamp_attribute].month]
       end
     end
 
     def months_in_year(year)
-      by_year(year)
-        .reorder("#{timestamp_attribute} ASC")
-        .group("MONTH(#{timestamp_attribute})")
-        .map { |record| record[timestamp_attribute].month }
+      select_months(by_year(year)).map(&:to_i).sort
     end
 
     def months_in_year_with_count(year)
-      by_year(year)
-        .group("MONTH(#{timestamp_attribute})")
+      group_by_month(by_year(year))
         .count
         .to_a
+        .sort_by(&:first)
     end
 
     def timestamp_attribute
@@ -42,14 +48,19 @@ module PagesCore
     end
 
     def years
-      @relation
-        .reorder("#{timestamp_attribute} ASC")
-        .group("YEAR(#{timestamp_attribute})")
-        .map { |record| record[timestamp_attribute].year }
+      select_years(@relation).map(&:to_i).sort
+    end
+
+    def years_with_count
+      years.map { |year| [year, by_year(year).count] }
     end
 
     private
 
+    def group_by_month(relation)
+      relation.reorder("").group(Arel.sql(month_part))
+    end
+
     def filter_by_time(range)
       @relation.where(
         "#{timestamp_attribute} >= ? AND #{timestamp_attribute} <= ?",
@@ -58,18 +69,36 @@ module PagesCore
       )
     end
 
+    def month_part
+      "date_part('month', #{timestamp_attribute})::integer"
+    end
+
     def range_for_year(year)
-      date_time = DateTime.new(year.to_i, 1, 1)
-      date_time..date_time.end_of_year
+      start_time = Time.zone.local(year.to_i, 1, 1)
+      end_time = start_time.end_of_year
+      (start_time.in_time_zone)..(end_time.in_time_zone)
     end
 
     def range_for_year_and_month(year, month)
-      date_time = DateTime.new(year.to_i, month.to_i, 1)
-      date_time..date_time.end_of_month
+      start_time = Time.zone.local(year.to_i, month, 1)
+      end_time = start_time.end_of_month
+      (start_time.in_time_zone)..(end_time.in_time_zone)
+    end
+
+    def select_months(relation)
+      relation.reorder("").pluck(Arel.sql("DISTINCT #{month_part}"))
+    end
+
+    def select_years(relation)
+      relation.reorder("").pluck(Arel.sql("DISTINCT #{year_part}"))
     end
 
     def ordered_relation
       @relation.reorder("#{timestamp_attribute} DESC")
     end
+
+    def year_part
+      "date_part('year', #{timestamp_attribute})"
+    end
   end
 end

data/lib/pages_core/attachment_embedder.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PagesCore
+  class AttachmentEmbedder
+    include ActionView::Helpers::AssetTagHelper
+
+    attr_reader :attachments
+
+    def initialize(attachments)
+      @attachments = Array(attachments)
+    end
+
+    def to_html
+      embed_attachments(attachments.map { |f| embed_attachment(f) })
+    end
+
+    def embed_attachments(embedded_attachments)
+      embedded_attachments.join(", ")
+    end
+
+    def embed_attachment(attachment)
+      tag.a(attachment.name, class: "file",
+                             href: attachment_path(attachment))
+    end
+
+    private
+
+    def attachment_path(attachment)
+      Rails.application.routes.url_helpers.attachment_path(
+        attachment.digest,
+        attachment,
+        format: attachment.filename_extension
+      )
+    end
+  end
+end

data/lib/pages_core/cache_sweeper.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   class CacheSweeper
@@ -8,102 +8,22 @@ 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 default configuration.
-      def default_config
-        OpenStruct.new(
-          cache_path: ActionController::Base.page_cache_directory,
-          observe: [Page, PageComment, Image],
-          patterns: [
-            /^\/index\.[\w]+$/,
-            /^\/sitemap\.[\w]+$/,
-            %r{^/pages/[\w]{2,3}[/\.](.*)$},
-            %r{^/[\w]{2,3}/(.*)$}
-          ]
-        )
-      end
-
-      # Returns the configuration. Accepts a block, ie:
-      #
-      #   PagesCore::CacheSweeper.config do |c|
-      #     c.observe  += [:store, :store_test]
-      #     c.patterns += [/^\/arkiv(.*)$/, /^\/tests(.*)$/]
-      #   end
       def config
-        @configuration ||= default_config
-        if block_given?
-          yield @configuration
-          extend_observed_models!
-        end
-        @configuration
-      end
-
-      def extend_observed_models!
-        config.observe.each do |klass|
-          if klass.is_a?(Symbol) || klass.is_a?(String)
-            klass = klass.to_s.camelize.constantize
-          end
-          unless klass.include?(PagesCore::Sweepable)
-            klass.send(:include, PagesCore::Sweepable)
-          end
-        end
-      end
-
-      # Purge the entire pages cache
-      def purge!
-        cache_dir = config.cache_path
-        `rm -rf "#{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) }
-            .map(&:to_s)
-        else
-          [config.cache_path.to_s]
-        end
-      end
-
-      def visible_dir?(dir)
-        !(dir =~ /^\./) && File.directory?(File.join(config.cache_path, dir))
-      end
-
-      def sweep_dir(cache_dir)
-        return [] unless File.exist?(cache_dir)
-        swept_files = []
-        Find.find(cache_dir + "/") do |path|
-          Find.prune if skip_path?(cache_dir, path)
-          file = path.gsub(Regexp.new("^#{cache_dir}"), "")
-          config.patterns.each do |p|
-            if file =~ p && File.exist?(path)
-              swept_files << path
-              FileUtils.rm_rf(path)
-            end
-          end
-        end
-        swept_files
-      end
-
-      def skip_path?(cache_dir, path)
-        path =~ Regexp.new("^#{cache_dir}/dynamic_image[s]?")
+        ActiveSupport::Deprecation.warn(
+          "PagesCore::CacheSweeper.config is no longer used."
+        )
+        configuration = OpenStruct.new(patterns: [])
+        yield configuration if block_given?
+        configuration
       end
     end
 

data/lib/pages_core/configuration.rb

@@ -1,7 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-load "pages_core/configuration/base.rb"
-load "pages_core/configuration/pages.rb"
+require "pages_core/configuration/base"
+require "pages_core/configuration/pages"
 
 module PagesCore
   module Configuration

data/lib/pages_core/configuration/base.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   module Configuration
@@ -13,11 +13,7 @@ module PagesCore
         settings[key] = OpenStruct.new(type: type, default: default)
 
         define_method key do |*args|
-          if args.length > 0
-            set(key, *args)
-          else
-            get(key)
-          end
+          args.any? ? set(key, *args) : get(key)
         end
 
         define_method "#{key}=" do |value|
@@ -30,7 +26,8 @@ module PagesCore
       end
 
       def get(key)
-        fail InvalidConfigurationKey unless setting?(key)
+        raise InvalidConfigurationKey unless setting?(key)
+
         if configuration.key?(key)
           configuration[key]
         else
@@ -39,10 +36,11 @@ module PagesCore
       end
 
       def set(key, value)
-        fail InvalidConfigurationKey unless setting?(key)
+        raise InvalidConfigurationKey unless setting?(key)
+
         value = parse_value(key, value)
         unless valid_type?(key, value)
-          fail(
+          raise(
             ArgumentError,
             "expected #{self.class.settings[key].type}, got #{value.class}"
           )
@@ -66,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