perron 0.18.0 → 1.1.0

data/lib/perron/site/builder/feeds/rss.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "nokogiri"
 require "perron/site/builder/feeds/author"
+require "perron/site/builder/feeds/template"
 
 module Perron
   module Site
@@ -9,6 +9,7 @@ module Perron
       class Feeds
         class Rss
           include Feeds::Author
+          include Feeds::Template
 
           def initialize(collection:)
             @collection = collection
@@ -18,31 +19,10 @@ module Perron
           def generate
             return if resources.empty?
 
-            Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
-              xml.rss(:version => "2.0", "xmlns:atom" => "http://www.w3.org/2005/Atom") do
-                xml.channel do
-                  xml.generator "Perron (#{Perron::VERSION})"
-                  xml.title feed_configuration.title.presence || @configuration.site_name
-                  xml.description feed_configuration.description.presence || @configuration.site_description
-                  xml.link @configuration.url
-
-                  Rails.application.routes.url_helpers.with_options(@configuration.default_url_options) do |url|
-                    resources.each do |resource|
-                      xml.item do
-                        xml.guid resource.id
-                        xml.link url.polymorphic_url(resource, ref: feed_configuration.ref).delete_suffix("?ref="), isPermaLink: true
-                        xml.pubDate(resource.published_at&.rfc822)
-                        if (author = author(resource)) && author.email
-                          xml.author author.name ? "#{author.email} (#{author.name})" : author.email
-                        end
-                        xml.title resource.metadata.title
-                        xml.description { xml.cdata(Perron::Markdown.render(resource.content)) }
-                      end
-                    end
-                  end
-                end
-              end
-            end.to_xml
+            template = find_template("rss")
+            return unless template
+
+            render(template, feed_configuration)
           end
 
           private
@@ -54,8 +34,6 @@ module Perron
               .reverse
               .take(feed_configuration.max_items)
           end
-
-          def feed_configuration = @collection.configuration.feeds.rss
         end
       end
     end

data/lib/perron/site/builder/feeds/template.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Perron
+  module Site
+    class Builder
+      class Feeds
+        module Template
+          def find_template(type)
+            collection_name = @collection.name.to_s.pluralize
+
+            user_path = Rails.root.join("app/views/content/#{collection_name}/#{type}.erb")
+            return user_path if File.exist?(user_path)
+
+            default_path = Pathname.new(__dir__).join("#{type}.erb")
+            return default_path if File.exist?(default_path)
+
+            nil
+          end
+
+          def render(template_path, feed_config)
+            template = File.read(template_path)
+            b = binding
+
+            b.local_variable_set(:collection, @collection)
+            b.local_variable_set(:resources, resources)
+            b.local_variable_set(:config, feed_config)
+            b.local_variable_set(:routes, routes)
+            b.local_variable_set(:author, method(:author))
+            b.local_variable_set(:url_for_resource, method(:url_for_resource))
+            b.local_variable_set(:current_feed_url, method(:current_feed_url))
+
+            ERB.new(template).result(b)
+          end
+
+          def url_for_resource(resource)
+            routes
+              .polymorphic_url(resource, **@configuration.default_url_options.merge(ref: feed_configuration.ref))
+              .delete_suffix("?ref=")
+          rescue
+            nil
+          end
+
+          def current_feed_url
+            path = feed_configuration.path || "feed.atom"
+            URI.join(@configuration.url, path).to_s
+          end
+
+          def routes
+            Rails.application.routes.url_helpers
+          end
+
+          def feed_configuration
+            case self.class.name.demodulize
+            when "Rss" then @collection.configuration.feeds.rss
+            when "Atom" then @collection.configuration.feeds.atom
+            when "Json" then @collection.configuration.feeds.json
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/perron/site/builder/feeds.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require "perron/site/builder/feeds/rss"
+require "perron/site/builder/feeds/atom"
 require "perron/site/builder/feeds/json"
+require "perron/site/builder/feeds/rss"
 
 module Perron
   module Site
@@ -17,13 +18,17 @@ module Perron
 
             config = collection.configuration.feeds
 
