perron 0.18.0 → 1.1.0

data/lib/perron/data_source.rb

@@ -20,6 +20,20 @@ module Perron
       super(records)
     end
 
+    def self.all
+      identifier = name.to_s.split("::").drop(2).map { it.underscore }.join("/")
+      identifier = name.demodulize.underscore if identifier.empty?
+
+      return cached(identifier) if Perron.configuration.cache_data_sources
+
+      new(identifier)
+    end
+
+    def self.cached(identifier)
+      @_data_sources ||= {}
+      @_data_sources[identifier] ||= new(identifier)
+    end
+
     def each(&block) = @records.each(&block)
 
     def count = @records.count
@@ -52,23 +66,15 @@ module Perron
       end
 
       data.map.with_index do |item, index|
-        unless item.is_a?(Hash)
-          raise Errors::DataParseError, "Item at index #{index} in `#{@file_path}` must be a hash/object, got #{item.class}"
+        if item.is_a?(Hash)
+          Item.new(item, identifier: @identifier)
+        elsif item.is_a?(String)
+          item
+        else
+          raise Errors::DataParseError, "Item at index #{index} in `#{@file_path}` must be a hash/object or string, got #{item.class}"
         end
-
-        Item.new(item, identifier: @identifier)
       end
     end
-    # def records
-    #   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, identifier: @identifier) }
-    # end
 
     def rendered_from(path)
       raw_content = File.read(path)
