pages_core 3.4.3 → 3.7.0

data/app/helpers/pages_core/admin/content_tabs_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module Admin
+    module ContentTabsHelper
+      def content_tab(name, options = {}, &block)
+        @content_tabs ||= []
+        return unless block_given?
+
+        tab = {
+          name: name.to_s.humanize,
+          key: options[:key] || name.to_s.underscore.gsub(/\s+/, "_"),
+          options: options,
+          content: capture(&block)
+        }
+        @content_tabs << tab
+        content_tab_tag(tab[:key], tab[:content])
+      end
+
+      private
+
+      def content_tab_tag(key, content)
+        tag.div(content, class: "content_tab",
+                         id: "content-tab-#{key}")
+      end
+    end
+  end
+end

data/app/helpers/pages_core/admin/date_range_helper.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module Admin
+    module DateRangeHelper
+      def page_date_range(page)
+        if page.all_day?
+          date_range(page.starts_at.to_date, page.ends_at.to_date)
+        else
+          date_range(page.starts_at, page.ends_at)
+        end
+      end
+
+      def date_range(starts_at, ends_at)
+        dates = different_year_date_range(starts_at, ends_at) ||
+                different_month_date_range(starts_at, ends_at) ||
+                different_day_date_range(starts_at, ends_at) ||
+                same_day_date_range(starts_at, ends_at)
+        safe_join(dates.map(&:strip), "–".html_safe)
+      end
+
+      private
+
+      def different_year_date_range(starts_at, ends_at)
+        return if starts_at.year == ends_at.year
+
+        [l(starts_at, format: :pages_full), l(ends_at, format: :pages_full)]
+      end
+
+      def different_month_date_range(starts_at, ends_at)
+        return if starts_at.month == ends_at.month
+
+        [l(starts_at, format: :pages_date), l(ends_at, format: :pages_full)]
+      end
+
+      def different_day_date_range(starts_at, ends_at)
+        return if starts_at.day == ends_at.day
+
+        if starts_at.is_a?(Date) && ends_at.is_a?(Date)
+          [l(starts_at, format: :pages_day), l(ends_at, format: :pages_full)]
+        else
+          [l(starts_at, format: :pages_date), l(ends_at, format: :pages_full)]
+        end
+      end
+
+      def same_day_date_range(starts_at, ends_at)
+        if starts_at.is_a?(Date) && ends_at.is_a?(Date)
+          [l(starts_at, format: :pages_full)]
+        else
+          [l(starts_at, format: :pages_full), l(ends_at, format: :pages_time)]
+        end
+      end
+    end
+  end
+end

data/app/helpers/pages_core/admin/form_builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module Admin
+    class FormBuilder < PagesCore::FormBuilder
+      include DynamicImage::Helper
+
+      def rich_text_area(attr, options = {})
+        @template.rich_text_area_tag(
+          "#{object_name}[#{attr}]",
+          object.send(attr),
+          options
+        )
+      end
+
+      def image_uploader(attr, options = {})
+        @template.image_uploader_tag(
+          "#{object_name}[#{foreign_key(attr)}]",
+          object.send(attr),
+          options
+        )
+      end
+
+      def labelled_rich_text_area(attribute, label_text = nil, options = {})
+        labelled_field(attribute, label_text, options) do |opts|
+          rich_text_area(attribute, opts)
+        end
+      end
+
+      def labelled_image_uploader(attribute, label_text = nil, options = {})
+        labelled_field(attribute, label_text, options) do |opts|
+          image_uploader(attribute, opts)
+        end
+      end
+
+      private
+
+      def foreign_key(attr)
+        object.class.reflections[attr.to_s].options[:foreign_key] ||
+          "#{attr}_id".to_sym
+      end
+    end
+  end
+end

data/app/helpers/pages_core/admin/image_uploads_helper.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module Admin
+    module ImageUploadsHelper
+      # Generates tags for an editable dynamic image.
+      def editable_dynamic_image_tag(image, width: 250,
+                                     caption: false, locale: nil)
+        react_component("EditableImage",
+                        editable_image_options(
+                          image,
+                          width: width,
+                          caption: caption,
+                          locale: locale
+                        ).merge(width: width))
+      end
+
+      def image_uploader_tag(name, image, options = {})
+        opts = { caption: false, locale: nil }.merge(options)
+        react_component("ImageUploader",
+                        editable_image_options(
+                          image,
+                          caption: opts[:caption],
+                          locale: opts[:locale]
+                        ).merge(attr: name, alternative: opts[:alternative]))
+      end
+
+      private
+
+      def editable_image_src_options(image, width)
+        return {} unless image
+
+        { src: dynamic_image_path(image, size: "#{width * 2}x"),
+          image: ::Admin::ImageSerializer.new(image) }
+      end
+
+      def editable_image_options(image, width: 250, caption: false, locale: nil)
+        editable_image_src_options(image, width).merge(
+          width: width,
+          caption: caption,
+          locale: locale || I18n.default_locale,
+          locales: PagesCore.config.locales,
+          csrf_token: form_authenticity_token
+        )
+      end
+    end
+  end
+end

