pageflow 15.1.0.beta2 → 15.1.0.beta3

data/entry_types/scrolled/lib/pageflow_scrolled/configuration.rb

@@ -0,0 +1,6 @@
+module PageflowScrolled
+  # Configuration options for scrolled entry type
+  class Configuration
+    include Pageflow::EntryTypeConfiguration
+  end
+end

data/entry_types/scrolled/lib/pageflow_scrolled/plugin.rb

@@ -0,0 +1,16 @@
+module PageflowScrolled
+  # @api private
+  class Plugin < Pageflow::Plugin
+    def configure(config)
+      config.entry_types.register(PageflowScrolled.entry_type)
+
+      config.for_entry_type(PageflowScrolled.entry_type) do |c|
+        c.file_types.register(Pageflow::BuiltInFileType.image)
+        c.file_types.register(Pageflow::BuiltInFileType.video)
+        c.file_types.register(Pageflow::BuiltInFileType.audio)
+
+        c.revision_components.register(Storyline)
+      end
+    end
+  end
+end

data/entry_types/scrolled/lib/pageflow_scrolled/seeds.rb

@@ -0,0 +1,133 @@
+require 'uri'
+
+module PageflowScrolled
+  # Following the DSL for seeding the database with Pageflow
+  # models, this adds a method to also seed a PageflowScrolled Entry configuration.
+  # Usage: See pageflow/seeds.rb
+  module Seeds
+    # Create a sample scrolled {Entry} with one section, based on the PageflowNext
+    # presentation example if no scrolled entry with that title exists in the given account.
+    #
+    # @param [Hash] attributes  attributes to override defaults
+    # @option attributes [Account] :account  required
+    # @option attributes [String] :title  required
+    # @option attributes [Array] :chapters  required
+    #   An array of chapter configurations, each containing a key "sections"
+    #   which lists the separate sections of each chapter.
+    #   Each section has a "foreground"-key
+    #   under which an array of content_element configurations is stored.
+    #   Each content_element configuration must provide a "type"-attribute
+    #   to determine the React component used to render this content element.
+    # @option attributes [Hash] :image_files A hash mapping image
+    #   names used in properties like `backdrop.image` to urls.
+    # @yield [entry] a block to be called before the entry is saved
+    # @return [Entry] newly created entry
+    def sample_scrolled_entry(attributes)
+      entry = Pageflow::Entry.where(type_name: 'scrolled')
+                             .where(attributes.slice(:account, :title))
+                             .first
+
+      if entry.nil?
+        entry = Pageflow::Entry.create!(type_name: 'scrolled',
+                                        **attributes.except(:chapters,
+                                                            :image_files)) do |created_entry|
+          created_entry.theming = attributes.fetch(:account).default_theming
+
+          say_creating_scrolled_entry(created_entry)
+          yield(created_entry) if block_given?
+        end
+
+        image_files_by_name = create_image_files(Pageflow::DraftEntry.new(entry),
+                                                 attributes.fetch(:image_files, {}))
+
+        attributes[:chapters].each_with_index do |chapter_config, i|
+          create_chapter(entry, chapter_config, i, image_files_by_name)
+        end
+      end
+
+      entry
+    end
+
+    private
+
+    def say(text)
+      puts(text) unless Rails.env.test?
+    end
+
+    def say_creating_scrolled_entry(entry)
+      say("   sample scrolled entry '#{entry.title}'\n")
+    end
+
+    def create_image_files(draft_entry, image_file_data_by_name)
+      image_file_data_by_name.transform_values do |data|
+        say("     creating image file from #{data['url']}")
+
+        draft_entry.create_file!(Pageflow::BuiltInFileType.image,
+                                 state: 'processed',
+                                 attachment: URI.parse(data['url']),
+                                 configuration: data['configuration'])
+      end
+    end
+
+    def create_chapter(entry, chapter_config, position, image_files_by_name)
+      section_configs = chapter_config.delete('sections') || []
+      chapter = Chapter.create!(
+        revision: entry.draft,
+        configuration: {
+          title: chapter_config['title'],
+          summary: chapter_config['summary']
+        },
+        position: position
+      )
+
+      section_configs.each_with_index do |section_config, i|
+        create_section(chapter, section_config, i, image_files_by_name)
+      end
+    end
+
+    def create_section(chapter, section_config, position, image_files_by_name)
+      content_element_configs = section_config.delete('foreground') || []
+
+      rewrite_file_references!(section_config['backdrop'],
+                               ['image', 'imageMobile'],
+                               image_files_by_name)
+
+      section = Section.create!(chapter: chapter,
+                                configuration: section_config,
+                                position: position)
+
+      content_element_configs.each_with_index do |content_element_config, i|
+        create_content_element(section, content_element_config, i, image_files_by_name)
+      end
+    end
+
+    def create_content_element(section, content_element_config, position, image_files_by_name)
+      if %w[stickyImage inlineImage].include?(content_element_config['type'])
+        rewrite_file_references!(content_element_config['props'], ['id'], image_files_by_name)
+      end
+
+      section.content_elements.create!(
+        type_name: content_element_config['type'],
+        configuration: content_element_config['props'],
+        position: position
+      )
+    end
+
+    def rewrite_file_references!(hash, keys, image_files_by_name)
+      return unless hash
+
+      keys.each do |key|
+        next unless hash[key]
+        next if non_image_reference?(hash[key])
+
+        hash[key] = image_files_by_name.fetch(hash[key]).perma_id
+      end
+    end
+
+    def non_image_reference?(value)
+      value.starts_with?('#') ||
+        value.starts_with?('video') ||
+        value.starts_with?('beforeAfter')
+    end
+  end
+end

