perron 0.7.0 → 0.9.0

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Perron
+  module Site
+    class Builder
+      class Feeds
+        class Json
+          def initialize(collection:)
+            @collection = collection
+            @configuration = Perron.configuration
+          end
+
+          def generate
+            return nil if resources.empty?
+
+            hash = Rails.application.routes.url_helpers.with_options(@configuration.default_url_options) do |url|
+              {
+                version: "https://jsonfeed.org/version/1.1",
+                title: @configuration.site_name,
+                home_page_url: @configuration.url,
+                description: @configuration.site_description,
+                items: resources.map do |resource|
+                  {
+                    id: resource.id,
+                    url: url.polymorphic_url(resource),
+                    date_published: (resource.metadata.published_at || resource.metadata.updated_at)&.iso8601,
+                    title: resource.metadata.title,
+                    content_html: Perron::Markdown.render(resource.content)
+                  }
+                end
+              }
+            end
+
+            JSON.pretty_generate hash
+          end
+
+          private
+
+          def resources
+            @resources ||= @collection.resources
+              .reject { it.metadata.feed == false }
+              .sort_by { it.metadata.published_at || it.metadata.updated_at || Time.current }
+              .reverse
+              .take(@collection.configuration.feeds.json.max_items)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Perron
+  module Site
+    class Builder
+      class Feeds
+        class Rss
+          def initialize(collection:)
+            @collection = collection
+            @configuration = Perron.configuration
+          end
+
+          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.title @configuration.site_name
+                  xml.description @configuration.site_description
+                  xml.link @configuration.url
+                  xml.generator "Perron (#{Perron::VERSION})"
+
+                  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), isPermaLink: true
+                        xml.pubDate((resource.metadata.published_at || resource.metadata.updated_at)&.rfc822)
+                        xml.title resource.metadata.title
+                        xml.description { xml.cdata(Perron::Markdown.render(resource.content)) }
+                      end
+                    end
+                  end
+                end
+              end
+            end.to_xml
+          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(@collection.configuration.feeds.rss.max_items)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "perron/site/builder/feeds/rss"
+require "perron/site/builder/feeds/json"
+
+module Perron
+  module Site
+    class Builder
+      class Feeds
+        def initialize(output_path)
+          @output_path = output_path
+        end
+
+        def generate
+          Perron::Site.collections.each do |collection|
+            config = collection.configuration.feeds
+
+            if config.rss.enabled
+              create_file at: config.rss.path, with: Rss.new(collection: collection).generate
+            end
+
+            if config.json.enabled
+              create_file at: config.json.path, with: Json.new(collection: collection).generate
+            end
+          end
+        end
+
+        private
+
+        def create_file(at:, with:)
+          return if with.blank?
+
+          path = @output_path.join(at)
+
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, with)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Perron
+  module Site
+    class Builder
+      class Sitemap
+        def initialize(output_path)
+          @output_path = output_path
+        end
+
+        def generate
+          return if !Perron.configuration.sitemap.enabled
+
+          xml = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |builder|
+            builder.urlset(xmlns: "http://www.sitemaps.org/schemas/sitemap/0.9") do
+              Perron::Site.collections.each do |collection|
+                add_urls_for(collection, with: builder)
+              end
+            end
+          end.to_xml
+
+          File.write(@output_path.join("sitemap.xml"), xml)
+        end
+
+        private
+
+        def add_urls_for(collection, with:)
+          return if collection.configuration.sitemap.exclude == true
+
+          collection.resources.each do |resource|
+            next if resource.metadata.sitemap == false
+
+            root = resource.slug == "/"
+            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
+
+            Rails.application.routes.url_helpers.with_options(Perron.configuration.default_url_options) do |url|
+              with.url do
+                with.loc 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
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/perron/site/builder.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "perron/site/builder/assets"
+require "perron/site/builder/sitemap"
+require "perron/site/builder/feeds"
 require "perron/site/builder/public_files"
 require "perron/site/builder/paths"
 require "perron/site/builder/page"
@@ -15,6 +17,7 @@ module Perron
       def build
         if Perron.configuration.mode.standalone?
           puts "🧹 Cleaning previous build…"
+
           FileUtils.rm_rf(Dir.glob("#{@output_path}/*"))
 
           Perron::Site::Builder::Assets.new.prepare
@@ -26,6 +29,9 @@ module Perron
 
         paths.each { render_page(it) }
 
+        Perron::Site::Builder::Sitemap.new(@output_path).generate
+        Perron::Site::Builder::Feeds.new(@output_path).generate
+
         puts "-" * 15
         puts "✅ Build complete"
       end

