perron 0.18.0 → 1.1.0

data/lib/perron/resource/configuration.rb

@@ -12,20 +12,28 @@ module Perron
 
             config.feeds = Options.new
 
-            config.feeds.rss = ActiveSupport::OrderedOptions.new
-            config.feeds.rss.enabled = false
-            config.feeds.rss.path = "feeds/#{collection.name.demodulize.parameterize}.xml"
-            config.feeds.rss.max_items = 20
+            config.feeds.atom = ActiveSupport::OrderedOptions.new
+            config.feeds.atom.enabled = false
+            config.feeds.atom.path = "feeds/#{collection.name.demodulize.parameterize}.atom"
+            config.feeds.atom.max_items = 20
 
             config.feeds.json = ActiveSupport::OrderedOptions.new
             config.feeds.json.enabled = false
             config.feeds.json.path = "feeds/#{collection.name.demodulize.parameterize}.json"
             config.feeds.json.max_items = 20
 
+            config.feeds.rss = ActiveSupport::OrderedOptions.new
+            config.feeds.rss.enabled = false
+            config.feeds.rss.path = "feeds/#{collection.name.demodulize.parameterize}.xml"
+            config.feeds.rss.max_items = 20
+
             config.related_posts = ActiveSupport::OrderedOptions.new
             config.related_posts.enabled = false
             config.related_posts.max = 5
 
+            config.pagination = ActiveSupport::OrderedOptions.new
+            config.pagination.path_template = "/page/:page/"
+
             config.sitemap = ActiveSupport::OrderedOptions.new
             config.sitemap.exclude = false
           end

data/lib/perron/resource/metadata.rb

@@ -3,28 +3,36 @@
 module Perron
   class Resource
     class Metadata
-      def initialize(resource:, frontmatter:, collection:)
+      def initialize(resource:, frontmatter:, collection:, controller_metadata: {})
         @resource = resource
         @frontmatter = frontmatter&.deep_symbolize_keys || {}
         @collection = collection
+        @controller_metadata = controller_metadata
         @config = Perron.configuration
       end
 
       def data
         @data ||= ActiveSupport::OrderedOptions
           .new
-          .merge(apply_fallbacks_and_defaults(to: merged_site_collection_resource_frontmatter))
+          .merge(apply_fallbacks_and_defaults(to: merged_metadata))
       end
 
       private
 
-      def merged_site_collection_resource_frontmatter = site_data.merge(collection_data).merge(@frontmatter)
+      def merged_metadata
+        site_data
+          .merge(collection_data)
+          .merge(@controller_metadata)
+          .merge(@frontmatter)
+      end
 
       def apply_fallbacks_and_defaults(to:)
         to[:title] ||= @config.site_name || Rails.application.name.underscore.camelize
 
         to[:canonical_url] ||= canonical_url
 
+        to[:image] = absolute_url(to[:image]) if to[:image]
+
         to[:og_image] ||= to[:image]
         to[:twitter_image] ||= to[:og_image]
 
@@ -52,13 +60,20 @@ module Perron
         begin
           Rails.application.routes.url_helpers.polymorphic_url(
             @resource,
-          **Perron.configuration.default_url_options
+            **Perron.configuration.default_url_options
           )
         rescue
           false
         end
       end
 
+      def absolute_url(path)
+        return path if path.blank?
+        return path if path.start_with?("http://", "https://", "//")
+
+        Perron.configuration.url.delete_suffix("/") + path
+      end
+
       def site_data
         @config.metadata.except(:title_separator, :title_suffix).deep_symbolize_keys || {}
       end

data/lib/perron/resource/publishable.rb

@@ -7,6 +7,8 @@ module Perron
 
       included do
         def published?
+          return ENV["VIEW_UNPUBLISHED"] == "true" if ENV["VIEW_UNPUBLISHED"]
+
           return true if Perron.configuration.view_unpublished
 
           return false if frontmatter.draft == true

data/lib/perron/resource/related.rb

@@ -9,6 +9,7 @@ module Perron
       #
       # Pre-normalizes vectors so cosine similarity reduces to a dot product,
       # then builds a symmetric similarity matrix once per collection.
