pageflow 15.1.0.beta2 → 15.1.0.beta3

data/lib/pageflow/editor_controller.rb

@@ -0,0 +1,44 @@
+module Pageflow
+  # Concern that can be included in entry type specific controllers
+  # that extend the REST interface used by the editor. Handles
+  # authentication, entry lookup, authorization and edit locking.
+  #
+  # @since 15.1
+  module EditorController
+    extend ActiveSupport::Concern
+
+    include EditLocking
+
+    included do
+      before_action :authenticate_user!
+
+      before_action do
+        begin
+          @entry = DraftEntry.find(params[:entry_id])
+        rescue ActiveRecord::RecordNotFound
+          head :not_found
+        end
+      end
+
+      before_action do
+        begin
+          Ability.new(current_user).authorize!(:update, @entry.to_model)
+        rescue CanCan::AccessDenied
+          head :forbidden
+        end
+      end
+
+      before_action :verify_edit_lock
+
+      before_action do
+        head :bad_request if params[:entry_type] && @entry.entry_type.name != params[:entry_type]
+      end
+    end
+
+    private
+
+    def verify_edit_lock
+      verify_edit_lock!(@entry)
+    end
+  end
+end

data/lib/pageflow/engine.rb

@@ -111,15 +111,14 @@ module Pageflow
       end
     end
 
-    # Precompile additional assets. pageflow/editor.* has to be
-    # provided by the main app.
+    # Precompile additional assets.
     initializer 'pageflow.assets.precompile' do |app|
       app.config.assets.precompile += %w(
-        pageflow/editor.js pageflow/editor.css
         pageflow/application_with_simulated_media_queries.css
         pageflow/print_view.css
         pageflow/lt_ie9.js pageflow/lt_ie9.css pageflow/ie9.js pageflow/ie9.css
         pageflow/vendor.js
+        pageflow/editor/vendor.js
         video-js.swf vjs.eot vjs.svg vjs.ttf vjs.woff
       )
 

data/lib/pageflow/entries_controller_env_helper.rb

@@ -0,0 +1,44 @@
+module Pageflow
+  # A helper module that can be included in an entry type's frontend
+  # app to access the {PublishedEntry}.
+  #
+  # @since 15.1
+  module EntriesControllerEnvHelper
+    module_function
+
+    # Read the {PublishedEntry} from the request env. It will be
+    # placed there by the Pageflow engine before delegating to the
+    # entry type's frontend app.
+    #
+    # Use {EntriesControllerTestHelper} to set up the request
+    # environment in controller tests.
+    def get_published_entry_from_env(env = request.env)
+      EntriesControllerEnvHelper.get_pageflow_hash(env)['published_entry']
+    end
+
+    # Returns `:preview` if a signed in user is currently viewing the
+    # entry via the preview feature. Returns `:published` if the entry
+    # is rendered on a publicly available site.  The information will
+    # be placed in the request env by the Pageflow engine before
+    # delegating to the entry type's frontend app.
+    #
+    # Use {EntriesControllerTestHelper} to set up the request
+    # environment in controller tests.
+    def get_entry_mode_from_env(env = request.env)
+      EntriesControllerEnvHelper.get_pageflow_hash(env)['entry_mode']
+    end
+
+    # @api private
+    def self.add_entry_info_to_env(env, entry:, mode: nil)
+      env['pageflow'] = {'published_entry' => entry, 'entry_mode' => mode}
+    end
+
+    # @api private
+    def self.get_pageflow_hash(env)
+      env.fetch('pageflow') do
+        throw('Missing pageflow key in request env. Use Pageflow::EntriesControllerTestHelper ' \
+              'to set it in controller tests.')
+      end
+    end
+  end
+end

data/lib/pageflow/entry_type.rb

@@ -4,11 +4,28 @@ module Pageflow
   # @since 15.1
   class EntryType
     # @api private
-    attr_reader :name
+    attr_reader :name, :frontend_app, :editor_fragment_renderer, :configuration, :editor_app
 
     # @param name [String] A unique name.
-    def initialize(name:)
+    #
+    # @param frontend_app [#call] A rack app that renders the entry
+    #   when not in the editor (i.e. preview and published entries).
+    #
+    # @param editor_fragment_renderer [PartialEditorFragmentRenderer]
+    #   Inject content into editor HTML and JSON seed templates.
+    #
+    # @param configuration [Class] Class including
+    #   {Pageflow::Configuration::EntryTypeConfiguration}.
+    #
+    # @param editor_app [#call] A rack app that extends the REST
+    #   interface used by editor Backbone collections. Mounted at
+    #   `/editor/entries/:id/<entry_type_name>/`
+    def initialize(name:, frontend_app:, editor_fragment_renderer:, configuration:, editor_app: nil)
       @name = name
