perron 0.17.0 → 1.0.0

data/lib/perron/html_processor.rb

@@ -2,17 +2,19 @@
 
 require "perron/html_processor/target_blank"
 require "perron/html_processor/lazy_load_images"
+require "perron/html_processor/absolute_urls"
 
 module Perron
   class HtmlProcessor
-    def initialize(html, processors: [])
+    def initialize(html, processors: [], resource: nil)
       @html = html
+      @resource = resource
       @processors = processors.map { find_by(it) }
     end
 
     def process
       Nokogiri::HTML::DocumentFragment.parse(@html).tap do |document|
-        @processors.each { it.new(document).process }
+        @processors.each { it.new(document, resource: @resource).process }
       end.to_html
     end
 
@@ -20,14 +22,9 @@ module Perron
 
     BUILT_IN = {
       "target_blank" => Perron::HtmlProcessor::TargetBlank,
-      "lazy_load_images" => Perron::HtmlProcessor::LazyLoadImages
-    }.tap do |processors|
-      require "rouge"
-      require "perron/html_processor/syntax_highlight"
-
-      processors["syntax_highlight"] = Perron::HtmlProcessor::SyntaxHighlight
-    rescue LoadError
-    end
+      "lazy_load_images" => Perron::HtmlProcessor::LazyLoadImages,
+      "absolute_urls" => Perron::HtmlProcessor::AbsoluteUrls
+    }
 
     def find_by(identifier)
       case identifier
@@ -47,7 +44,6 @@ module Perron
 
       return processor if processor
 
-      raise Perron::Errors::ProcessorNotFoundError, "The `syntax_highlight` processor requires `rouge`. Run `bundle add rouge` to add it to your Gemfile." if name.inquiry.syntax_highlight?
       raise Perron::Errors::ProcessorNotFoundError, "Could not find processor `#{name}`. It is not a Perron-included processor and the constant `#{name.camelize}` could not be found."
     end
   end

data/lib/perron/install/README.md.tt