-            if config.rss.enabled
-              create_file at: config.rss.path, with: Rss.new(collection: collection).generate
+            if config.atom.enabled
+              create_file at: config.atom.path, with: Atom.new(collection: collection).generate
             end
 
             if config.json.enabled
               create_file at: config.json.path, with: Json.new(collection: collection).generate
             end
+
+            if config.rss.enabled
+              create_file at: config.rss.path, with: Rss.new(collection: collection).generate
+            end
           end
         end
 

data/lib/perron/site/builder/page.rb

@@ -11,13 +11,15 @@ module Perron
         end
 
         def render
-          action = route_info[:action]
+          info = route_info
+          return puts "  ❌ ERROR: No route matches '#{@path}'" unless info
+
           request = ActionDispatch::Request.new(env)
           response = ActionDispatch::Response.new
 
-          request.path_parameters = route_info
+          request.path_parameters = info
 
-          controller.dispatch(action, request, response)
+          controller.dispatch(info[:action], request, response)
 
           return puts "  ❌ ERROR: Request failed for '#{@path}' (Status: #{response.status})" unless response.successful?
 
@@ -41,7 +43,20 @@ module Perron
         end
 
         def route_info
-          @route_info ||= Rails.application.routes.recognize_path(@path)
+          @route_info ||= recognize_path_with_pagination_fallback(@path)
+        end
+
+        def recognize_path_with_pagination_fallback(path)
+          Rails.application.routes.recognize_path(path)
+        rescue ActionController::RoutingError
+          return nil unless (match = path.match(/\/(.+)\/page\/(\d+)\//))
+
+          base_path = "/#{match[1]}"
+          page_number = match[2].to_i
+
+          Rails.application.routes.recognize_path(base_path).tap do |route_info|
+            route_info[:page] = page_number
+          end
         end
 
         def env = Rack::MockRequest.env_for(@path, "HTTP_HOST" => Perron.configuration.default_url_options[:host])

data/lib/perron/site/builder/paths.rb

@@ -1,36 +1,98 @@
 # frozen_string_literal: true
 
+require "perron/site/builder/route_resources"
+
 module Perron
   module Site
     class Builder
       class Paths
-        def initialize(collection, paths)
-          @collection, @paths = collection, paths
+        include RouteResources
+
+        def initialize(paths)
+          @paths = paths
         end
 
         def get
-          @paths << routes.public_send(index_path) if routes.respond_to?(index_path)
+          buildable_routes.each do |route|
+            paths_for(route).each { @paths << it }
+          end
+        end
+
+        private
+
+        def paths_for(route)
+          case route.defaults[:action]
+          when "index"
+            required_params = route.required_keys - [:controller, :action]
+            if required_params.any?
+              raise "Route `#{route.name}` (#{route.path.spec}) is an index route but requires parameters #{required_params}. Perron doesn't know how to generate these parameters."
+            end
 
-          if routes.respond_to?(show_path)
-            @collection.send(:load_resources).select(&:buildable?).each do |resource|
-              next if resource.root?
+            base_path = routes.public_send("#{route.name}_path")
+            collection = collection_for(route)
+            return [base_path] unless collection
 
-              @paths << routes.public_send(show_path, resource)
+            pagination = collection.configuration.pagination
+            return [base_path] unless pagination.per_page
 
-              (resource.class.try(:nested_routes) || []).each do |nested|
-                @paths << routes.polymorphic_path([resource, nested])
-              end
+            total = collection.all.count
+            total_pages = (total.to_f / pagination.per_page).ceil
+            return [base_path] if total_pages <= 1
+
+            [base_path] + (2..total_pages).map do |page_number|
+              build_paginated_path(route, page_number, pagination.path_template)
             end
+          when "show" then show_paths_for(route)
+          else []
           end
         end
 
-        private
+        def build_paginated_path(route, page_number, path_template)
+          routes.public_send("#{route.name}_path")
+            .sub(/\/$/, "") + path_template.sub(":page", page_number.to_s)
+        end
+
+        def show_paths_for(route)
+          resources_for(route).reject(&:root?).map do |resource|
+            routes.public_send("#{route.name}_path", resource)
+          end
+        end
 
         def routes = Rails.application.routes.url_helpers
 
-        def index_path = "#{@collection.name}_path"
+        class ConstraintCollection
+          def initialize(values)
+            @values = values
+          end
 
-        def show_path = "#{@collection.name.singularize}_path"
+          def load_resources
+            @values.map { ConstraintResource.new(it) }
+          end
+        end
+
+        class ConstraintResource
+          def initialize(value)
+            @value = value
+          end
+
+          def to_param = @value
+
+          def buildable? = true
+
+          def root? = false
+
+          def metadata = Metadata.new
+
+          class Metadata
+            def sitemap = nil
+
+            def sitemap_priority = nil
+
+            def sitemap_change_frequency = nil
+
+            def updated_at = nil
+          end
+        end
       end
     end
   end

data/lib/perron/site/builder/route_resources.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Perron
+  module Site
+    class Builder
+      module RouteResources
+        def buildable_routes
+          Rails.application.routes.routes.select do |route|
+            route.defaults[:controller]&.start_with?("content/") &&
+              %w[index show].include?(route.defaults[:action])
+          end
+        end
+
+        def resources_for(route)
+          constraint_resources = constraint_resources_from(route)
+          return constraint_resources if constraint_resources.any?
+
+          collection = collection_for(route)
+          return [] unless collection
+
+          resources = collection.send(:load_resources).select(&:buildable?)
+          constraint = route.path.requirements[:id]
+
+          constraint.is_a?(Regexp) ? resources.select { constraint.match?(it.to_param) } : resources
+        end
+
+        def collection_for(route)
+          collection = standard_collection(route)
+          return collection if collection
+
+          collection = parent_collection(route)
+          return collection if collection
+
+          constraint_collection(route)
+        end
+
+        private
+
+        def standard_collection(route)
+          controller_class = "#{route.defaults[:controller]}_controller".classify.constantize
+          collection_name = controller_class.respond_to?(:collection_name) ? controller_class.collection_name : route.defaults[:controller].split("/").last.chomp("_controller")
+
+          Perron::Site.find_collection(collection_name)
+        rescue NameError
+          Perron::Site.find_collection(route.defaults[:controller].split("/").last.chomp("_controller"))
+        end
+
+        def parent_collection(route)
+          parent_controller = route.defaults[:controller].split("/")[-2]
+          return nil unless parent_controller
+
+          Perron::Site.find_collection(parent_controller.chomp("_controller"))
+        end
+
+        def constraint_collection(route)
+          constraint = route.path.requirements[:id]
+          return nil unless constraint.is_a?(Regexp)
+          return nil unless constraint.source.include?("|")
+
+          values = constraint.source.split("|")
+          return nil unless values.all? { it.match?(/\A\w+\z/) }
+
+          Paths::ConstraintCollection.new(values)
+        end
+
+        def constraint_resources_from(route)
+          constraint = route.path.requirements[:id]
+          return [] unless constraint.is_a?(Regexp)
+          return [] unless constraint.source.include?("|")
+
+          values = constraint.source.split("|")
+          return [] unless values.all? { it.match?(/\A\w+\z/) }
+
+          values.map { Paths::ConstraintResource.new(it) }
+        end
+      end
+    end
+  end
+end

data/lib/perron/site/builder/sitemap.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require "perron/site/builder/route_resources"
+
 module Perron
   module Site
     class Builder
       class Sitemap
+        include RouteResources
+
         def initialize(output_path)
           @output_path = output_path
         end
@@ -11,12 +15,27 @@ module Perron
         def generate
           return if !Perron.configuration.sitemap.enabled
 
+          added_urls = Set.new
+
           xml = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |builder|
             builder.urlset(xmlns: "http://www.sitemaps.org/schemas/sitemap/0.9") do
               add_additional_routes(with: builder)
 
-              Perron::Site.collections.each do |collection|
-                add_urls_for(collection, with: builder)
+              buildable_routes.each do |route|
+                case route.defaults[:action]
+                when "index"
+                  add_index_url(route, with: builder, added_urls: added_urls)
+                when "show"
+                  if (route.required_keys - %i[controller action]).empty?
+                    add_index_url(route, with: builder, added_urls: added_urls)
+                  else
+                    resources_for(route).reject(&:root?).each do |resource|
+                      next if resource.metadata.sitemap == false
+
+                      add_show_url(route, resource, with: builder, added_urls: added_urls)
+                    end
+                  end
+                end
               end
             end
           end.to_xml
@@ -41,31 +60,63 @@ module Perron
           end
         end
 
-        def add_urls_for(collection, with:)
-          return if collection.configuration.blank?
-          return if collection.configuration.sitemap.exclude == true
+        def add_index_url(route, with:, added_urls:)
+          collection = collection_for(route)
+          return if collection&.configuration&.sitemap&.enabled == false
 
-          collection.resources.each do |resource|
-            next if resource.metadata.sitemap == false
+          url_options = Perron.configuration.default_url_options
+          url_options = url_options.merge(trailing_slash: false) if route.path.spec.to_s.match?(/\.\w+/)
 
-            priority = resource.metadata.sitemap_priority || collection.configuration.sitemap.priority || Perron.configuration.sitemap.priority
-            change_frequency = resource.metadata.sitemap_change_frequency || collection.configuration.sitemap.change_frequency || Perron.configuration.sitemap.change_frequency
+          routes.with_options(url_options) do |url|
+            loc = url.public_send("#{route.name}_url")
+            next if added_urls.include?(loc)
+            added_urls << loc
 
-            Rails.application.routes.url_helpers.with_options(Perron.configuration.default_url_options) do |url|
-              with.url do
-                with.loc resource.root? ? url.root_url : url.polymorphic_url(resource)
-                with.priority priority
-                with.changefreq change_frequency
-                begin
-                  with.lastmod resource.metadata.updated_at.iso8601
-                rescue
-                  Time.current.iso8601
-                end
-              end
+            lastmod = last_modified_for(collection)
+
+            with.url do
+              with.loc loc
+              with.priority Perron.configuration.sitemap.priority
+              with.changefreq Perron.configuration.sitemap.change_frequency
+              with.lastmod lastmod if lastmod
+            end
+          end
+        end
+
+        def add_show_url(route, resource, with:, added_urls:)
+          collection = collection_for(route)
+          return if collection&.configuration&.sitemap&.enabled == false
+
+          priority = resource.metadata.sitemap_priority || collection&.configuration&.sitemap&.priority || Perron.configuration.sitemap.priority
+          change_frequency = resource.metadata.sitemap_change_frequency || collection&.configuration&.sitemap&.change_frequency || Perron.configuration.sitemap.change_frequency
+
+          url_options = Perron.configuration.default_url_options
+          url_options = url_options.merge(trailing_slash: false) if route.path.spec.to_s.match?(/\.\w+/)
+
+          loc = resource.root? ? routes.root_url(url_options) : routes.public_send("#{route.name}_url", resource, **url_options)
+
+          return if added_urls.include?(loc)
+          added_urls << loc
+
+          routes.with_options(Perron.configuration.default_url_options) do |url|
+            with.url do
+              with.loc loc
+              with.priority priority
+              with.changefreq change_frequency
+              with.lastmod resource.metadata.updated_at&.iso8601 if resource.metadata.updated_at.present?
             end
           end
         end
 
+        def last_modified_for(collection)
+          return unless collection
+
+          resources = collection.send(:load_resources).select(&:buildable?)
+          dates = resources.filter_map { it.metadata.updated_at || it.metadata.publication_date }
+
+          dates.max&.iso8601
+        end
+
         def routes = Rails.application.routes.url_helpers
       end
     end

data/lib/perron/site/builder.rb

@@ -16,6 +16,8 @@ module Perron
       end
 
       def build
+        run_hook(:before_build)
+
         if Perron.configuration.mode.standalone?
           puts "🧹 Cleaning previous build…"
 
@@ -35,6 +37,8 @@ module Perron
         output_preview_urls
 
         puts "\n✅ Build complete"
+      ensure
+        run_hook(:after_build)
       end
 
       private
@@ -42,7 +46,7 @@ module Perron
       def paths
         Set.new.tap do |paths|
           Perron::Site::Builder::AdditionalRoutes.new(paths).get
-          Perron::Site.collections.each { Perron::Site::Builder::Paths.new(it, paths).get }
+          Perron::Site::Builder::Paths.new(paths).get
         end
       end
 
@@ -58,6 +62,26 @@ module Perron
           end
         end
       end
+
+      def run_hook(name)
+        return unless (hook = Perron.configuration.public_send(name))
+
+        context = Context.new(
+          output_path: @output_path.to_s,
+          mode: Perron.configuration.mode
+        )
+
+        hook.call(context)
+      end
+
+      class Context
+        attr_reader :output_path, :mode
+
+        def initialize(output_path:, mode:)
+          @output_path = output_path
+          @mode = mode
+        end
+      end
     end
   end
 end

data/lib/perron/site/validate.rb

@@ -19,8 +19,7 @@ module Perron
 
         puts [
           "Validation finished",
-          (" with #{@failures.count} failures" if failed?),
-          "."
+          (" with #{@failures.count} failures" if failed?)
         ].join
       end
 
@@ -37,7 +36,11 @@ module Perron
       def validate_collection(collection)
         collection.resources.each do |resource|
           resource.validate ? success : failed(resource)
+        rescue Psych::SyntaxError => error
+          render_yaml error, resource.file_path
         end
+      rescue Psych::SyntaxError => error
+        render_yaml error, "unknown"
       end
 
       def success = print "#{GREEN}.#{RESET}"
@@ -45,13 +48,22 @@ module Perron
       def failed(resource)
         print "#{RED}F#{RESET}"
 
-        errors = []
+        @failures << Failure.new(
+          identifier: resource.file_path,
+          errors: resource.errors.respond_to?(:full_messages) ? resource.errors.full_messages : []
+        )
+      end
 
-        if resource.respond_to?(:errors) && resource.errors.respond_to?(:full_messages) && resource.errors.any?
-          errors = resource.errors.full_messages
-        end
+      def render_yaml(error, identifier)
+        print "#{RED}F#{RESET}"
+
+        line_info = error.line ? " at line #{error.line}" : ""
+        column_info = error.column ? ", column #{error.column}" : ""
 
-        @failures << Failure.new(identifier: resource.file_path, errors: errors)
+        @failures << Failure.new(
+          identifier: identifier,
+          errors: ["Invalid YAML#{line_info}#{column_info}: #{error.problem}"]
+        )
       end
 
       def failures_report

data/lib/perron/site.rb

@@ -23,6 +23,13 @@ module Perron
 
     def collection(name) = Collection.new(name)
 
+    def find_collection(name)
+      collection_path = File.join(Perron.configuration.input, name)
+      return nil unless File.exist?(collection_path) && File.directory?(collection_path)
+
+      Collection.new(name)
+    end
+
     def data(name = nil)
       Perron.deprecator.deprecation_warning(:data, "Use Content::Data::ClassName instead, e.g. `Content::Data::Users.all`")
 

data/lib/perron/tasks/build.rake

@@ -1,13 +1,12 @@
 namespace :perron do
-  task :set_production_env do
-    unless ENV["RAILS_ENV"]
-      ENV["RAILS_ENV"] = "production"
-      puts "RAILS_ENV not set, defaulting to production"
+  desc "Generate static HTML files from Perron collections"
+  task build: :environment do
+    unless Rails.env.production?
+      puts "⚠️  Not running in production mode. Unpublished content will be included in the build."
+      puts " └─> Run in production mode using: RAILS_ENV=production bin/rails perron:build"
+      puts ""
     end
-  end
 
-  desc "Generate static HTML files from Perron collections"
-  task build: [:set_production_env, :environment] do
     Perron::Site.build
   end
 end