+      @frontend_app = frontend_app
+      @editor_fragment_renderer = editor_fragment_renderer
+      @configuration = configuration
+      @editor_app = editor_app
     end
   end
 end

data/lib/pageflow/entry_type_configuration.rb

@@ -0,0 +1,44 @@
+module Pageflow
+  # Include in entry type specific configuration classes.
+  #
+  # @since 15.1
+  module EntryTypeConfiguration
+    # @api private
+    def initialize(config, entry_type)
+      @config = config
+      @features = FeaturesDelegator.new(config, entry_type)
+    end
+
+    attr_reader :features
+
+    delegate :file_types, to: :@config
+    delegate :help_entries, to: :@config
+    delegate :hooks, to: :@config
+    delegate :revision_components, to: :@config
+    delegate :widget_types, to: :@config
+
+    def plugin(plugin)
+      plugin.configure(self)
+    end
+
+    # @api private
+    FeaturesDelegator = Struct.new(:config, :entry_type) do
+      def register(feature, &block)
+        return register(Feature.new(feature, &block)) if feature.is_a?(String)
+
+        entry_type_feature = Feature.new(
+          feature.name,
+          name_translation_key: feature.name_translation_key
+        ) do |feature_config|
+          feature_config.for_entry_type(entry_type, &feature.method(:enable))
+        end
+
+        config.features.register(entry_type_feature)
+      end
+
+      def enable_by_default(name)
+        config.features.enable_by_default(name)
+      end
+    end
+  end
+end

data/lib/pageflow/entry_types.rb

@@ -3,6 +3,8 @@ module Pageflow
   #
   # @since 15.1
   class EntryTypes
+    include Enumerable
+
     # @api private
     def initialize
       @entry_types_by_name = {}
@@ -21,5 +23,25 @@ module Pageflow
         raise "Unknown entry type with name #{name}."
       end
     end
+
+    # @api private
+    def each(&block)
+      @entry_types_by_name.values.each(&block)
+    end
+
+    # @api private
+    def routes(router)
+      each do |entry_type|
+        next unless entry_type.editor_app
+
+        router.instance_eval do
+          nested do
+            scope '/:entry_type', constraints: {entry_type: entry_type.name} do
+              mount entry_type.editor_app, at: '/'
+            end
+          end
+        end
+      end
+    end
   end
 end

data/lib/pageflow/feature.rb

@@ -9,12 +9,22 @@ module Pageflow
     # @return [String]
     attr_reader :name
 
+    # Translation key to represent the feature in the UI.
+    #
+    # @return [String]
+    attr_reader :name_translation_key
+
     # Create a block based feature.
     #
     # @param name [String] Unique identifyer of feature.
+    #
+    # @param name_translation_key [String] Translation key to
+    #   represent the feature in the UI.
+    #
     # @yieldparam config [Configuration] The configuration object to manipulate.
-    def initialize(name, &block)
+    def initialize(name, name_translation_key: nil, &block)
       @name = name
+      @name_translation_key = name_translation_key || "pageflow.#{name}.feature_name"
       @block = block
     end
 
@@ -25,9 +35,5 @@ module Pageflow
     def enable(config)
       @block.call(config) if @block
     end
-
-    def name_translation_key
-      "pageflow.#{name}.feature_name"
-    end
   end
 end

data/lib/pageflow/file_importers.rb

@@ -8,8 +8,8 @@ module Pageflow
       clear
     end
 
-    def register(name, file_importer)
-      @file_importers[name] = file_importer
+    def register(file_importer)
+      @file_importers[file_importer.name] = file_importer
     end
 
     def clear

data/lib/pageflow/file_type.rb

@@ -58,12 +58,13 @@ module Pageflow
     #
     # @example
     #
-    #   Pageflow::FileType.new(model: Pageflow::Rainbow::File,
+    #   Pageflow::FileType.new(model: 'Pageflow::Rainbow::File',
     #                          editor_partial: 'pageflow/rainbow/editor/files/file')
     #
     # @param [Hash] options
     # @option options [ActiveRecord::Base, String] :model
-    #   Required. Model representing the file, or name of that model.
+    #   Required. Name of model representing the file. Model reference
+    #   still works, but is deprecated
     # @option options [String] :partial
     #   Optional. Path of a partial to include in json representations
     #   of the file both inside  the editor and published entries.

data/lib/pageflow/file_types.rb

@@ -2,12 +2,20 @@ module Pageflow
   class FileTypes
     include Enumerable
 
-    def initialize(page_types)
-      @page_types = page_types
+    def initialize
+      @file_types = []
+    end
+
+    def register(file_type)
+      @file_types << file_type
+    end
+
+    def clear
+      @file_types = []
     end
 
     def each(&block)