data/entry_types/scrolled/spec/factories/chapters.rb

@@ -0,0 +1,12 @@
+module PageflowScrolled
+  FactoryBot.define do
+    factory :scrolled_chapter, class: Chapter do
+      revision
+      configuration do
+        {
+          title: 'chapter title'
+        }
+      end
+    end
+  end
+end

data/entry_types/scrolled/spec/factories/content_elements.rb

@@ -0,0 +1,36 @@
+module PageflowScrolled
+  FactoryBot.define do
+    factory :content_element, class: ContentElement do
+      section
+
+      transient do
+        revision { nil }
+      end
+
+      before(:create) do |content_element, evaluator|
+        if evaluator.revision
+          chapter = create(:scrolled_chapter, revision: evaluator.revision)
+          content_element.section = create(:section, chapter: chapter)
+        end
+      end
+    end
+
+    trait :heading do
+      type_name { 'heading' }
+      configuration do
+        {
+          children: 'A headline'
+        }
+      end
+    end
+
+    trait :text_block do
+      type_name { 'textBlock' }
+      configuration do
+        {
+          children: 'Some sample text with <b>HTML</b>'
+        }
+      end
+    end
+  end
+end

data/entry_types/scrolled/spec/factories/sections.rb

@@ -0,0 +1,26 @@
+module PageflowScrolled
+  FactoryBot.define do
+    factory :section, class: Section do
+      chapter { create(:scrolled_chapter) }
+      configuration do
+        {
+          transition: 'scroll',
+          fullHeight: true,
+          backdrop: {
+            image: 'darkPattern'
+          }
+        }
+      end
+
+      transient do
+        revision { nil }
+      end
+
+      before(:create) do |section, evaluator|
+        if evaluator.revision
+          section.chapter = create(:scrolled_chapter, revision: evaluator.revision)
+        end
+      end
+    end
+  end
+end

data/entry_types/scrolled/spec/factories/storylines.rb

@@ -0,0 +1,12 @@
+module PageflowScrolled
+  FactoryBot.define do
+    factory :scrolled_storyline, class: Storyline do
+      revision
+      configuration do
+        {
+          main: true
+        }
+      end
+    end
+  end
+end

data/lib/generators/pageflow/active_admin_initializer/active_admin_initializer_generator.rb

@@ -7,7 +7,7 @@ module Pageflow
 
       def configure_active_admin_load_path
         prepend_to_file 'config/initializers/active_admin.rb' do
-          "ActiveAdmin.application.load_paths.unshift(Pageflow.active_admin_load_path)\n\n"
+          "ActiveAdmin.application.load_paths += [Pageflow.active_admin_load_path]\n\n"
         end
       end
 

data/lib/generators/pageflow/assets/assets_generator.rb

@@ -16,8 +16,8 @@ module Pageflow
 
         template 'components.js', 'app/assets/javascripts/components.js'
 
-        append_to_file 'app/assets/javascripts/active_admin.js.coffee' do
-          "#= require pageflow/admin\n"
+        append_to_file 'app/assets/javascripts/active_admin.js' do
+          "//= require pageflow/admin\n"
         end
 
         append_to_file 'app/assets/stylesheets/active_admin.scss' do

data/lib/pageflow/built_in_page_types_plugin.rb

@@ -1,9 +1,11 @@
 module Pageflow
   class BuiltInPageTypesPlugin < Plugin
     def configure(config)