data/lib/perron/site/collection.rb

@@ -6,16 +6,21 @@ module Perron
 
     def initialize(name)
       @name = name
-      @collection_path = File.join(Rails.root, Perron.configuration.input, name)
+      @collection_path = File.join(Perron.configuration.input, name)
 
       raise Errors::CollectionNotFoundError, "No such collection: #{name}" unless File.exist?(@collection_path) && File.directory?(@collection_path)
     end
 
+    def configuration(resource_class = "Content::#{name.classify}".safe_constantize)
+      resource_class.configuration
+    end
+
     def all(resource_class = "Content::#{name.classify}".safe_constantize)
       @all ||= Dir.glob("#{@collection_path}/**/*.*").map do |file_path|
         resource_class.new(file_path)
       end.select(&:published?)
     end
+    alias_method :resources, :all
 
     def find(slug, resource_class = Resource)
       resource = all(resource_class).find { it.slug == slug }

data/lib/perron/site/data/proxy.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Perron
+  class Data
+    class Proxy
+      def method_missing(method_name, *arguments, &block)
+        raise ArgumentError, "Data `#{method_name}` does not accept arguments" if arguments.any?
+
+        Perron::Data.new(method_name.to_s)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/perron/site/data.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "erb"
+require "singleton"
+
 require "csv"
 
 module Perron
@@ -29,25 +32,39 @@ module Perron
     end
 
     def records
-      content = File.read(@file_path)
-      extension = File.extname(@file_path)
-      parser = PARSER_METHODS.fetch(extension) do
-        raise Errors::UnsupportedDataFormatError, "Unsupported data format: #{extension}"
-      end
-
-      data = send(parser, content)
+      content = rendered_from(@file_path)
+      data = parsed_from(content, @file_path)
 
       unless data.is_a?(Array)
         raise Errors::DataParseError, "Data in '#{@file_path}' must be an array of objects."
       end
 
       data.map { Item.new(it) }
+    end
+
+    def rendered_from(path)
+      raw_content = File.read(path)
+
+      render_erb(raw_content)
+    rescue NameError, ArgumentError, SyntaxError => error
+      raise Errors::DataParseError, "Failed to render ERB in `#{path}`: (#{error.class}) #{error.message}"
+    end
+
+    def parsed_from(content, path)
+      extension = File.extname(path)
+      parser_method = PARSER_METHODS.fetch(extension) do
+        raise Errors::UnsupportedDataFormatError, "Unsupported data format: #{extension}"
+      end
+
+      send(parser_method, content)
     rescue Psych::SyntaxError, JSON::ParserError, CSV::MalformedCSVError => error
-      raise Errors::DataParseError, "Failed to parse '#{@file_path}': #{error.message}"
+      raise Errors::DataParseError, "Failed to parse data format in `#{path}`: (#{error.class}) #{error.message}"
     end
 
+    def render_erb(content) = ERB.new(content).result(HelperContext.instance.get_binding)
+
     def parse_yaml(content)
-      YAML.safe_load(content, permitted_classes: [Symbol], aliases: true)
+      YAML.safe_load(content, permitted_classes: [Symbol, Time], aliases: true)
     end
 
     def parse_json(content)
@@ -58,6 +75,19 @@ module Perron
       CSV.new(content, headers: true, header_converters: :symbol).to_a.map(&:to_h)
     end
 
+    class HelperContext
+      include Singleton
+
+      def initialize
+        self.class.include ActionView::Helpers::AssetUrlHelper
+        self.class.include ActionView::Helpers::DateHelper
+        self.class.include Rails.application.routes.url_helpers
+      end
+
+      def get_binding = binding
+    end
+    private_constant :HelperContext
+
     class Item
       def initialize(attributes)
         @attributes = attributes.transform_keys(&:to_sym)
@@ -78,67 +108,3 @@ module Perron
     private_constant :Item
   end
 end