+      #
       # Results are cached at the class level so the O(n²) comparison
       # is paid once, not once per resource.
       class Related
@@ -18,7 +19,8 @@ module Perron
 
         def self.cache_for(collection_name)
           clear_cache!(collection_name) if stale?(collection_name)
-          @collection_caches[collection_name] ||= Cache.new(nil, nil, content_fingerprint(collection_name))
+
+          @collection_caches[collection_name] ||= Cache.new(nil, nil, fingerprinted(collection_name))
         end
 
         def self.clear_cache!(collection_name)
@@ -26,12 +28,13 @@ module Perron
         end
 
         def self.stale?(collection_name)
-          @collection_caches[collection_name]&.fingerprint != content_fingerprint(collection_name)
+          @collection_caches[collection_name]&.fingerprint != fingerprinted(collection_name)
         end
 
-        def self.content_fingerprint(collection_name)
+        def self.fingerprinted(collection_name)
           path = File.join(Perron.configuration.input, collection_name)
           files = Dir.glob(File.join(path, "**", "*.*"))
+
           [files.size, files.map { File.mtime(it) }.max]
         end
 
@@ -52,55 +55,53 @@ module Perron
 
         private
 
-        def resources = @cache.resources ||= @collection.resources
+        def resources
+          @cache.resources ||= @collection.resources
+        end
 
-        def similarity_matrix = @cache.similarity_matrix ||= build_similarity_matrix
+        def similarity_matrix
+          @cache.similarity_matrix ||= build_similarity_matrix
+        end
 
         def build_similarity_matrix
           vectors = resources.to_h { [it.slug, normalize(tfidf_vector_for(it))] }
-          matrix = Hash.new { |h, k| h[k] = {} }
 
-          slugs = vectors.keys
-          slugs.each_with_index do |slug_a, i|
-            next if vectors[slug_a].empty?
+          Hash.new { |hash, key| hash[key] = {} }.tap do |matrix|
+            slugs = vectors.keys
+
+            slugs.each_with_index do |slug_a, index|
+              next if vectors[slug_a].empty?
 
-            slugs[(i + 1)..].each do |slug_b|
-              next if vectors[slug_b].empty?
+              slugs[(index + 1)..].each do |slug_b|
+                next if vectors[slug_b].empty?
 
-              score = dot_product(vectors[slug_a], vectors[slug_b])
-              matrix[slug_a][slug_b] = score
-              matrix[slug_b][slug_a] = score
+                matrix[slug_a][slug_b] = dot_product(vectors[slug_a], vectors[slug_b])
+                matrix[slug_b][slug_a] = matrix[slug_a][slug_b]
+              end
             end
           end
-
-          matrix
-        end
-
-        def dot_product(vec_a, vec_b)
-          score = 0.0
-          vec_a.each_key { score += vec_a[it] * vec_b[it] if vec_b.key?(it) }
-          score
         end
 
         def normalize(vector)
-          return {} if vector.empty?
-
           magnitude = Math.sqrt(vector.values.sum { it**2 })
-          return {} if magnitude.zero?
+          return {} if vector.empty? || magnitude.zero?
 
           vector.transform_values { it / magnitude }
         end
 
         def tfidf_vector_for(resource)
-          tokens = tokenize(resource)
+          tokens = tokenized(resource)
           return {} if tokens.empty?
 
           token_count = tokens.size.to_f
-
           tokens.tally.to_h { |term, count| [term, (count / token_count) * inverse_document_frequency[term]] }
         end
 
-        def tokenize(resource)
+        def dot_product(vector_a, vector_b)
+          vector_a.sum { |term, value| value * (vector_b[term] || 0) }
+        end
+
+        def tokenized(resource)
           return [] if resource.content.blank?
 
           resource.content.gsub(/<[^>]*>/, " ").downcase.scan(/\w+/).reject { StopWords.all.include?(it) || it.length < 3 }
@@ -108,11 +109,11 @@ module Perron
 
         def inverse_document_frequency
           @inverse_document_frequency ||= begin
