perron 1.0.0 → 1.2.0

data/lib/perron/resource/publishable.rb

@@ -54,7 +54,15 @@ module Perron
         return @date_from_filename if defined?(@date_from_filename)
 
         match = File.basename(file_path).match(DATE_REGEX)
-        @date_from_filename = match ? Date.new(match[:year].to_i, match[:month].to_i, match[:day].to_i).in_time_zone : nil
+
+        @date_from_filename =
+          if match
+            begin
+              Date.new(match[:year].to_i, match[:month].to_i, match[:day].to_i).in_time_zone
+            rescue Date::Error
+              nil
+            end
+          end
       end
     end
   end

data/lib/perron/resource/separator.rb

@@ -19,12 +19,18 @@ module Perron
 
       def parsed(content)
         if content =~ /\A---\s*(.*?)\s*---\s*(.*)/m
-          @frontmatter = YAML.safe_load($1, permitted_classes: [Date, Time]) || {}
-          @content = $2.strip
-        else
-          @frontmatter = {}
-          @content = content
+          parsed_yaml = YAML.safe_load($1, permitted_classes: [Date, Time])
+
+          if parsed_yaml.nil? || parsed_yaml.is_a?(Hash)
+            @frontmatter = parsed_yaml || {}
+            @content = $2.strip
+
+            return
+          end
         end
+
+        @frontmatter = {}
+        @content = content
       end
     end
   end

data/lib/perron/resource/sourceable.rb

@@ -5,6 +5,11 @@ module Perron
     module Sourceable
       extend ActiveSupport::Concern
 
+      MODES = {
+        single: ->(dataset) { dataset.zip },
+        combinations: ->(dataset) { dataset.to_a.combination(2).to_a }
+      }
+
       class_methods do
         def sources(*arguments)
           @source_definitions = parsed(*arguments)
@@ -32,12 +37,14 @@ module Perron
         def generate_from_sources!
           return unless source_backed?
 
-          combinations.each do |combo|
+          extension = source_definitions.values.first&.dig(:extension) || "erb"
+
+          derive.each do |combo|
             content = content_with combo
             filename = filename_with combo
 
             FileUtils.mkdir_p(output_dir)
-            File.write(output_dir.join("#{filename}.erb"), content)
+            File.write(output_dir.join("#{filename}.#{extension}"), content)
           end
         end
 
@@ -48,7 +55,7 @@ module Perron
         def parsed(*arguments)
           return {} if arguments.empty?
 
-          arguments.flat_map do |argument|
+          definitions = arguments.flat_map do |argument|
             case argument
             when Hash
               argument.to_a
@@ -58,11 +65,39 @@ module Perron
               [[argument, {primary_key: :id}]]
             end
           end.to_h
+
+          if definitions.values.any? { it[:mode] }
+            raise ArgumentError, "mode is only supported for single-source definitions" if definitions.size > 1
+          end
+
+          definitions
         end
 
-        def combinations
+        def derive
           datasets = source_names.map { resolve it }
 
+          if single_source_with_mode?
+            derive_from_single_source(datasets.first)
+          else
+            derive_from_multiple_sources(datasets)
+          end
+        end
+
+        def derive_from_single_source(dataset)
+          source_name = source_names.first
+          mode = source_definitions[source_name][:mode] || :single
+          method = MODES[mode.to_sym] || raise(ArgumentError, "Unknown mode: #{mode}")
+
+          method.call(dataset).each do |combo|
+            primary_key = source_definitions[source_name][:primary_key] || :id
+
+            combo.each do |item|
+              raise Errors::DataParseError, "Primary key `#{primary_key}` is nil for row" if item.public_send(primary_key).nil?
+            end
+          end
+        end
+
+        def derive_from_multiple_sources(datasets)
           datasets.first.product(*datasets[1..]).each do |combo|
             combo.each_with_index do |item, index|
               name = source_names[index]