-
-# require "csv"
-
-# module Perron
-#   class Data
-#     include Enumerable
-
-#     def initialize(resource)
-#       @file_path = path_for(resource)
-#       @data = data
-#     end
-
-#     def each(&block)
-#       @data.each(&block)
-#     end
-
-#     private
-
-#     PARSER_METHODS = {
-#       ".csv" => :parse_csv,
-#       ".json" => :parse_json,
-#       ".yaml" => :parse_yaml,
-#       ".yml" => :parse_yaml
-#     }.freeze
-#     SUPPORTED_EXTENSIONS = PARSER_METHODS.keys.freeze
-
-#     def path_for(identifier)
-#       path = Pathname.new(identifier)
-
-#       return path.to_s if path.file? && path.absolute?
-
-#       found_path = SUPPORTED_EXTENSIONS.lazy.map do |extension|
-#         Rails.root.join("app", "content", "data").join("#{identifier}#{extension}")
-#       end.find(&:exist?)
-
-#       found_path&.to_s or raise Errors::FileNotFoundError, "No data file found for '#{identifier}'"
-#     end
-
-#     def data
-#       content = File.read(@file_path)
-#       extension = File.extname(@file_path)
-#       parser = PARSER_METHODS.fetch(extension) do
-#         raise Errors::UnsupportedDataFormatError, "Unsupported data format: #{extension}"
-#       end
-
-#       raw_data = send(parser, content)
-
-#       unless raw_data.is_a?(Array)
-#         raise Errors::DataParseError, "Data in '#{@file_path}' must be an array of objects."
-#       end
-
-#       struct = Struct.new(*raw_data.first.keys, keyword_init: true)
-#       raw_data.map { struct.new(**it) }
-#     rescue Psych::SyntaxError, JSON::ParserError, CSV::MalformedCSVError => error
-#       raise Errors::DataParseError, "Failed to parse '#{@file_path}': #{error.message}"
-#     end
-
-#     def parse_yaml(content) = YAML.safe_load(content, permitted_classes: [Symbol], aliases: true)
-
-#     def parse_json(content) = JSON.parse(content, symbolize_names: true)
-
-#     def parse_csv(content) = CSV.new(content, headers: true, header_converters: :symbol).to_a.map(&:to_h)
-#   end
-# end

data/lib/perron/site/resource/configuration.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Perron
+  class Resource
+    module Configuration
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def configuration
+          @configuration ||= Options.new.tap do |config|
+            config.metadata = Options.new
+
+            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.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.linked_data = ActiveSupport::OrderedOptions.new
+
+            config.related_posts = ActiveSupport::OrderedOptions.new
+            config.related_posts.enabled = false
+            config.related_posts.max = 5
+
+            config.sitemap = ActiveSupport::OrderedOptions.new
+            config.sitemap.exclude = false
+          end
+        end
+
+        def configure
+          yield(configuration)
+        end
+      end
+
+      class Options < ActiveSupport::OrderedOptions
+        def method_missing(name, *arguments)
+          if name.to_s.end_with?("=")
+            key = name.to_s.chomp("=").to_sym
+            value = arguments.first
+
+            return self[key].merge!(value) if self[key].is_a?(ActiveSupport::OrderedOptions) && value.is_a?(Hash)
+          end
+
+          super
+        end
+
+        def respond_to_missing?(name, include_private = false) = super
+      end
+      private_constant :Options
+    end
+  end
+end