-            doc_frequency = Hash.new(0)
-            resources.each { tokenize(it).uniq.each { doc_frequency[it] += 1 } }
+            document_frequency = Hash.new(0)
+            resources.each { tokenized(it).uniq.each { document_frequency[it] += 1 } }
 
             total = resources.size.to_f
-            doc_frequency.transform_values { Math.log(total / (1 + it)) }
+            document_frequency.transform_values { Math.log(total / (1 + it)) }
           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)
@@ -15,12 +20,24 @@ module Perron
           @source_definitions || {}
         end
 
+        def resolve(name)
+          definition = source_definitions[name]
+
+          data = if definition[:class]
+            definition[:class].all
+          else
+            Perron::DataSource.new(name.to_s).to_a
+          end
+
+          definition[:scope] ? definition[:scope].call(data) : data
+        end
+
         def source_names = source_definitions.keys
 
         def generate_from_sources!
           return unless source_backed?
 
-          combinations.each do |combo|
+          derive.each do |combo|
             content = content_with combo
             filename = filename_with combo
 
@@ -36,28 +53,91 @@ module Perron
         def parsed(*arguments)
           return {} if arguments.empty?
 
-          arguments.flat_map { it.is_a?(Hash) ? it.to_a : [[it, {primary_key: :id}]] }.to_h
+          definitions = arguments.flat_map do |argument|
+            case argument
+            when Hash
+              argument.to_a
+            when Proc
+              [[SecureRandom.hex(8).to_sym, {scope: argument, primary_key: :id}]]
+            else
+              [[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
-          datasets = source_names.map { Perron::DataSource.new(it.to_s) }
+        def derive
+          datasets = source_names.map { resolve it }
 
-          datasets.first.product(*datasets[1..])
+          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]
+              primary_key = source_definitions[name][:primary_key] || :id
+
+              raise Errors::DataParseError, "Primary key `#{primary_key}` is nil for row in source `#{name}`" if item.public_send(primary_key).nil?
+            end
+          end
         end
 
         def content_with(combo)
-          data = source_names.each.with_index.to_h { |name, index| [name, combo[index]] }
-          sources = Source.new(data)
+          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(sources)
+          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)
@@ -65,21 +145,23 @@ module Perron
 
       def source_backed? = self.class.source_backed?
 
-      def sources
-        @sources ||= begin
+      def source
+        @source ||= begin
           data = self.class.source_definitions.each_with_object({}) do |(name, options), hash|
             primary_key = options[:primary_key]
             singular_name = name.to_s.singularize
             identifier = frontmatter["#{singular_name}_#{primary_key}"]
 
-            hash[name] = Perron::DataSource.new(name.to_s).find { it.public_send(primary_key).to_s == identifier.to_s }
+            dataset = self.class.send(:resolve, name)
+            hash[name] = dataset.find { it.public_send(primary_key).to_s == identifier.to_s }
           end
 
           Source.new(data)
         end
       end
+      alias_method :sources, :source
 
-      def source_template(sources)
+      def source_template(source)
         raise NotImplementedError, "#{self.class.name} must implement #source_template"
       end
 

data/lib/perron/resource.rb

@@ -17,6 +17,7 @@ require "perron/resource/searchable"
 require "perron/resource/separator"
 require "perron/resource/sourceable"
 require "perron/resource/sweeper"
+require "perron/resource/adjacency"
 require "perron/resource/table_of_content"
 
 module Perron
@@ -34,6 +35,7 @@ module Perron
     include Previewable
     include Scopes
     include Sweeper
+    include Adjacency
     include TableOfContent
 
     attr_reader :file_path, :id
@@ -94,6 +96,10 @@ module Perron
       slug == "/"
     end
 
+    def destroy
+      File.delete(@file_path) and self
+    end
+
     private
 
     ID_LENGTH = 8
@@ -115,6 +121,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/assets.rb

@@ -11,7 +11,7 @@ module Perron
         def prepare
           puts "📦 Precompiling and copying assets…"
 
-          success = system("bundle exec rails assets:precompile", out: File::NULL, err: File::NULL)
+          success = system("bundle exec rails assets:precompile", out: File::NULL)
 
           unless success
             puts "❌ ERROR: Asset precompilation failed"

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) %></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>