@@ -0,0 +1,67 @@
+# Data
+
+Perron can consume structured data from YML, JSON or CSV files, making them available within views. This is useful for populating features, team members or any other repeated data structure.
+
+
+## Usage
+
+Access data sources using the `Content::Data` namespace with the class name matching the file's basename:
+```erb
+<% Content::Data::Features.all.each do |feature| %>
+  <h4><%= feature.name %></h4>
+  <p><%= feature.description %></p>
+<% end %>
+```
+
+Look up a single entry with `Content::Data::Features.find("advanced-search")`, where `"advanced-search"` matches the value of the entry's `id` field.
+
+
+## File location and formats
+
+By default, Perron looks up `app/content/data/` for files with a `.yml`, `.json` or `.csv` extension. For a `features` call, it would find `features.yml`, `features.json` or `features.csv`. Provide a path to any data resource in `/app/content/data/`, via `Content::Data.new("path/to/data-resource")`.
+
+
+## Accessing data
+
+The wrapper object provides flexible, read-only access to each record's attributes. Both dot notation and hash-like key access are supported.
+```ruby
+feature.name
+feature[:name]
+```
+
+
+## Rendering
+
+Render data collections directly using Rails-like partial rendering:
+```erb
+<%= render Content::Data::Features.all %>
+```
+
+This expects a partial at `app/views/content/features/_feature.html.erb` that will be rendered once for each item in `Content::Data::Features.all`. The individual record is made available as a local variable matching the singular form of the collection name.
+```erb
+<!-- app/views/content/features/_feature.html.erb -->
+<div class="feature">
+  <h4><%= feature.name %></h4>
+  <p><%= feature.description %></p>
+</div>
+```
+
+
+## Data structure
+
+Data resources must contain an array of objects. Each record should include an `id` field if used with [associations](/docs/resources/#associations) or with the `find` method:
+```yaml
+# app/content/data/authors.yml
+- id: rails-designer
+  name: Rails Designer
+  bio: Creator of Perron
+
+- id: cam
+  name: Cam
+  bio: Contributing author
+```
+
+
+## Enumerable methods
+
+All data objects support enumerable methods like `select`, `sort_by`, `first` and `count`. See [Enumerable methods](/docs/rendering/#enumerable-methods) for the full list of available methods.

data/lib/{generators/perron/templates → perron/install}/initializer.rb.tt

@@ -1,16 +1,20 @@
 Perron.configure do |config|
-  # View all options: https://perron.railsdesigner.com/docs/configuration/
+  # For all options check out:
+  # https://perron.railsdesigner.com/docs/configuration/
 
-  # config.site_name = "Chirp Form"
-
-  # The build mode for Perron. Can be :standalone (SSG) or :integrated (alongside your Rails app)
+  # The build mode for Perron. Can be :standalone (SSG, default) or :integrated (alongside your Rails app)
   # config.mode = :standalone
 
+  # Enable Live Reload with DOM Morphing in development
+  # config.live_reload = true
+
   # config.default_url_options = {host: "chirpform.com", protocol: "https", trailing_slash: true}
 
   # The options hash is passed directly to the chosen library
   # config.markdown_options = {}
 
+  # config.site_name = "Chirp Form"
+
   # Set meta title suffix
   # config.metadata.title_suffix = nil
   # config.metadata.title_separator = " — "

data/lib/perron/install.rb

@@ -0,0 +1,23 @@
+say "Install Perron in your Rails app"
+
+say "Create Perron initializer"
+copy_file "#{__dir__}/install/initializer.rb", "config/initializers/perron.rb"
+
+say "Create content data directory"
+copy_file "#{__dir__}/install/README.md", "app/content/data/README.md"
+
+say "Add Markdown gem options to Gemfile"
+append_to_file "Gemfile", <<~RUBY
+
+  # Perron supports Markdown rendering using one of the following gems.
+  # Uncomment your preferred choice and run `bundle install`
+  # gem "commonmarker"
+  # gem "kramdown"
+  # gem "redcarpet"
+RUBY
+
+copy_file "#{__dir__}/assets/icon.png", "public/icon.png", force: true
+copy_file "#{__dir__}/assets/icon.svg", "public/icon.svg", force: true
+
+say "Add output folder to .gitignore"
+append_to_file ".gitignore", "/#{Perron.configuration.output}/\n"

data/lib/perron/markdown.rb

@@ -5,9 +5,9 @@ require "perron/html_processor"
 module Perron
   class Markdown
     class << self
-      def render(text, processors: [])
+      def render(text, processors: [], resource: nil)
         parser.parse(text)
-          .then { Perron::HtmlProcessor.new(it, processors: processors).process }
+          .then { Perron::HtmlProcessor.new(it, processors: processors, resource: resource).process }
           .html_safe
       end
 

data/lib/perron/output_server.rb

@@ -8,6 +8,7 @@ module Perron
 
     def call(environment)
       return @app.call(environment) if disabled?
+      return not_found if !static_file(environment) && Perron.configuration.output_server_strict
 
       static_file(environment).then do |file|
         file ? serve(file) : @app.call(environment)
@@ -27,21 +28,34 @@ module Perron
 
     def serve(file_path)
       content = File.read(file_path)
+      injected_content = inject_preview_indicator(content)
 
       [
         200,
 
         {
           "Content-Type" => "text/html; charset=utf-8",
-          "Content-Length" => content.bytesize.to_s
+          "Content-Length" => injected_content.bytesize.to_s
         },
 
-        [content]
+        [injected_content]
+      ]
+    end
+
+    def not_found
+      [
+        404,
+        {"Content-Type" => "text/plain"},
+        ["Not Found"]
       ]
     end
 
     def enabled? = Dir.exist?(output_path)
 
+    def inject_preview_indicator(content)
+      content.gsub(/<title>(.*?)<\/title>/i, "<title>[PREVIEW] \\1</title>")
+    end
+
     def output_path
       @output_path ||= Rails.root.join(Perron.configuration.output)
     end

data/lib/perron/relation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Perron
+  class Relation < Array
+    def initialize(resources = [])
+      super
+    end
+
+    def where(**conditions)
+      filtered = select do |resource|
+        conditions.all? do |key, value|
+          key_value = resource.public_send(key)
+
+          if value.is_a?(Array)
+            value.map(&:to_s).include?(key_value.to_s)
+          else
+            key_value.to_s == value.to_s
+          end
+        end
+      end
+
+      Relation.new(filtered)
+    end
+
+    def limit(count) = Relation.new(first(count))
+
+    def offset(count) = Relation.new(drop(count))
+
+    def order(attribute, direction = :asc)
+      if attribute.is_a?(Hash)
+        attribute, direction = attribute.first
+      end
+
+      sorted = sort_by { it.public_send(attribute) }
+
+      Relation.new((direction == :desc) ? sorted.reverse : sorted)
+    end
+
+    def pluck(*attributes)
+      raise ArgumentError, "wrong number of arguments (given 0, expected 1+)" if attributes.empty?
+
+      map do |resource|
+        if attributes.size == 1
+          resource.public_send(attributes.first)
+        else
+          attributes.map { resource.public_send(it) }
+        end
+      end
+    end
+  end
+end

data/lib/perron/resource/adjacency.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Perron
+  class Resource
+    module Adjacency
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def adjacent_by(position_method, within: {})
+          return unless within.present?
+
+          grouping_method = within.is_a?(Hash) ? within.keys.first : within
+          grouping_order = within.is_a?(Hash) ? within.values.first : nil
+
+          define_method(:next) do
+            resources = self.class.all.sort_by do |resource|
+              group_value = resource.public_send(grouping_method)
+
+              group_order = if grouping_order
+                grouping_order.index(group_value.to_s) || grouping_order.index(group_value.to_sym) || Float::INFINITY
+              else
+                group_value.to_s
+              end
+
+              [group_order, resource.public_send(position_method)]
+            end
+
+            return if (position = resources.index { it.id == id }).nil? || position >= resources.size - 1
+
+            resources[position + 1]
+          end
+
+          define_method(:previous) do
+            resources = self.class.all.sort_by do |resource|
+              group_value = resource.public_send(grouping_method)
+
+              group_order = if grouping_order
+                grouping_order.index(group_value.to_s) || grouping_order.index(group_value.to_sym) || Float::INFINITY
+              else
+                group_value.to_s
+              end
+
+              [group_order, resource.public_send(position_method)]
+            end
+
+            return if (position = resources.index { it.id == id }).nil? || position <= 0
+
+            resources[position - 1]
+          end
+        end
+      end
+
+      included do
+        define_method(:next) do
+          resources = self.class.all
+          return if (position = resources.index { it.id == id }).nil? || position >= resources.size - 1
+
+          resources[position + 1]
+        end
+
+        define_method(:previous) do
+          resources = self.class.all
+          return if (position = resources.index { it.id == id }).nil? || position <= 0
+
+          resources[position - 1]
+        end
+      end
+    end
+  end
+end

data/lib/perron/resource/associations.rb

@@ -13,7 +13,7 @@ module Perron
               foreign_key = foreign_key_for(association_name, **options)
               identifier = metadata[foreign_key]
 
-              identifier ? associated_class.find(identifier) : nil
+              identifier ? associated_class.find!(identifier) : nil
             end
           end
         end
@@ -66,7 +66,7 @@ module Perron
       def records_for_ids(associated_class, ids)
         ids = Array(ids)
 
-        associated_class.all.select { ids.include?(it[:id]) || ids.include?(it["id"]) }
+        Perron::Relation.new(associated_class.all.select { ids.include?(it[:id]) || ids.include?(it["id"]) })
       end
 
       def records_for_foreign_key(associated_class, association_name, **options)
@@ -74,7 +74,7 @@ module Perron
         primary_key_method = options.fetch(:primary_key, :slug)
         lookup_value = public_send(primary_key_method)
 
-        associated_class.all.select { it.association_value(foreign_key) == lookup_value }
+        Perron::Relation.new(associated_class.all.select { it.association_value(foreign_key) == lookup_value })
       end
 
       def inverse_association_name = self.class.name.demodulize.underscore

data/lib/perron/resource/class_methods.rb

@@ -8,10 +8,20 @@ module Perron
       class_methods do
         def find(slug) = collection.find(slug, name.constantize)
 
+        def find!(slug) = collection.find!(slug, name.constantize)
+
         def all = collection.all(self)
 
+        def where(**conditions) = all.where(**conditions)
+
+        def limit(count) = all.limit(count)
+
+        def offset(count) = all.offset(count)
+
         def count = all.size
 
+        def order(attribute, direction = :asc) = all.order(attribute, direction)
+
         def first(n = nil)
           n ? all.first(n) : all[0]
         end

data/lib/perron/resource/configuration.rb

@@ -12,17 +12,20 @@ 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.linked_data = ActiveSupport::OrderedOptions.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.related_posts = ActiveSupport::OrderedOptions.new
             config.related_posts.enabled = false
@@ -39,18 +42,17 @@ module Perron
       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)
+        def []=(key, value)
+          if self[key].is_a?(ActiveSupport::OrderedOptions) && value.is_a?(Hash)
+            self[key].merge!(value)
+          else
+            super
           end
-
-          super
         end
 
-        def respond_to_missing?(name, include_private = false) = super
+        def respond_to_missing?(name, include_private = false)
+          name.to_s.end_with?("=") || super
+        end
       end
       private_constant :Options
     end

data/lib/perron/resource/core.rb

@@ -10,6 +10,17 @@ module Perron
       def to_model = self
 
       def model_name = self.class.model_name
+
+      def association_value(key) = metadata[key]
+
+      def to_partial_path
+        @to_partial_path ||= begin
+          element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self.class.model_name))
+          collection = ActiveSupport::Inflector.tableize(self.class.model_name)
+
+          File.join("content", collection, element)
+        end
+      end
     end
   end
 end

data/lib/perron/resource/metadata.rb

@@ -25,6 +25,8 @@ module Perron
 
         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 +54,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/stop_words.rb

@@ -5,28 +5,28 @@ module Perron
     class Resource
       class Related
         module StopWords
+          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"
+          ].freeze
+
           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
+          def all = ALL
         end
       end
     end