sitepress-rails 2.0.0.beta3 → 2.0.0.beta8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 308a11e4d4472d626fb4f81581085c06e6ae98b2334f0540c314fd000be6a6c4
-  data.tar.gz: 5fcea186abadb31c9ca5d33b392dc6b5b197c7514421f5a07857d253ef34d051
+  metadata.gz: 8847542b4eda39498873172a50e932d9f227bb5449ad36d164a47f563eb0d058
+  data.tar.gz: 027d9477d21a64e432fa4a5875570cd64b52eb5fb4124479fd360e5a8d5d31fd
 SHA512:
-  metadata.gz: f1fa2ccd305669f776a95e9723fa4aede892ecfce34801481761278da67eeccaf12e056e07b256a81dbf2d253d09a6810f1bb906b09c54a79723a3e24de56967
-  data.tar.gz: 1744e9291b6a268a196baaf57a2f208ddbb59b5ce62839b41bda20ee87debcacd7fa30d224a434a6c55878c7fa68ad74e1845cd21f3fbeb05bbc71937847e454
+  metadata.gz: 2f25562abb42ffa015f2f5736c2fe63e54f773f93f3d25fdcc8704eb23e0636fd9bd1a7e7f6834bf179092c1979620e1f96e7f1e761a1be4f3a8c8d2a2ee7591
+  data.tar.gz: 5fc33c2a07f472d74f1bcde41041ee833fd9bab24985282ad0e512004d5d0adc27b84c5da4cf567257699fe3f830613e040b8ebb7478760cbc137e1ef7e6d67f

data/.gitignore