data/app/helpers/pages_core/admin/labelled_field_helper.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   module Admin
@@ -19,54 +19,54 @@ module PagesCore
       #   <% end %>
       #
       def labelled_field(field, label, options = {})
-        content_tag(:div, class: labelled_field_class(options)) do
-          (
-           labelled_field_label(label, options) +
-             labelled_field_description(options[:description]) +
-             field +
-             (options[:check_box_description] || "")
-           ).html_safe
+        tag.div(class: labelled_field_class(options)) do
+          safe_join(
+            [labelled_field_label(label, options),
+             labelled_field_description(options[:description]),
+             field,
+             (options[:check_box_description] || "")]
+          )
         end
       end
 
       def image_upload_field(form, label, method = :image, options = {})
         output = ""
         if form.object.send(method)
-          output += "<p>" +
-            dynamic_image_tag(form.object.send(method), size: "120x100") +
-            "</p>"
+          output += tag.p(dynamic_image_tag(form.object.send(method),
+                                            size: "120x100"))
         end
-        output += labelled_field(
+        output + labelled_field(
           form.file_field(method),
           label, { errors: form.object.errors[method] }.merge(options)
         )
-        output.html_safe
       end
 
       private
 
       def labelled_field_class(options = {})
-        if options[:errors] && options[:errors].any?
-          "field field_with_errors"
+        if options[:errors]&.any?
+          "field field-with-errors"
         else
           "field"
         end
       end
 
       def labelled_field_label(label, options = {})
-        content_tag(:label) do
+        tag.label do
           label + labelled_field_errors(options[:errors])
         end
       end
 
       def labelled_field_description(str)
         return "" unless str
-        content_tag(:p, str, class: "description")
+
+        tag.p(str, class: "description")
       end
 
       def labelled_field_errors(errors)
-        return "" unless errors && errors.any?
-        content_tag(:span, class: "error") { Array(errors).last }
+        return "" unless errors&.any?
+
+        tag.span(class: "error") { Array(errors).last }
       end
     end
   end

data/app/helpers/pages_core/admin/page_blocks_helper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module Admin
+    module PageBlocksHelper
+      def page_block_field(form, block_name, block_options)
+        labelled_field(
+          if block_options[:type] == :select
+            page_block_select(form, block_name, block_options)
+          else
+            page_block_text_field(form, block_name, block_options)
+          end,
+          block_options[:title],
+          errors: form.object.errors[block_name],
+          description: block_options[:description]
+        )
+      end
+
+      def page_block_select(form, block_name, block_options)
+        opts = localize_page_select_options(form, block_options)
+        opts = opts.call if opts.is_a?(Proc)
+        opts = opts.map { |v| [v, v] } unless nested_array?(opts)
+        opts = ([["", nil]] + opts).uniq
+
+        value = form.object.send(block_name)
+        opts << [value, value] unless opts.map(&:last).include?(value)
+
+        form.send(:select, block_name, opts)
+      end
+
+      def page_block_text_field(form, block_name, block_options)
+        form.send(
+          block_options[:size] == :field ? :text_field : :rich_text_area,
+          block_name,
+          page_block_field_options(block_options)
+        )
+      end
+
+      private
+
+      def localize_page_select_options(form, block_options)
+        if block_options[:options].is_a?(Hash)
+          block_options[:options][form.object.locale.to_sym]
+        else
+          block_options[:options]
+        end
+      end
+
+      def page_block_classes(class_name, block_options = {})
+        [class_name, block_options[:class]].join(" ").strip
+      end
+
+      def page_block_field_options(block_options = {})
+        opts = { placeholder: block_options[:placeholder] }
+        if block_options[:size] == :field
+          opts.merge(class: page_block_classes("rich", block_options))
+        else
+          opts.merge(
+            class: page_block_classes("rich", block_options),
+            rows: (block_options[:size] == :large ? 15 : 5)
+          )
+        end
+      end
+    end
+  end
+end

data/app/helpers/pages_core/admin/page_json_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module Admin
+    module PageJsonHelper
+      def page_json(page)
+        { id: page.id, param: page.to_param,
+          name: page.name,
+          parent_page_id: page.parent_page_id,
+          locale: page.locale, status: page.status,
+          news_page: page.news_page,
+          published_at: page.published_at,
+          pinned: page.pinned?, starts_at: page.starts_at,
+          permissions: page_permissions(page) }
+      end
+
+      def page_permissions(page)
+        [(:edit if policy(page).edit?),
+         (:create if policy(page).edit?)].compact
+      end
+    end
+  end
+end

data/app/helpers/pages_core/admin/tag_editor_helper.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   module Admin
@@ -9,7 +9,7 @@ module PagesCore
         tags = options[:tags] || Tag.tags_and_suggestions_for(item, limit: 20)
         tagged = options[:tagged] || item.tags
         options[:placeholder] ||= "Add tag..."
-        content_tag(:div, class: "tag-editor clearfix") do
+        tag.div(class: "tag-editor clearfix") do
           form_helper.hidden_field(field_name, class: "serialized_tags") +
             tag_check_boxes(tags, tagged) +
             add_tag_button(options)
@@ -18,27 +18,29 @@ module PagesCore
 
       private
 
+      def tag_check_box(tag_instance, tagged)
+        tag.span(class: :tag) do
+          check_box_tag(
+            "tag-#{tag_instance.id}",
+            1,
+            tagged.include?(tag_instance)
+          ) + tag.span(tag_instance.name, class: :name)
+        end
+      end
+
       def tag_check_boxes(tags, tagged)
-        content_tag(:div, class: :tags) do
-          tags.map do |tag|
-            content_tag(:span, class: :tag) do
-              check_box_tag(
-                "tag-#{tag.id}",
-                1,
-                tagged.include?(tag)
-              ) + content_tag(:span, tag.name, class: :name)
-            end
-          end.join.html_safe
+        tag.div(class: :tags) do
+          safe_join(tags.map { |t| tag_check_box(t, tagged) }, "")
         end
       end
 
       def add_tag_button(options = {})
-        content_tag(:div, class: "add-tag-form") do
+        tag.div(class: "add-tag-form") do
           text_field_tag(
             "add_tag",
             options[:placeholder],
             class: "add-tag"
-          ) + content_tag(:button, "Add", class: "add-tag-button")
+          ) + tag.button("Add", class: "add-tag-button")
         end
       end
     end