data/lib/perron/site/resource/related/stop_words.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Perron
+  module Site
+    class Resource
+      class Related
+        module StopWords
+          module_function
+
+          def all
+            Set[
+              "a", "about", "above", "after", "again", "against", "all", "am",
+              "an", "and", "any", "are", "as", "at", "be", "because", "been",
+              "before", "being", "below", "between", "both", "but", "by", "can",
+              "did", "do", "does", "doing", "down", "during", "each", "few",
+              "for", "from", "further", "had", "has", "have", "having", "he",
+              "her", "here", "hers", "herself", "him", "himself", "his", "how",
+              "i", "if", "in", "into", "is", "it", "its", "itself", "just",
+              "me", "more", "most", "my", "myself", "no", "nor", "not", "now",
+              "of", "off", "on", "once", "only", "or", "other", "our", "ours",
+              "ourselves", "out", "over", "own", "s", "same", "she", "should",
+              "so", "some", "such", "t", "than", "that", "the", "their",
+              "theirs", "them", "themselves", "then", "there", "these", "they",
+              "this", "those", "through", "to", "too", "under", "until", "up",
+              "very", "was", "we", "were", "what", "when", "where", "which",
+              "while", "who", "whom", "why", "will", "with", "you", "your",
+              "yours", "yourself", "yourselves"
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/perron/site/resource/related.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "perron/site/resource/related/stop_words"
+
+module Perron
+  module Site
+    class Resource
+      class Related
+        def initialize(resource)
+          @resource = resource
+          @collection = resource.collection
+        end
+
+        def find(limit: 5)
+          @collection.resources
+            .reject { it.slug == @resource.slug }
+            .map { [it, cosine_similarities_for(@resource, it)] }
+            .sort_by { |_, score| -score }
+            .map(&:first)
+            .first(limit)
+        end
+
+        private
+
+        def cosine_similarities_for(resource_one, resource_two)
+          first_vector = tfidf_vector_for(resource_one)
+          second_vector = tfidf_vector_for(resource_two)
+
+          return 0.0 if first_vector.empty? || second_vector.empty?
+
+          dot_product = 0.0
+
+          first_vector.each_key { dot_product += first_vector[it] * second_vector[it] if second_vector.key?(it) }
+
+          first_magnitude = Math.sqrt(first_vector.values.sum { it**2 })
+          second_magnitude = Math.sqrt(second_vector.values.sum { it**2 })
+          denominator = first_magnitude * second_magnitude
+
+          return 0.0 if denominator.zero?
+
+          dot_product / denominator
+        end
+
+        def tfidf_vector_for(target_resource)
+          @tfidf_vectors ||= {}
+
+          return @tfidf_vectors[target_resource] if @tfidf_vectors.key?(target_resource)
+
+          tokens = tokenize_content(target_resource)
+          token_count = tokens.size
+
+          return {} if token_count.zero?
+
+          term_count = Hash.new(0)
+
+          tokens.each { |token| term_count[token] += 1 }
+
+          tfidf_vector = {}
+
+          term_count.each do |term, count|
+            terms = count.to_f / token_count
+
+            tfidf_vector[term] = terms * inverse_document_frequency[term]
+          end
+
+          @tfidf_vectors[target_resource] = tfidf_vector
+        end
+
+        def tokenize_content(target_resource)
+          @tokenized_content ||= {}
+
+          return @tokenized_content[target_resource] if @tokenized_content.key?(target_resource)
+
+          content = target_resource.content.gsub(/<[^>]*>/, " ")
+          tokens = content.downcase.scan(/\w+/).reject { StopWords.all.include?(it) || it.length < 3 }
+
+          @tokenized_content[target_resource] = tokens
+        end
+
+        def inverse_document_frequency
+          @inverse_document_frequency ||= begin
+            resource_frequency = Hash.new(0)
+
+            @collection.resources.each { tokenize_content(it).uniq.each { resource_frequency[it] += 1 } }
+
+            frequencies = {}
+            total_resources = @collection.resources.size
+
+            resource_frequency.each do |term, frequency|
+              frequencies[term] = Math.log(total_resources.to_f / (1 + frequency))
+            end
+
+            frequencies
+          end
+        end
+      end
+    end
+  end
+end

data/lib/perron/site/resource.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "perron/site/resource/configuration"
 require "perron/site/resource/core"
 require "perron/site/resource/class_methods"
 require "perron/site/resource/publishable"
+require "perron/site/resource/related"
 require "perron/site/resource/slug"
 require "perron/site/resource/separator"
 
@@ -10,6 +12,7 @@ module Perron
   class Resource
     ID_LENGTH = 8
 
+    include Perron::Resource::Configuration
     include Perron::Resource::Core
     include Perron::Resource::ClassMethods
     include Perron::Resource::Publishable
@@ -47,6 +50,9 @@ module Perron
 
     def collection = Collection.new(self.class.model_name.collection)
 
+    def related_resources(limit: 5) = Perron::Site::Resource::Related.new(self).find(limit:)
+    alias_method :related, :related_resources
+
     private
 
     def processable?
@@ -55,7 +61,7 @@ module Perron
 
     def generate_id
       Digest::SHA1.hexdigest(
-        @file_path.delete_prefix(Perron.configuration.input).parameterize
+        @file_path.delete_prefix(Perron.configuration.input.to_s).parameterize
       ).first(ID_LENGTH)
     end
   end

data/lib/perron/site.rb

@@ -4,6 +4,7 @@ require "perron/site/builder"
 require "perron/site/collection"
 require "perron/site/resource"
 require "perron/site/data"
+require "perron/site/data/proxy"
 
 module Perron
   module Site
@@ -24,13 +25,14 @@ module Perron
     def collections
       @collections ||= Dir.children(Perron.configuration.input)
         .select { File.directory?(File.join(Perron.configuration.input, it)) }
+        .reject { it == "data" }
         .map { Collection.new(it) }
     end
 
     def collection(name) = Collection.new(name)
 
-    def data(name)
-      Perron::Data.new(name)
+    def data(name = nil)
+      (name && Perron::Data.new(name)) || Perron::Data::Proxy.new
     end
   end
 end

data/lib/perron/version.rb

@@ -1,3 +1,3 @@
 module Perron
-  VERSION = "0.7.0"
+  VERSION = "0.9.0"
 end

data/lib/perron.rb

@@ -6,6 +6,7 @@ require "perron/errors"
 require "perron/root"
 require "perron/site"
 require "perron/markdown"
+require "perron/feeds"
 require "perron/metatags"
 require "perron/engine"