pageflow 17.1.0 → 17.2.0

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

@@ -19,8 +19,8 @@ module PageflowScrolled
 
     # @api private
     def for(entry, request, options = {})
-      items_for_entry(entry, options).each_with_object({}) do |item, result|
-        result[item.name] = item.callable.call(entry:, request:, foo: 1)
+      items_for_entry(entry, options).to_h do |item|
+        [item.name, item.callable.call(entry:, request:, foo: 1)]
       end
     end
 

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

@@ -55,6 +55,26 @@ module PageflowScrolled
     # @since 17.1
     attr_reader :additional_theme_assets
 
+    # Paths or globs of JSON files to read configuration schemas
+    # from. Schemas describe the shape of configuration data of content
+    # elements, sections and other models. Used to find file references
+    # without going through the editor.
+    #
+    # @example
+    #
+    #     config.configuration_schema_load_path += Dir[
+    #       MyEngine.root.join('config', 'configuration_schemas', '*.json').to_s
+    #     ]
+    #
+    # @return [Array<String>]
+    # @since 17.2
+    attr_accessor :configuration_schema_load_path
+
+    # @api private
+    def configuration_schemas
+      @configuration_schemas ||= ConfigurationSchemas.load(configuration_schema_load_path)
+    end
+
     # Determine which vendors a content element will require consent
     # for. Based on the vendor name returned here, the following
     # translations will be used in consent UI components.
@@ -80,18 +100,32 @@ module PageflowScrolled
     # @since 16.1
     attr_reader :content_element_consent_vendors
 
-    # Mapping from URL hosts to consent vendor names. Used for iframe
-    # embed opt-in.
+    # Mapping from URL host+path patterns to consent vendor names.
+    # Used for iframe embed opt-in.
     #
     # @exmaple
     #
-    #     entry_type_config.consent_vendor_host_matchers = {
-    #       /\.some-vendor\.com$/ => 'someVendor'
+    #     entry_type_config.consent_vendor_url_matchers = {
+    #       /\.some-vendor\.com\// => 'someVendor',
+    #       /google\.com\/maps\/embed/ => 'googleMaps'
     #     }
     #
     # @return [Hash<RegExp, String>]
+    # @since 17.2
+    attr_accessor :consent_vendor_url_matchers
+
+    # @deprecated Use {#consent_vendor_url_matchers=} instead.
+    #   Rewrites trailing `$` in patterns to `/` and merges
+    #   into {#consent_vendor_url_matchers}.
     # @since 16.1
-    attr_accessor :consent_vendor_host_matchers
+    def consent_vendor_host_matchers=(matchers)
+      rewritten = matchers.transform_keys do |key|
+        source = key.source.sub(/\$$/, '/')
+        Regexp.new(source, key.options)
+      end
+
+      @consent_vendor_url_matchers.merge!(rewritten)
+    end
 
     # Migrate typography variants to palette colors. Before palette
     # colors for text blocks and headings were introduced, it was
@@ -147,6 +181,14 @@ module PageflowScrolled
     # @since 16.1
     attr_accessor :legacy_typography_variants
 
+    # Whether to include the legacy JavaScript Sprockets asset
+    # (`pageflow_scrolled/legacy`) in the head of published entries and
+    # previews. Defaults to `true`. Set to `false` once no code relies
+    # on the legacy bundle anymore.
+    #
+    # @since 17.2
+    attr_accessor :include_legacy_frontend_javascript
+
     def initialize(*)
       super
       @additional_frontend_packs = AdditionalPacks.new
@@ -154,10 +196,13 @@ module PageflowScrolled
 
       @additional_frontend_seed_data = AdditionalSeedData.new
       @additional_theme_assets = AdditionalThemeAssets.new
+      @configuration_schema_load_path = []
       @content_element_consent_vendors = ContentElementConsentVendors.new
-      @consent_vendor_host_matchers = {}
+      @consent_vendor_url_matchers = {}
 
       @legacy_typography_variants = {}
+
+      @include_legacy_frontend_javascript = true
     end
   end
 end

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