-      config.page_types.register(BuiltInPageType.plain)
-      config.page_types.register(BuiltInPageType.video)
-      config.page_types.register(BuiltInPageType.audio)
+      config.for_entry_type(PageflowPaged.entry_type) do |entry_type_config|
+        entry_type_config.page_types.register(BuiltInPageType.plain)
+        entry_type_config.page_types.register(BuiltInPageType.video)
+        entry_type_config.page_types.register(BuiltInPageType.audio)
+      end
     end
   end
 end

data/lib/pageflow/built_in_widget_types_plugin.rb

@@ -1,33 +1,59 @@
 module Pageflow
+  # @api private
   class BuiltInWidgetTypesPlugin < Plugin
     def configure(config)
-      config.widget_types.register(Pageflow::BuiltInWidgetType.default_slideshow_mode,
-                                   default: true)
+      config.for_entry_type(PageflowPaged.entry_type) do |entry_type_config|
+        slideshow_mode(entry_type_config)
+        loading_spinner(entry_type_config)
+        navigation(entry_type_config)
+        player_controls(entry_type_config)
+        cookie_notice(entry_type_config)
+        background_media_control(entry_type_config)
+      end
+    end
+
+    private
+
+    def slideshow_mode(config)
+      config.widget_types.register(BuiltInWidgetType.default_slideshow_mode, default: true)
 
       config.features.register('phone_horizontal_slideshow_mode') do |feature_config|
-        feature_config.widget_types.register(Pageflow::BuiltInWidgetType
-                                               .phone_horizontal_slideshow_mode)
+        feature_config.widget_types.register(BuiltInWidgetType.phone_horizontal_slideshow_mode)
       end
+    end
 
+    def loading_spinner(config)
       config.widget_types.register_widget_defaults('loading_spinner',
                                                    'blur_strength' => 50,
                                                    'remove_logo' => false,
                                                    'invert' => false)
-      config.widget_types.register(Pageflow::BuiltInWidgetType.classic_loading_spinner,
-                                   default: true)
+
+      config.widget_types.register(BuiltInWidgetType.classic_loading_spinner, default: true)
 
       config.features.register('title_loading_spinner') do |feature_config|
-        feature_config.widget_types.register(Pageflow::BuiltInWidgetType.media_loading_spinner)
-        feature_config.widget_types.register(Pageflow::BuiltInWidgetType.title_loading_spinner)
+        feature_config.widget_types.register(BuiltInWidgetType.media_loading_spinner)
+        feature_config.widget_types.register(BuiltInWidgetType.title_loading_spinner)
       end
+
       config.features.enable_by_default('title_loading_spinner')
+    end
+
+    def navigation(config)
+      config.widget_types.register(BuiltInWidgetType.navigation, default: true)
+      config.widget_types.register(BuiltInWidgetType.mobile_navigation, default: true)
+    end
 
-      config.widget_types.register(Pageflow::BuiltInWidgetType.navigation, default: true)
-      config.widget_types.register(Pageflow::BuiltInWidgetType.mobile_navigation, default: true)
+    def player_controls(config)
       config.widget_types.register(Pageflow::BuiltInWidgetType.slim_player_controls)
       config.widget_types.register(Pageflow::BuiltInWidgetType.classic_player_controls, default: true)
-      config.widget_types.register(Pageflow::BuiltInWidgetType.cookie_notice_bar)
-      config.widget_types.register(Pageflow::BuiltInWidgetType.unmute_button, default: true)
+    end
+
+    def cookie_notice(config)
+      config.widget_types.register(BuiltInWidgetType.cookie_notice_bar)
+    end
+
+    def background_media_control(config)
+      config.widget_types.register(BuiltInWidgetType.unmute_button, default: true)
     end
   end
 end

data/lib/pageflow/configuration.rb

@@ -52,11 +52,11 @@ module Pageflow
     #
     # @example
     #
-    # Make a page type only available if a feature flag is set on the
+    # Make a widget type only available if a feature flag is set on the
     # entry or its account
     #
-    #   config.features.register('some_special_page_type' do |config
-    #     config.page_types.register(Pageflow::SomeSpecial.page_type)
+    #   config.features.register('some_special_widget_type' do |config
+    #     config.widget_types.register(Pageflow::SomeSpecial.widget_type)
     #   end
     #
     # @since 0.9
@@ -95,15 +95,16 @@ module Pageflow
     # @since 15.1
     attr_reader :entry_types
 