@@ -74,18 +109,37 @@ module Perron
         end
 
         def content_with(combo)
-          data = source_names.each.with_index.to_h { |name, index| [name, combo[index]] }
+          data = if single_source_with_mode?
+            source_name = source_names.first
+            names = source_definitions[source_name][:as]&.map(&:to_sym) || (1..combo.size).map { :"#{source_name}_#{it}" }
+
+            combo.each_with_index.to_h { |item, index| [names[index], item] }
+          else
+            source_names.each_with_index.to_h { |name, index| [name, combo[index]] }
+          end
+
           source = Source.new(data)
 
           source_template(source)
         end
 
         def filename_with(combo)
-          source_names.each_with_index.map do |name, index|
-            primary_key = source_definitions[name][:primary_key]
+          if single_source_with_mode?
+            source_name = source_names.first
+            primary_key = source_definitions[source_name][:primary_key] || :id
+
+            combo.map { it.public_send(primary_key) }.join("-")
+          else
+            source_names.each_with_index.map do |name, index|
+              primary_key = source_definitions[name][:primary_key]
+
+              combo[index].public_send(primary_key)
+            end.join("-")
+          end
+        end
 
-            combo[index].public_send(primary_key)
-          end.join("-")
+        def single_source_with_mode?
+          source_names.one? && source_definitions[source_names.first][:mode]
         end
 
         def output_dir = Perron.configuration.input.join(model_name.collection)

data/lib/perron/resource/updatable.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Perron
+  class Resource
+    module Updatable
+      extend ActiveSupport::Concern
+
+      included do
+        def metadata
+          @metadata ||= Proxy.new(super, self)
+        end
+      end
+
+      class Proxy
+        def initialize(metadata, resource)
+          @metadata = metadata
+          @resource = resource
+        end
+
+        def update(attributes)
+          attributes = attributes.deep_symbolize_keys
+
+          separator = Perron::Resource::Separator.new(@resource.raw_content)
+          frontmatter = separator.frontmatter.to_h.merge(attributes)
+          yaml = frontmatter.transform_keys(&:to_s).to_yaml.sub(/\A---\n/, "")
+          body = separator.content
+
+          File.write(@resource.file_path, "---\n#{yaml}---\n\n#{body}\n")
+
+          @resource.instance_variable_set(:@frontmatter, nil)
+          attributes.each { |key, value| @metadata[key] = value }
+
+          self
+        end
+
+        def respond_to_missing?(name, include_private = false)
+          @metadata.respond_to?(name, include_private) || super
+        end
+
+        def method_missing(name, *arguments, &block)
+          @metadata.public_send(name, *arguments, &block)
+        end
+      end
+    end
+  end
+end

data/lib/perron/resource.rb

@@ -19,6 +19,7 @@ require "perron/resource/sourceable"
 require "perron/resource/sweeper"
 require "perron/resource/adjacency"
 require "perron/resource/table_of_content"
+require "perron/resource/updatable"
 
 module Perron
   class Resource
@@ -96,6 +97,10 @@ module Perron
       slug == "/"
     end
 
+    def destroy
+      File.delete(@file_path) and self
+    end
+
     private
 
     ID_LENGTH = 8
@@ -117,6 +122,8 @@ module Perron
     end
 
     def erb_processing?
+      return false if metadata.erb == false
+
       @file_path.ends_with?(".erb") || metadata.erb == true
     end
   end

data/lib/perron/site/builder/feeds/atom.erb

@@ -16,7 +16,7 @@
 
   <% resources.each do |resource| %>
   <entry>
-    <id><%= url_for_resource.call(resource) || "#{@configuration.url}/posts/#{resource.id}" %></id>
+    <id><%= url_for_resource.call(resource) %></id>
     <title><%= resource.metadata.title %></title>
     <link href="<%= url_for_resource.call(resource) %>" rel="alternate" type="text/html"/>
     <published><%= resource.published_at&.iso8601 %></published>

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