@@ -0,0 +1,91 @@
+module PageflowScrolled
+  # Look up schemas describing the shape of configuration data by the
+  # subject they apply to.
+  class ConfigurationSchemas
+    # Read schemas from JSON files. Each file contains either a single
+    # schema or an array of schemas.
+    #
+    # @param load_path [Array<String>] Paths or globs of JSON files.
+    #
+    # @api private
+    def self.load(load_path)
+      new(load_path.flat_map { |path| Dir[path] }.uniq.sort.flat_map { |file| documents_in(file) })
+    end
+
+    # Configuration objects are rebuilt for each request, so parsing
+    # results outlive them.
+    #
+    # @api private
+    def self.documents_in(file)
+      mtime = File.mtime(file)
+      cached_mtime, documents = cache[file]
+
+      return documents if cached_mtime == mtime
+
+      cache[file] = [mtime, Array.wrap(JSON.parse(File.read(file)))]
+      cache[file].last
+    end
+
+    # @api private
+    def self.cache
+      @cache ||= {}
+    end
+
+    # @api private
+    def initialize(documents)
+      @documents = documents
+    end
+
+    # @api private
+    def find(model:, type_name: nil)
+      by_subject[[model, type_name]]
+    end
+
+    # @api private
+    def find_by_id(id)
+      by_id[id]
+    end
+
+    # @api private
+    def type_names(model:)
+      by_subject.keys.filter_map { |subject_model, type_name| type_name if subject_model == model }
+    end
+
+    private
+
+    def by_subject
+      @by_subject ||= @documents.each_with_object({}) do |document, result|
+        subject = document['x-subject']
+        next unless subject
+
+        key = [subject['model'], subject['typeName']]
+        result[key] = result.key?(key) ? merge(result[key], document) : document
+      end
+    end
+
+    def merge(document, other)
+      document.merge(other) do |key, value, other_value|
+        if %w[properties $defs].include?(key)
+          merge_disjoint(value, other_value, key)
+        else
+          other_value
+        end
+      end
+    end
+
+    def merge_disjoint(value, other_value, key)
+      duplicates = value.keys & other_value.keys
+
+      if duplicates.any?
+        raise(ArgumentError,
+              "Conflicting #{key} in configuration schemas: #{duplicates.join(', ')}")
+      end
+
+      value.merge(other_value)
+    end
+
+    def by_id
+      @by_id ||= @documents.index_by { |document| document['$id'] }
+    end
+  end
+end

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

@@ -21,7 +21,8 @@ module PageflowScrolled
     config.i18n.load_path += Dir[config.root.join('config', 'locales', '**', '*.yml').to_s]
 
     initializer 'pageflow_scrolled.assets.precompile' do |app|
-      app.config.assets.precompile += %w[pageflow_scrolled/legacy.js]
+      app.config.assets.precompile += %w[pageflow_scrolled/legacy.js
+                                         pageflow_scrolled/ui.css]
     end
   end
 end

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

@@ -0,0 +1,71 @@
+module PageflowScrolled
+  # Describe the places where the configurations of an entry can
+  # reference files.
+  #
+  # @api private
+  class EntryFileReferenceLocations
+    def initialize(entry_config, content_elements, include_unused: false)
+      @entry_config = entry_config
+      @content_elements = content_elements
+      @include_unused = include_unused
+    end
+
+    def content_element_locations
+      content_element_type_names.each_with_object({}) do |type_name, result|
+        schema = schemas.find(model: 'contentElement', type_name:)
+
+        if schema
+          result[type_name] = locations.for(schema)
+        else
+          log_missing_schema(type_name)
+        end
+      end
+    end
+
+    def section_locations
+      locations_for(model: 'section')
+    end
+
+    def entry_locations
+      locations_for(model: 'entry')
+    end
+
+    private
+
+    def locations_for(model:)
+      schema = schemas.find(model:)
+
+      unless schema
+        raise("Missing configuration schema for #{model}. Configuration schemas are " \
+              'generated by the JavaScript build or by running ' \
+              'yarn build-configuration-schemas inside the scrolled package.')
+      end
+
+      locations.for(schema)
+    end
+
+    # Content elements of any type can be added in the editor without
+    # reloading the seed.
+    def content_element_type_names
+      if @include_unused
+        schemas.type_names(model: 'contentElement')
+      else
+        @content_elements.map(&:type_name).uniq
+      end
+    end
+
+    def log_missing_schema(type_name)
+      return unless @entry_config.features.enabled?('file_rights_from_references')
+
+      Rails.logger.warn("Missing configuration schema for content element type '#{type_name}'")
+    end
+
+    def schemas
+      @schemas ||= @entry_config.configuration_schemas
+    end
+
+    def locations
+      @locations ||= FileReferenceLocations.new(schemas)
+    end
+  end
+end