-    # Register new types of pages.
-    # @return [PageTypes]
-    # @since 0.9
-    attr_reader :page_types
-
-    # List of {FileType} instances provided by page types.
+    # List of {FileType} instances.
+    # Can be registered globally or provided by page types.
     # @return [FileTypes]
     attr_reader :file_types
 
+    # Used to register components whose current state must be
+    # persisted as part of a revision.
+    # @return [RevisionComponents]
+    attr_reader :revision_components
+
     # Used to register new types of widgets to be displayed in entries.
     # @return [WidgetTypes]
     attr_reader :widget_types
@@ -337,7 +338,9 @@ module Pageflow
     # @since 12.2
     attr_accessor :news
 
-    def initialize
+    def initialize(target_type_name = nil)
+      @target_type_name = target_type_name
+
       @paperclip_attachments_version = 'v1'
       @paperclip_s3_root = 'main'
 
@@ -367,11 +370,13 @@ module Pageflow
       @quotas = Quotas.new
       @themes = Themes.new
       @entry_types = EntryTypes.new
-      @page_types = PageTypes.new
-      @file_types = FileTypes.new(page_types)
+      @entry_type_configs = {}
+      @entry_type_configure_blocks = Hash.new { |h, k| h[k] = [] }
+      @file_types = FileTypes.new
       @widget_types = WidgetTypes.new
       @file_importers = FileImporters.new
       @help_entries = HelpEntries.new
+      @revision_components = RevisionComponents.new
 
       @thumbnail_styles = Defaults::THUMBNAIL_STYLES.dup
       @css_rendered_thumbnail_styles = Defaults::CSS_RENDERED_THUMBNAIL_STYLES.dup
@@ -421,6 +426,16 @@ module Pageflow
       plugin.configure(self)
     end
 
+    # Provide backwards compatibility as long as paged entry type has
+    # not been extracted completely. Prefer accessing entry type
+    # specific config via {#for_entry_type} for new code.
+    #
+    # @return {PageTypes}
+    # @since 0.7
+    def page_types
+      get_entry_type_config(PageflowPaged.entry_type).page_types
+    end
+
     # @deprecated Use `config.page_types.register` instead.
     def register_page_type(page_type)
       ActiveSupport::Deprecation.warn('Pageflow::Configuration#register_page_type is deprecated. Use config.page_types.register instead.', caller)
@@ -437,8 +452,28 @@ module Pageflow
       ActiveSupport::Deprecation.warn('Pageflow::Configuration#paperclip_filesystem_root is deprecated.', caller)
     end
 
-    def revision_components
-      page_types.map(&:revision_components).flatten.uniq
+    # Scope configuration to entries of a certain entry type or access
+    # entry type specific configuration. When building a configuration
+    # object for an entry, the passed block is only evaluated when
+    # types match. When building `Pageflow.config`, all
+    # `for_entry_type` blocks are evaluated.
+    #
+    # @param [EntryType] type
+    #
+    # @yieldparam [EntryTypeConfiguration] entry_type_config -
+    #   Instance of configuration class passed as `configuration`
+    #   option during registration of entry type.
+    #
+    # @since 15.1
+    def for_entry_type(type)
+      return if @target_type_name && @target_type_name != type.name
+
+      yield get_entry_type_config(type)
+    end
+
+    # @api private
+    def get_entry_type_config(type)
+      @entry_type_configs[type.name] ||= type.configuration.new(self, type)
     end
 
     # @api private
@@ -464,7 +499,7 @@ module Pageflow
 
     # Restricts the configuration interface to those parts which can
     # be used from inside features.
-    class FeatureLevelConfiguration < Struct.new(:config)
+    FeatureLevelConfiguration = Struct.new(:config) do
       delegate :page_types, to: :config
       delegate :widget_types, to: :config
       delegate :help_entries, to: :config
@@ -472,6 +507,32 @@ module Pageflow
       delegate :admin_attributes_table_rows, to: :config
       delegate :themes, to: :config
       delegate :file_importers, to: :config
+
+      delegate :for_entry_type, to: :config
+    end
+
+    # @api private
+    class ConfigView
+      def initialize(config, entry_type)
+        @config = config
+        @entry_type_config = config.get_entry_type_config(entry_type)
+      end
+
+      def method_missing(method, *args)
+        if @config.respond_to?(method)
+          @config.send(method, *args)
+        elsif @entry_type_config.respond_to?(method)
+          @entry_type_config.send(method, *args)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @config.respond_to?(method_name) ||
+          @entry_type_config.respond_to?(method_name) ||
+          super
+      end
     end
   end
 end