@@ -11,8 +11,10 @@ module Perron
           include Feeds::Author
           include Feeds::Template
 
-          def initialize(collection:)
+          def initialize(collection:, resources: nil, feed_config: nil)
             @collection = collection
+            @resources = resources
+            @feed_config = feed_config
             @configuration = Perron.configuration
           end
 
@@ -28,12 +30,16 @@ module Perron
           private
 
           def resources
-            @resource ||= @collection.resources
+            (@resources || @collection.resources)
               .reject { it.metadata.feed == false }
               .sort_by { it.metadata.published_at || it.metadata.updated_at || Time.current }
               .reverse
               .take(feed_configuration.max_items)
           end
+
+          def feed_configuration
+            @feed_config || super
+          end
         end
       end
     end

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

@@ -11,8 +11,10 @@ module Perron
           include Feeds::Author
           include Feeds::Template
 
-          def initialize(collection:)
+          def initialize(collection:, resources: nil, feed_config: nil)
             @collection = collection
+            @resources = resources
+            @feed_config = feed_config
             @configuration = Perron.configuration
           end
 
@@ -28,12 +30,16 @@ module Perron
           private
 
           def resources
-            @resource ||= @collection.resources
+            (@resources || @collection.resources)
               .reject { it.metadata.feed == false }
               .sort_by { it.metadata.published_at || it.metadata.updated_at || Time.current }
               .reverse
               .take(feed_configuration.max_items)
           end
+
+          def feed_configuration
+            @feed_config || super
+          end
         end
       end
     end

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

@@ -11,8 +11,10 @@ module Perron
           include Feeds::Author
           include Feeds::Template
 
-          def initialize(collection:)
+          def initialize(collection:, resources: nil, feed_config: nil)
             @collection = collection
+            @resources = resources
+            @feed_config = feed_config
             @configuration = Perron.configuration
           end
 
@@ -28,12 +30,16 @@ module Perron
           private
 
           def resources
-            @resource ||= @collection.resources
+            (@resources || @collection.resources)
               .reject { it.metadata.feed == false }
               .sort_by { it.metadata.published_at || it.metadata.updated_at || Time.current }
               .reverse
               .take(feed_configuration.max_items)
           end
+
+          def feed_configuration
+            @feed_config || super
+          end
         end
       end
     end

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

@@ -4,10 +4,14 @@ require "perron/site/builder/feeds/atom"
 require "perron/site/builder/feeds/json"
 require "perron/site/builder/feeds/rss"
 
+require "perron/feeds/split"
+
 module Perron
   module Site
     class Builder
       class Feeds
+        include Perron::Feeds::Split
+
         def initialize(output_path)
           @output_path = output_path
         end
@@ -18,21 +22,39 @@ module Perron
 
             config = collection.configuration.feeds
 
-            if config.atom.enabled
-              create_file at: config.atom.path, with: Atom.new(collection: collection).generate
-            end
+            generate_feed(collection: collection, type_config: config.atom, generator_class: Atom) if config.atom.enabled
+            generate_feed(collection: collection, type_config: config.json, generator_class: Json) if config.json.enabled
+            generate_feed(collection: collection, type_config: config.rss, generator_class: Rss) if config.rss.enabled
+          end
+        end
+
+        private
+
+        def generate_feed(collection:, type_config:, generator_class:)
+          generator = generator_class.new(collection: collection)
+          content = generator.generate
 
-            if config.json.enabled
-              create_file at: config.json.path, with: Json.new(collection: collection).generate
-            end
+          create_file(at: type_config.path, with: content) if content.present?
 
-            if config.rss.enabled
-              create_file at: config.rss.path, with: Rss.new(collection: collection).generate
-            end
+          return unless type_config[:split_by]
+
+          grouped_resources(collection.resources, type_config[:split_by][:extractor]).each do |value, group|
+            path = split_path_for(type_config, value)
+            config = split_config(type_config, value, path)
+            content = generator_class.new(collection: collection, resources: group, feed_config: config).generate
+
+            create_file(at: path, with: content) if content.present?
           end
         end
 