data/entry_types/scrolled/lib/pageflow_scrolled/entry_structured_data_types/faq_page.rb

@@ -0,0 +1,58 @@
+module PageflowScrolled
+  module EntryStructuredDataTypes
+    # Generates Schema.org FAQPage structured data from question content elements
+    class FaqPage
+      def initialize(content_element_type_names: ['question'])
+        @content_element_type_names = content_element_type_names
+      end
+
+      def call(entry)
+        content_elements = PageflowScrolled::ContentElement
+                           .all_for_revision(entry.revision)
+                           .where(type_name: @content_element_type_names)
+
+        main_entity = content_elements.map { |element|
+          question_text = extract_text(element.configuration['question'])
+          answer_text = extract_text(element.configuration['answer'])
+
+          next if question_text.blank? || answer_text.blank?
+
+          {
+            '@type' => 'Question',
+            'name' => question_text,
+            'acceptedAnswer' => {
+              '@type' => 'Answer',
+              'text' => answer_text
+            }
+          }
+        }.compact
+
+        {
+          '@type' => 'FAQPage',
+          'mainEntity' => main_entity
+        }
+      end
+
+      private
+
+      def extract_text(slate_json)
+        return '' if slate_json.blank?
+
+        texts = []
+        collect_text(slate_json, texts)
+        texts.join.strip
+      end
+
+      def collect_text(nodes, texts)
+        return unless nodes.is_a?(Array)
+
+        nodes.each do |node|
+          if node.is_a?(Hash)
+            texts << node['text'] if node['text']
+            collect_text(node['children'], texts) if node['children']
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module PageflowScrolled
+  # Flatten a configuration schema into the places where references to
+  # files can occur.
+  class FileReferenceLocations
+    # @api private
+    def initialize(schemas)
+      @schemas = schemas
+    end
+
+    # @api private
+    def for(schema)
+      collect(schema, document: schema, path: [], seen: [])
+    end
+
+    private
+
+    def collect(schema, document:, path:, seen:)
+      if (ref = schema['$ref'])
+        return [] if seen.include?(ref)
+
+        schema, document = resolve(ref, document:)
+        seen += [ref]
+      end
+
+      return [] unless schema.is_a?(Hash)
+
+      references = schema['x-fileCollection'] ? [reference(schema, path)] : []
+
+      references +
+        branches(schema).flat_map { |branch| collect(branch, document:, path:, seen:) } +
+        children(schema).flat_map do |name, child|
+          collect(child, document:, path: path + [name], seen:)
+        end
+    end
+
+    def branches(schema)
+      Array(schema['anyOf']) + Array(schema['oneOf'])
+    end
+
+    def reference(schema, path)
+      {
+        'path' => path,
+        'collection' => schema['x-fileCollection'].camelize(:lower),
+        'activeIf' => schema['x-activeIf']
+      }.compact
+    end
+
+    def children(schema)
+      children = schema['properties']&.dup || {}
+      nested = schema['items'] || schema['additionalProperties']
+
+      children['*'] = nested if nested.is_a?(Hash)
+      children
+    end
+
+    def resolve(ref, document:)
+      id, pointer = ref.split('#', 2)
+      target = id.empty? ? document : @schemas.find_by_id(id)
+
+      target ? [dig(target, pointer), target] : [nil, nil]
+    end
+
+    def dig(document, pointer)
+      return document if pointer.blank? || pointer == '/'
+
+      document.dig(*pointer.delete_prefix('/').split('/'))
+    end
+  end
+end