@@ -0,0 +1,7 @@
+.bundle/
+log/*.log
+pkg/
+test/dummy/db/*.sqlite3
+test/dummy/db/*.sqlite3-journal
+test/dummy/log/*.log
+test/dummy/tmp/

data/bin/rails

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/sitepress-rails/engine', __FILE__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/lib/sitepress/build_paths/directory_index_path.rb

@@ -4,7 +4,7 @@ module Sitepress
     # hosts like S3. To achieve this effect, we have to compile `pages/blah.html.haml`
     # to a folder with the filename `index.html`, so the final path would be `/blah/index.html`
     class DirectoryIndexPath < IndexPath
-      def path_with_default_format
+      def filename_with_default_format
         File.join(node.name, "#{node.default_name}.#{format}")
       end
     end

data/lib/sitepress/build_paths/index_path.rb

@@ -4,16 +4,16 @@ module Sitepress
     # pages too, mainly grabbing the root, which doesn't have a name in the node, to the default_name
     # of the node, which is usually `index`.
     class IndexPath < RootPath
-      def path_without_format
+      def filename_without_format
         node.name
       end
 
-      def path_with_format
+      def filename_with_format
         "#{node.name}.#{format}"
       end
 
-      def path_with_default_format
-        path_with_format
+      def filename_with_default_format
+        filename_with_format
       end
     end
   end

data/lib/sitepress/build_paths/root_path.rb

@@ -13,27 +13,31 @@ module Sitepress
         @resource = resource
       end
 
-      def path
+      def filename
         if format.nil?
-          path_without_format
+          filename_without_format
         elsif format == node.default_format
-          path_with_default_format
+          filename_with_default_format
         elsif format
-          path_with_format
+          filename_with_format
         end
       end
 
+      def path
+        File.join(*resource.lineage, filename)
+      end
+
       protected
-      def path_without_format
+      def filename_without_format
         node.default_name
       end
 
-      def path_with_format
+      def filename_with_format
         "#{node.default_name}.#{format}"
       end
 
-      def path_with_default_format
-        path_with_format
+      def filename_with_default_format
+        filename_with_format
       end
     end
   end

data/lib/sitepress/compiler.rb

@@ -6,63 +6,56 @@ module Sitepress
   class Compiler
     include FileUtils
 
-    class ResourceCompiler
-      attr_reader :resource
+    attr_reader :site, :root_path
 
-      def initialize(resource)
-        @resource = resource
+    def initialize(site:, root_path:, stdout: $stdout)
+      @site = site
+      @stdout = stdout
+      @root_path = Pathname.new(root_path)
+    end
+
+    # Iterates through all pages and writes them to disk
+    def compile
+      status "Building #{site.root_path.expand_path} to #{root_path.expand_path}"
+      resources.each do |resource, path|
+        if resource.renderable?
+          status "  Rendering #{path}"
+          File.open(path.expand_path, "w"){ |f| f.write render resource }
+        else
+          status "  Copying #{path}"
+          cp resource.asset.path, path.expand_path
+        end
+      rescue
+        status "Error building #{resource.inspect}"
+        raise
       end
+      status "Successful build to #{root_path.expand_path}"
+    end
+
+    private
+      def resources
+        Enumerator.new do |y|
+          mkdir_p root_path
 
-      def compilation_path
-        File.join(*resource.lineage, compilation_filename)
+          site.resources.each do |resource|
+            path = build_path resource
+            mkdir_p path.dirname
+            y << [resource, path]
+          end
+        end
       end
 
-      # Compiled assets have a slightly different filename for assets, especially the root node.
-      def compilation_filename(path_builder: BuildPaths::DirectoryIndexPath, root_path_builder: BuildPaths::RootPath)
-        path_builder = resource.node.root? ? root_path_builder : path_builder
-        path_builder.new(resource).path
+      def build_path(resource)
+        path_builder = resource.node.root? ? BuildPaths::RootPath : BuildPaths::DirectoryIndexPath
+        root_path.join path_builder.new(resource).path
       end
 
-      def render(page)
+      def render(resource)
         Renderers::Server.new(resource).render
       end
-    end
 
-    attr_reader :site
-
-    def initialize(site:, stdout: $stdout)
-      @site = site
-      @stdout = stdout
-    end
-
-    # Iterates through all pages and writes them to disk
-    def compile(target_path:)
-      target_path = Pathname.new(target_path)
-      mkdir_p target_path
-      cache_resources = @site.cache_resources
-      @stdout.puts "Compiling #{@site.root_path.expand_path}"
-
-      begin
-        @site.cache_resources = true
-        @site.resources.each do |resource|
-          compiler = ResourceCompiler.new(resource)
-          path = target_path.join(compiler.compilation_path)
-          mkdir_p path.dirname
-          if resource.renderable?
-            @stdout.puts "  Rendering #{path}"
-            File.open(path.expand_path, "w"){ |f| f.write compiler.render(resource) }
-          else
-            @stdout.puts "  Copying #{path}"
-            FileUtils.cp resource.asset.path, path.expand_path
-          end
-        rescue => e
-          @stdout.puts "Error compiling #{resource.inspect}"
-          raise
-        end
-        @stdout.puts "Successful compilation to #{target_path.expand_path}"
-      ensure
-        @site.cache_resources = cache_resources
+      def status(message)
+        @stdout.puts message
       end
-    end
   end
 end

data/lib/sitepress/engine.rb

@@ -20,26 +20,20 @@ module Sitepress
     # Load paths from `Sitepress#site` into rails so it can render views, helpers, etc. properly.
     initializer :set_sitepress_paths, before: :set_autoload_paths do |app|
       app.paths["app/helpers"].push site.helpers_path.expand_path
+      app.paths["app/assets"].push site.assets_path.expand_path
       app.paths["app/views"].push site.root_path.expand_path
       app.paths["app/views"].push site.pages_path.expand_path
     end
 
     # Configure sprockets paths for the site.
-    initializer :set_asset_paths, before: :append_assets_path do |app|
+    initializer :set_manifest_file_path, before: :append_assets_path do |app|
       manifest_file = sitepress_configuration.manifest_file_path.expand_path
-
-      if manifest_file.exist?
-        app.paths["app/assets"].push site.assets_path.expand_path
-        app.config.assets.precompile << manifest_file.to_s
-      else
-        Rails.logger.warn "WARNING: Sitepress could not enable Sprockets because it could not find a manifest file at #{manifest_file.to_s.inspect}."
-      end
+      app.config.assets.precompile << manifest_file.to_s if manifest_file.exist?
     end
 
     # Configure Sitepress with Rails settings.
     initializer :configure_sitepress do |app|
       sitepress_configuration.parent_engine = app
-      sitepress_configuration.cache_resources = app.config.cache_classes
     end
 
     private

data/lib/sitepress/rails.rb

@@ -3,11 +3,11 @@ require "sitepress-core"
 module Sitepress
   autoload :Compiler,                 "sitepress/compiler"
   autoload :RailsConfiguration,       "sitepress/rails_configuration"
-  autoload :RouteConstraint,          "sitepress/route_constraint"
   module Renderers
     autoload :Controller,             "sitepress/renderers/controller"
     autoload :Server,                 "sitepress/renderers/server"
   end
+  autoload :RouteConstraint,          "sitepress/route_constraint"
   module BuildPaths
     autoload :RootPath,               "sitepress/build_paths/root_path"
     autoload :IndexPath,              "sitepress/build_paths/index_path"
@@ -17,6 +17,9 @@ module Sitepress
   # Rescued by ActionController to display page not found error.
   PageNotFoundError = Class.new(StandardError)
 
+  # Raised when any of the Render subclasses can't render a page.
+  RenderingError = Class.new(RuntimeError)
+
   # Make site available via Sitepress.site from Rails app.
   def self.site
     configuration.site

data/lib/sitepress/renderers/controller.rb

@@ -1,18 +1,20 @@
 module Sitepress
   module Renderers
+    # This would be the ideal way to render Sitepress resources, but there's a lot
+    # of hackery involved in getting it to work properly.
     class Controller
-      attr_reader :controller, :page
+      attr_reader :controller, :resource
 
-      def initialize(page, controller = SiteController)
+      def initialize(resource, controller = SiteController)
         @controller = controller
-        @page = page
+        @resource = resource
       end
 
       def render
-        renderer.render inline: page.body,
-          type: page.asset.template_extensions.last,
+        renderer.render inline: resource.body,
+          type: resource.asset.template_extensions.last,
           layout: resolve_layout,
-          content_type: page.mime_type.to_s
+          content_type: resource.mime_type.to_s
       end
 
       private
@@ -29,15 +31,15 @@ module Sitepress
         end
 
         def renderer
-          controller.renderer.new("PATH_INFO" => page.request_path)
+          controller.renderer.new("PATH_INFO" => resource.request_path)
         end
 
         def resolve_layout
-          return page.data.fetch("layout") if page.data.key? "layout"
+          return resource.data.fetch("layout") if resource.data.key? "layout"
           return layout unless has_layout_conditions?
 
           clause, formats = layout_conditions.first
-          format = page.format.to_s
+          format = resource.format.to_s
 
           case clause
           when :only

data/lib/sitepress/renderers/server.rb

@@ -1,21 +1,29 @@
 module Sitepress
   module Renderers
+    # Renders resources by invoking a rack call to the Rails application. From my
+    # experiments rendering as of 2021, this is the most reliable way to render
+    # resources. Rendering via `Renderers::Controller` has lots of various subtle issues
+    # that are surprising. People don't like surprises, so I opted to render through a
+    # slightly heavier stack.
     class Server
-      attr_reader :rails_app, :page
+      attr_reader :rails_app, :resource
 
-      def initialize(page, rails_app = Rails.application)
+      def initialize(resource, rails_app = Rails.application)
         @rails_app = rails_app
-        @page = page
+        @resource = resource
       end
 
       def render
         code, headers, response = rails_app.routes.call env
         response.body
+      rescue => e
+        raise RenderingError.new "Error rendering #{resource.request_path.inspect} at #{resource.asset.path.expand_path.to_s.inspect}:\n#{e.message}"
       end
 
+      private
       def env
         {
-          "PATH_INFO"=> page.request_path,
+          "PATH_INFO"=> resource.request_path,
           "REQUEST_METHOD"=>"GET",
           "rack.input" => "GET"
         }

data/rails/app/controllers/concerns/sitepress/site_pages.rb

@@ -0,0 +1,132 @@
+module Sitepress
+  # Serves up Sitepress site pages in a rails application. This is mixed into the
+  # Sitepress::SiteController, but may be included into other controllers for static
+  # page behavior.
+  module SitePages
+    # Rails 5 requires a format to be given to the private layout method
+    # to return the path to the layout.
+    DEFAULT_PAGE_RAILS_FORMATS = [:html].freeze
+
+    # Default root path of resources.
+    ROOT_RESOURCE_PATH = "".freeze
+
+    extend ActiveSupport::Concern
+
+    included do
+      rescue_from Sitepress::PageNotFoundError, with: :page_not_found
+      helper Sitepress::Engine.helpers
+      helper_method :current_page, :site
+      before_action :append_relative_partial_path, only: :show
+      after_action :reload_site, only: :show
+    end
+
+    def show
+      render_page current_page
+    end
+
+    protected
+    def render_page(page)
+      if page.renderable?
+        render_text_resource page
+      else
+        send_binary_resource page
+      end
+    end
+
+    def current_page
+      @current_page ||= find_resource
+    end
+
+    def site
+      Sitepress.site
+    end
+
+    def page_not_found(e)
+      raise ActionController::RoutingError, e.message
+    end
+
+    private
+    def append_relative_partial_path
+      append_view_path current_page.asset.path.dirname
+    end
+
+    def render_text_resource(resource)
+      render inline: resource.body,
+        type: resource.asset.template_extensions.last,
+        layout: resource.data.fetch("layout", controller_layout),
+        content_type: resource.mime_type.to_s
+    end
+
+    def send_binary_resource(resource)
+      send_file resource.asset.path,
+        disposition: :inline,
+        type: resource.mime_type.to_s
+    end
+
+    # Sitepress::PageNotFoundError is handled in the default Sitepress::SiteController
+    # with an execption that Rails can use to display a 404 error.
+    def get(path)
+      resource = site.resources.get(path)
+      if resource.nil?
+        # TODO: Display error in context of Reources class root.
+        raise Sitepress::PageNotFoundError, "No such page: #{path}"
+      else
+        resource
+      end
+    end
+
+    # Default finder of the resource for the current controller context. If the :resource_path
+    # isn't present, then its probably the root path so grab that.
+    def find_resource
+      get params.fetch(:resource_path, ROOT_RESOURCE_PATH)
+    end
+
+    # Returns the current layout for the inline Sitepress renderer. This is
+    # exposed via some really convoluted private methods inside of the various
+    # versions of Rails, so I try my best to hack out the path to the layout below.
+    def controller_layout
+      private_layout_method = self.method(:_layout)
+      layout =
+        if Rails.version >= "6"
+          private_layout_method.call lookup_context, current_page_rails_formats
+        elsif Rails.version >= "5"
+          private_layout_method.call current_page_rails_formats
+        else
+          private_layout_method.call
+        end
+
+      if layout.instance_of? String # Rails 4 and 5 return a string from above.
+        layout
+      elsif layout # Rails 3 and older return an object that gives us a file name
+        File.basename(layout.identifier).split('.').first
+      else
+        # If none of the conditions are met, then no layout was
+        # specified, so nil is returned.
+        nil
+      end
+    end
+
+    # Rails 5 requires an extension, like `:html`, to resolve a template. This
+    # method returns the intersection of the formats Rails supports from Mime::Types
+    # and the current page's node formats. If nothing intersects, HTML is returned
+    # as a default.
+    def current_page_rails_formats
+      extensions = current_page.node.formats.extensions
+      supported_extensions = extensions & Mime::EXTENSION_LOOKUP.keys
+
+      if supported_extensions.empty?
+        DEFAULT_PAGE_RAILS_FORMATS
+      else
+        supported_extensions.map?(&:to_sym)
+      end
+    end
+
+    def reload_site
+      site.reload! if reload_site?
+    end
+
+    def reload_site?
+      !Rails.configuration.cache_classes
+    end
+  end
+end