perron 0.18.0 → 1.0.0

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

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <generator uri="https://perron.railsdesigner.com/" version="<%= Perron::VERSION %>">Perron</generator>
+  <id><%= current_feed_url.call %></id>
+  <title><%= config.title.presence || @configuration.site_name %></title>
+  <subtitle><%= config.description.presence || @configuration.site_description %></subtitle>
+  <link href="<%= current_feed_url.call %>" rel="self" type="application/atom+xml"/>
+  <link href="<%= @configuration.url %>" rel="alternate" type="text/html"/>
+  <updated><%= resources.first&.published_at&.iso8601 || Time.current.iso8601 %></updated>
+
+  <% feed_author = config.author || { name: @configuration.site_name, email: "noreply@#{URI.parse(@configuration.url).host}" } %>
+  <author>
+    <% if feed_author[:name] %><name><%= feed_author[:name] %></name><% end %>
+    <% if feed_author[:email] %><email><%= feed_author[:email] %></email><% end %>
+  </author>
+
+  <% resources.each do |resource| %>
+  <entry>
+    <id><%= url_for_resource.call(resource) || "#{@configuration.url}/posts/#{resource.id}" %></id>
+    <title><%= resource.metadata.title %></title>
+    <link href="<%= url_for_resource.call(resource) %>" rel="alternate" type="text/html"/>
+    <published><%= resource.published_at&.iso8601 %></published>
+    <updated><%= (resource.metadata.updated_at || resource.published_at)&.iso8601 %></updated>
+
+    <% entry_author = author.call(resource); if entry_author %>
+      <author>
+        <% if entry_author.name %><name><%= entry_author.name %></name><% end %>
+        <% if entry_author.email %><email><%= entry_author.email %></email><% end %>
+      </author>
+    <% end %>
+
+    <% base_url = url_for_resource.call(resource) %>
+    <% if base_url %>
+      <content type="html" xml:base="<%= base_url %>"><![CDATA[<%= Perron::Markdown.render(resource.content, processors: ["absolute_urls"]) %>]]></content>
+    <% else %>
+      <content type="html"><![CDATA[<%= Perron::Markdown.render(resource.content, processors: ["absolute_urls"]) %>]]></content>
+    <% end %>
+
+    <% resource.metadata.tags&.each do |tag| %>
+      <category term="<%= tag %>"/>
+    <% end %>
+  </entry>
+  <% end %>
+</feed>

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "perron/site/builder/feeds/author"
+require "perron/site/builder/feeds/template"
+
+module Perron
+  module Site
+    class Builder
+      class Feeds
+        class Atom
+          include Feeds::Author
+          include Feeds::Template
+
+          def initialize(collection:)
+            @collection = collection
+            @configuration = Perron.configuration
+          end
+
+          def generate
+            return if resources.empty?
+
+            template = find_template("atom")
+            return unless template
+
+            render(template, feed_configuration)
+          end
+
+          private
+
+          def resources
+            @resource ||= @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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+<%= {
+  generator: "Perron (#{Perron::VERSION})",
+  version: "https://jsonfeed.org/version/1.1",
+  home_page_url: @configuration.url,
+  title: config.title.presence || @configuration.site_name,
+  description: config.description.presence || @configuration.site_description,
+
+  items: resources.map { |resource|
+    item_author = author.call(resource)
+    {
+      id: resource.id,
+      url: url_for_resource.call(resource),
+      date_published: resource.published_at&.iso8601,
+      title: resource.metadata.title,
+      authors: (item_author && item_author.name ? [{ name: item_author.name, email: item_author.email, url: item_author.url, avatar: item_author.avatar }.compact] : nil),
+      content_html: Perron::Markdown.render(resource.content, processors: ["absolute_urls"])
+    }.compact
+  }
+}.to_json %>

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "json"
 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 Json
           include Feeds::Author
+          include Feeds::Template
 
           def initialize(collection:)
             @collection = collection
@@ -16,50 +17,23 @@ module Perron
           end
 
           def generate
-            return nil if resources.empty?
+            return if resources.empty?
 
-            hash = Rails.application.routes.url_helpers.with_options(@configuration.default_url_options) do |url|
-              {
-                generator: "Perron (#{Perron::VERSION})",
-                version: "https://jsonfeed.org/version/1.1",
-                home_page_url: @configuration.url,
-                title: feed_configuration.title.presence || @configuration.site_name,
-                description: feed_configuration.description.presence || @configuration.site_description,
-                items: resources.map do |resource|
-                  {
-                    id: resource.id,
-                    url: url.polymorphic_url(resource, ref: feed_configuration.ref).delete_suffix("?ref="),
-                    date_published: resource.published_at&.iso8601,
-                    authors: authors(resource),
-                    title: resource.metadata.title,
-                    content_html: Perron::Markdown.render(resource.content)
-                  }
-                end
-              }
-            end
+            template = find_template("json")
+            return unless template
 
-            JSON.pretty_generate hash
+            render(template, feed_configuration)
           end
 
           private
 
           def resources
-            @resources ||= @collection.resources
+            @resource ||= @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 = @collection.configuration.feeds.json
-
-          def authors(resource)
-            author = author(resource)
-
-            return nil unless author&.name
-
-            [{name: author.name, email: author.email, url: author.url, avatar: author.avatar}.compact].presence
-          end
         end
       end
     end

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

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <generator>Perron (<%= Perron::VERSION %>)</generator>
+    <link><%= @configuration.url %></link>
+    <title><%= config.title.presence || @configuration.site_name %></title>
+    <description><%= config.description.presence || @configuration.site_description %></description>
+
+    <% resources.each do |resource| %>
+    <item>
+      <guid isPermaLink="false"><%= resource.id %></guid>
+
+      <% resource_url = url_for_resource.call(resource) %>
+      <% if resource_url %>
+        <link><%= resource_url %></link>
+      <% end %>
+
+      <pubDate><%= resource.published_at&.rfc822 %></pubDate>
+      <% entry_author = author.call(resource); if entry_author && entry_author.email %>
+        <author><%= entry_author.name ? "#{entry_author.email} (#{entry_author.name})" : entry_author.email %></author>
+      <% end %>
+      <title><%= resource.metadata.title %></title>
+
+      <description><![CDATA[<%= Perron::Markdown.render(resource.content, processors: ["absolute_urls"]) %>]]></description>
+    </item>
+    <% end %>
+  </channel>
+</rss>

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/paths.rb

@@ -1,36 +1,80 @@
 # 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)
-
-          if routes.respond_to?(show_path)
-            @collection.send(:load_resources).select(&:buildable?).each do |resource|
-              next if resource.root?
+          buildable_routes.each do |route|
+            paths_for(route).each { @paths << it }
+          end
+        end
 
-              @paths << routes.public_send(show_path, resource)
+        private
 
-              (resource.class.try(:nested_routes) || []).each do |nested|
-                @paths << routes.polymorphic_path([resource, nested])
-              end
+        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
+
+            [routes.public_send("#{route.name}_path")]
+          when "show" then show_paths_for(route)
+          else []
           end
         end
 
-        private
+        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

@@ -42,7 +42,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