data/app/helpers/pages_core/application_helper.rb

@@ -1,42 +1,23 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # Methods added to this helper will be available to all templates
 # in the application.
 module PagesCore
   module ApplicationHelper
+    include PagesCore::AttachmentsHelper
     include PagesCore::HeadTagsHelper
     include PagesCore::ImagesHelper
+    include PagesCore::MetaTagsHelper
+    include PagesCore::OpenGraphTagsHelper
+    include PagesCore::PagePathHelper
 
     def page_link(page, options = {})
       link_locale = options[:locale] || locale
       page.localize(link_locale) do |p|
         title = options[:title] || p.name.to_s
         return title unless conditional_options?(options)
-        url = if p.redirects?
-                p.redirect_path(locale: link_locale)
-              else
-                page_path(link_locale, p)
-              end
-        link_to(title, url, class: options[:class])
-      end
-    end
 
-    def page_url(page_or_locale, page = nil, options = {})
-      if page
-        locale = page_or_locale
-      else
-        ActiveSupport::Deprecation.warn(
-          "Calling page_url without locale is deprecated"
-        )
-        locale = options[:locale] || @locale
-        page = page_or_locale
-      end
-      page.localize(locale) do |p|
-        if p.redirects?
-          p.redirect_path(locale: locale)
-        else
-          super locale, p, options
-        end
+        link_to(title, page_link_path(link_locale, p), class: options[:class])
       end
     end
 
@@ -47,7 +28,7 @@ module PagesCore
         output = capture(page.localize(locale), &block)
         concat(output)
       end
-      (page) ? page.localize(locale) : nil
+      page ? page.localize(locale) : nil
     end
 
     private
@@ -61,5 +42,13 @@ module PagesCore
         true
       end
     end
+
+    def page_link_path(locale, page)
+      if page.redirects?
+        page.redirect_path(locale: locale)
+      else
+        page_path(locale, page)
+      end
+    end
   end
 end