@@ -86,16 +92,6 @@ module Perron
 
       send(parser_method, content, path)
     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 data format in `#{path}`: (#{error.class}) #{error.message}"
-    # end
 
     def render_erb(content) = ERB.new(content).result(HelperContext.instance.get_binding)
 
@@ -107,9 +103,6 @@ module Perron
 
       raise Errors::DataParseError, "Invalid YAML syntax in `#{path}`#{line_info}#{column_info}: #{error.problem}"
     end
-    # def parse_yaml(content)
-    #   YAML.safe_load(content, permitted_classes: [Symbol, Time], aliases: true)
-    # end
 
     def parse_json(content, path)
       JSON.parse(content, symbolize_names: true)
@@ -119,9 +112,6 @@ module Perron
 
       raise Errors::DataParseError, "Invalid JSON syntax in `#{path}`#{line_info}: #{error.message}"
     end
-    # def parse_json(content)
-    #   JSON.parse(content, symbolize_names: true)
-    # end
 
     def parse_csv(content, path)
       expected_headers = nil
@@ -148,8 +138,5 @@ module Perron
 
       raise Errors::DataParseError, "Malformed CSV in `#{path}`#{line_info}: #{error.message}"
     end
-    # def parse_csv(content)
-    #   CSV.new(content, headers: true, header_converters: :symbol).to_a.map(&:to_h)
-    # end
   end
 end

data/lib/perron/development_feed_server.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Perron
+  class DevelopmentFeedServer
+    def initialize(app)
+      @app = app
+    end
+
+    def call(environment)
+      request = Rack::Request.new(environment)
+
+      if build_only_path?(request.path_info)
+        render_message(request.path_info)
+      else
+        @app.call(environment)
+      end
+    end
+
+    private
+
+    def build_only_path?(path)
+      sitemap?(path) || feed?(path)
+    end
+
+    def render_message(path)
+      content_type = path.end_with?(".json") ? "application/json" : "application/xml"
+
+      [
+        200,
+
+        {
+          "Content-Type" => "#{content_type}; charset=utf-8",
+          "Content-Length" => message(path).bytesize.to_s
+        },
+
+        [message(path)]
+      ]
+    end
+
+    def sitemap?(path)
+      path.match?(/\/sitemap\.xml$/)
+    end
+
+    def feed?(path)
+      feed_paths.any? { path.end_with?("/#{it}") || path == "/#{it}" }
+    end
+
+    def message(path)
+      if path.end_with?(".json")
+        "{ \"message\": \"This feed is generated during build\" }"
+      elsif sitemap?(path)
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n  <!-- Sitemap is generated during build -->\n</urlset>"
+      else
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<feed xmlns=\"http://www.w3.org/2005/Atom\">\n  <!-- Feed is generated during build -->\n</feed>"
+      end
+    end
+
+    def feed_paths
+      @feed_paths ||= Perron::Site.collections.flat_map do |collection|
+        config = collection.configuration
+        next [] unless config && config[:feeds]
+
+        config[:feeds].values.filter_map do |feed_config|
+          feed_config[:path] if feed_config[:enabled]
+        end
+      end.compact
+    end
+  end
+end

data/lib/perron/engine.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "perron/output_server"
+require "perron/development_feed_server"
 require "mata"
 
 module Perron
@@ -10,7 +11,11 @@ module Perron
     end
 
     initializer "perron.output_server" do |app|
-      app.middleware.use Perron::OutputServer
+      app.middleware.use Perron::OutputServer if Rails.env.development?
+    end
+
+    initializer "perron.development_feed_server" do |app|
+      app.middleware.use Perron::DevelopmentFeedServer if Rails.env.development?
     end
 
     initializer "perron.configure_hmr", after: :load_config_initializers do |app|
@@ -24,11 +29,37 @@ module Perron
       end
     end
 
+    initializer "perron.concierge", before: :add_builtin_route do |app|
+      if Rails.env.development?
+        app.config.after_initialize do
+          app.routes.append do
+            namespace :perron do
+              post :run_command, to: "concierge#run_command"
+            end
+
+            root to: "perron/concierge#show" unless app.routes.named_routes.key?(:root)
+          end
+        end
+
+        app.routes.finalize!
+      end
+    end
+
+    initializer "perron.inflections" do
+      ActiveSupport::Inflector.inflections(:en) do |inflect|
+        inflect.acronym "RSS"
+        inflect.acronym "Atom"
+        inflect.acronym "Json"
+      end
+    end
+
     rake_tasks do
       load File.expand_path("../tasks/build.rake", __FILE__)
       load File.expand_path("../tasks/clobber.rake", __FILE__)
+      load File.expand_path("../tasks/install.rake", __FILE__)
       load File.expand_path("../tasks/sync_sources.rake", __FILE__)
       load File.expand_path("../tasks/validate.rake", __FILE__)
+      load File.expand_path("../tasks/deploy.rake", __FILE__)
     end
   end
 end

data/lib/perron/errors.rb

@@ -10,6 +10,8 @@ module Perron
 
     class DataParseError < StandardError; end
 
+    class DataSourceNotFoundError < StandardError; end
+
     class ProcessorNotFoundError < StandardError; end
 
     class InvalidProcessorError < StandardError; end

data/lib/perron/feeds.rb

@@ -19,7 +19,7 @@ module Perron
             next unless feed.enabled && feed.path && MIME_TYPES.key?(type)
 
             absolute_url = URI.join(url.root_url, feed.path).to_s
-            title = "#{collection.name.humanize} #{type.to_s.upcase} Feed"
+            title = "#{collection.name.humanize} #{type.to_s.humanize} Feed"
 
             html_tags << tag(:link, rel: "alternate", type: MIME_TYPES[type], title: title, href: absolute_url)
           end
@@ -32,8 +32,9 @@ module Perron
     private
 
     MIME_TYPES = {
-      rss: "application/rss+xml",
-      json: "application/json"
+      atom: "application/atom+xml",
+      json: "application/json",
+      rss: "application/rss+xml"
     }
   end
 end

data/lib/perron/html_processor/absolute_urls.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Perron
+  class HtmlProcessor
+    class AbsoluteUrls < HtmlProcessor::Base
+      def process
+        @html.css("img").each do |image|
+          src = image["src"]
+
+          next if src.blank? || absolute_url?(src)
+
+          image["src"] = base_url + src
+        end
+      end
+
+      private
+
+      def absolute_url?(src)
+        src.start_with?("http://", "https://", "//")
+      end
+
+      def base_url
+        Perron.configuration.url.delete_suffix("/")
+      end
+    end
+  end
+end

data/lib/perron/html_processor/base.rb

@@ -3,8 +3,8 @@
 module Perron
   class HtmlProcessor
     class Base
-      def initialize(html)
-        @html = html
+      def initialize(html, resource: nil)
+        @html, @resource = html, resource
       end
 
       def process

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/{generators/perron/templates → perron/install}/README.md.tt

@@ -7,10 +7,10 @@ Perron can consume structured data from YML, JSON or CSV files, making them avai
 
 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 %>
+<% 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.
@@ -34,15 +34,15 @@ feature[:name]
 
 Render data collections directly using Rails-like partial rendering:
 ```erb
-<%%= render Content::Data::Features.all %>
+<%= 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>
+  <h4><%= feature.name %></h4>
+  <p><%= feature.description %></p>
 </div>
 ```
 
@@ -64,6 +64,4 @@ Data resources must contain an array of objects. Each record should include an `
 
 ## Enumerable methods
 
-[!label v0.17.0+]
-
 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/perron/install/deploy.yml

@@ -0,0 +1,15 @@
+# Deploy configuration for Perron
+# Requires Beam Up (`bundle add beam_up`)
+# See also: https://perron.railsdesigner.com/docs/deploy/
+
+# Uncomment and configure your provider:
+# provider: netlify
+
+# netlify:
+#   api_token: your_token_here
+#   site_id: your_site_id
+
+before_actions:
+  - RAILS_ENV=production bundle exec rails perron:build
+after_actions:
+  - bundle exec rails perron:clobber

data/lib/perron/install.rb

@@ -0,0 +1,26 @@
+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 "Create deploy configuration"
+copy_file "#{__dir__}/install/deploy.yml", "config/deploy.yml"
+
+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)
@@ -41,6 +42,14 @@ module Perron
       ]
     end
 
+    def not_found
+      [
+        404,
+        {"Content-Type" => "text/plain"},
+        ["Not Found"]
+      ]
+    end
+
     def enabled? = Dir.exist?(output_path)
 
     def inject_preview_indicator(content)

data/lib/perron/paginate.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Perron
+  class Paginate
+    def initialize(collection, page:, per_page:, base_path: nil, page_path_template: nil, use_query_params: false)
+      @collection = collection
+      @per_page = per_page
+      @base_path = base_path
+      @page_path_template = page_path_template || "/page/:page/"
+      @use_query_params = use_query_params
+
+      @total_items = collection.size
+      @total_pages = total_items.zero? ? 0 : (total_items.to_f / per_page).ceil
+      @current_page = page.clamp(1, total_pages.zero? ? 1 : total_pages)
+    end
+
+    attr_reader :current_page, :total_pages, :total_items, :per_page
+
+    def items
+      offset = (@current_page - 1) * @per_page
+
+      @collection[offset, @per_page] || []
+    end
+
+    def next? = @current_page < @total_pages
+
+    def previous? = @current_page > 1
+
+    def next
+      return unless next?
+
+      page_path(@current_page + 1)
+    end
+
+    def previous
+      return unless previous?
+
+      target = (@current_page == 2) ? 1 : @current_page - 1
+
+      page_path(target)
+    end
+
+    private
+
+    attr_reader :use_query_params
+
+    def page_path(number)
+      return if number < 1
+      return if number > @total_pages && @total_pages > 0
+
+      return @base_path if number <= 1
+
+      return "#{@base_path}?page=#{number}" if @use_query_params
+
+      @base_path.sub(/\/$/, "") + @page_path_template.sub(":page", number.to_s)
+    end
+  end
+end

data/lib/perron/relation.rb

@@ -2,9 +2,12 @@
 
 module Perron
   class Relation < Array
-    def initialize(resources = [])
-      super
+    def initialize(resources = [], model_class = nil)
+      super(resources)
+
+      @model_class = model_class
     end
+    attr_reader :model_class
 
     def where(**conditions)
       filtered = select do |resource|
@@ -19,12 +22,12 @@ module Perron
         end
       end
 
-      Relation.new(filtered)
+      Relation.new(filtered, @model_class)
     end
 
-    def limit(count) = Relation.new(first(count))
+    def limit(count) = Relation.new(first(count), @model_class)
 
-    def offset(count) = Relation.new(drop(count))
+    def offset(count) = Relation.new(drop(count), @model_class)
 
     def order(attribute, direction = :asc)
       if attribute.is_a?(Hash)
@@ -33,7 +36,7 @@ module Perron
 
       sorted = sort_by { it.public_send(attribute) }
 
-      Relation.new((direction == :desc) ? sorted.reverse : sorted)
+      Relation.new((direction == :desc) ? sorted.reverse : sorted, @model_class)
     end
 
     def pluck(*attributes)
@@ -47,5 +50,20 @@ module Perron
         end
       end
     end
+
+    def in_order_of(attribute, values, filter: true)
+      return Relation.new([]) if values.empty?
+
+      indexed = values.each_with_index.to_h
+
+      resources = if filter
+        select { indexed.key?(it.public_send(attribute)) }
+          .sort_by { indexed[it.public_send(attribute)] }
+      else
+        sort_by { indexed[it.public_send(attribute)] || Float::INFINITY }
+      end
+
+      Relation.new(resources)
+    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

data/lib/perron/resource/class_methods.rb

@@ -22,6 +22,8 @@ module Perron
 
         def order(attribute, direction = :asc) = all.order(attribute, direction)
 
+        def in_order_of(attribute, values, filter: true) = all.in_order_of(attribute, values, filter:)
+
         def first(n = nil)
           n ? all.first(n) : all[0]
         end
@@ -44,6 +46,10 @@ module Perron
 
         def root = all.find(&:root?)
 
+        def destroy_all
+          all.each(&:destroy)
+        end
+
         def model_name
           @model_name ||= ActiveModel::Name.new(self, nil, name.demodulize.to_s)
         end