-        private
+        def split_config(type_config, value, split_path)
+          ActiveSupport::OrderedOptions.new.tap do |config|
+            type_config.each { |key, value| config[key] = value unless key == :split_by }
+
+            config.path = split_path
+            config.title = "#{type_config.title.presence || Perron.configuration.site_name}: #{value.to_s.humanize}"
+          end
+        end
 
         def create_file(at:, with:)
           return if with.blank?

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

@@ -28,12 +28,30 @@ module Perron
               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
 
-            [routes.public_send("#{route.name}_path")]
+            base_path = routes.public_send("#{route.name}_path")
+            collection = collection_for(route)
+            return [base_path] unless collection
+
+            pagination = collection.configuration.pagination
+            return [base_path] unless pagination.per_page
+
+            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
 
+        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)
@@ -73,6 +91,10 @@ module Perron
             def sitemap_change_frequency = nil
 
             def updated_at = nil
+
+            def canonical_url = nil
+
+            def explicit_canonical_url = nil
           end
         end
       end

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

@@ -52,9 +52,8 @@ module Perron
             routes.with_options(Perron.configuration.default_url_options) do |url|
               with.url do
                 with.loc url.public_send(route_name.to_s.gsub("_path", "_url"))
-                with.priority Perron.configuration.sitemap.priority
-                with.changefreq Perron.configuration.sitemap.change_frequency
-                with.lastmod Time.current.iso8601
+                with.priority Perron.configuration.sitemap.priority if Perron.configuration.sitemap.emit_priority
+                with.changefreq Perron.configuration.sitemap.change_frequency if Perron.configuration.sitemap.emit_changefreq
               end
             end
           end
@@ -76,8 +75,8 @@ module Perron
 
             with.url do
               with.loc loc
-              with.priority Perron.configuration.sitemap.priority
-              with.changefreq Perron.configuration.sitemap.change_frequency
+              with.priority Perron.configuration.sitemap.priority if Perron.configuration.sitemap.emit_priority
+              with.changefreq Perron.configuration.sitemap.change_frequency if Perron.configuration.sitemap.emit_changefreq
               with.lastmod lastmod if lastmod
             end
           end
@@ -95,14 +94,15 @@ module Perron
 
           loc = resource.root? ? routes.root_url(url_options) : routes.public_send("#{route.name}_url", resource, **url_options)
 
+          return if canonical_mismatch?(resource.metadata.explicit_canonical_url, loc)
           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.priority priority if Perron.configuration.sitemap.emit_priority
+              with.changefreq change_frequency if Perron.configuration.sitemap.emit_changefreq
               with.lastmod resource.metadata.updated_at&.iso8601 if resource.metadata.updated_at.present?
             end
           end
@@ -111,10 +111,23 @@ module Perron
         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 }
+          modification_dates = collection.send(:load_resources).select(&:buildable?).filter_map { it.metadata.updated_at }
 
-          dates.max&.iso8601
+          modification_dates.max&.iso8601
+        end
+
+        def canonical_mismatch?(canonical, location)
+          return false unless canonical.is_a?(String) && canonical.present?
+
+          canonical_uri = URI.parse(canonical)
+          canonical_uri = URI.join(location, canonical) unless canonical_uri.host
+          page_uri = URI.parse(location)
+
+          normalize = ->(uri) { [uri.host, uri.path].map(&:to_s).map(&:downcase).join("|") }
+
+          normalize.call(canonical_uri) != normalize.call(page_uri)
+        rescue URI::InvalidURIError
+          false
         end
 
         def routes = Rails.application.routes.url_helpers

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
@@ -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

@@ -36,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}"
@@ -44,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