-      first_level_file_types = @page_types.map(&:file_types).flatten
+      first_level_file_types = trigger_lazy_loading_of_file_types
       lower_level_file_types = search_for_nested_file_types(first_level_file_types)
       (first_level_file_types + lower_level_file_types).uniq(&:model).each(&block)
     end
@@ -39,6 +47,18 @@ module Pageflow
 
     private
 
+    def trigger_lazy_loading_of_file_types
+      # To avoid dependency cycles due to autoloading for model
+      # references that are passed into FileType.new in some plugins,
+      # we allow registering as file types lambdas which resolve to a
+      # page type's file types. After some deprecation period, we
+      # could get rid of this and just set first_level_file_types to
+      # @file_types here.
+      @file_types.map { |file_type|
+        file_type.respond_to?(:call) ? file_type.call : file_type
+      }.flatten
+    end
+
     def search_for_nested_file_types(higher_level_file_types)
       higher_level_file_types.map { |file_type|
         file_type.nested_file_types +

data/lib/pageflow/global_config_api.rb

@@ -44,9 +44,16 @@ module Pageflow
     # @return [Configuration]
     # @since 0.9
     def config_for(target)
-      build_config do |config|
-        config.enable_features(target.enabled_feature_names)
+      config = build_config(target.respond_to?(:type_name) && target.type_name) do |c|
+        c.enable_features(target.enabled_feature_names(c))
       end
+
+      if target.respond_to?(:type_name)
+        config = Configuration::ConfigView.new(config,
+                                               config.entry_types.find_by_name!(target.type_name))
+      end
+
+      config
     end
 
     # Register a block which shall be called after any configuration
@@ -99,8 +106,8 @@ module Pageflow
 
     private
 
-    def build_config(&block)
-      Configuration.new.tap do |config|
+    def build_config(target_type_name = nil)
+      Configuration.new(target_type_name).tap do |config|
         @configure_blocks ||= []
         @after_configure_blocks ||= []
 

data/lib/pageflow/page_types.rb

@@ -32,10 +32,40 @@ module Pageflow
       @page_types.each(&block)
     end
 
+    def setup(config)
+      config.help_entries.register('pageflow.help_entries.page_types', priority: 10)
+      each do |page_type|
+        register_help_entries(config, page_type)
+        register_revision_components(config, page_type)
+        register_file_types(config, page_type)
+      end
+    end
+
     private
 
     def ensure_export_version_implemented(page_type)
       page_type.export_version
     end
+
+    def register_help_entries(config, page_type)
+      config.help_entries.register(page_type.help_entry_translation_key,
+                                   parent: 'pageflow.help_entries.page_types')
+    end
+
+    def register_revision_components(config, page_type)
+      page_type.revision_components.each do |component|
+        config.revision_components.register(component)
+      end
+    end
+
+    def register_file_types(config, page_type)
+      # After a deprecation period against initializing FileType with
+      # a model reference instead of a model name string, we could
+      # rewrite this to register the page type's file types one by one
+      # right here instead of lazily in FileTypes#each.
+      config.file_types.register(
+        -> { page_type.file_types }
+      )
+    end
   end
 end

data/lib/pageflow/partial_editor_fragment_renderer.rb

@@ -0,0 +1,37 @@
+module Pageflow
+  # Helper class to be used as `editor_fragment_renderer` of
+  # {EntryType} objects to render fragments from partials.
+  #
+  # @since 15.1
+  class PartialEditorFragmentRenderer
+    # Create object that implements methods required by
+    # `editor_fragment_renderer` of {EntryType}.
+    #
+    # @param controller [ActionController::Base] Renders partials in
+    #   the context of this controller. The controller determines
+    #   which helpers are available in the template
+    def initialize(controller)
+      @renderer = controller.renderer
+    end
+
+    def head_fragment(entry)
+      render('head', entry)
+    end
+
+    def body_fragment(entry)
+      render('body', entry)
+    end
+
+    def seed_fragment(entry)
+      render('seed', entry, format: :json)
+    end
+
+    private
+
+    def render(partial, entry, format: :html)
+      @renderer.render(partial: partial,
+                       formats: format,
+                       locals: {entry: entry})
+    end
+  end
+end

data/lib/pageflow/revision_component.rb

@@ -12,8 +12,9 @@ module Pageflow
     class PermaIdGenerationAdvisoryLockTimeout < StandardError; end
 
     included do
+      include AutoGeneratedPermaId
+
       belongs_to :revision, class_name: 'Pageflow::Revision', touch: true
-      before_save :ensure_perma_id
     end
 
     def copy_to(revision)
@@ -22,10 +23,6 @@ module Pageflow
       record.save!
     end
 
-    def ensure_perma_id
-      self.perma_id ||= (self.class.maximum(:perma_id) || 0) + 1
-    end
-
     module ClassMethods
       # Recommended way to create revision components. Uses an
       # advisory lock to ensure concurrently created records are not