bridgetown-core 0.19.2 → 0.21.0.beta3

data/lib/bridgetown-core/readers/defaults_reader.rb

@@ -18,7 +18,7 @@ module Bridgetown
 
       entries.each do |entry|
         path = @site.in_source_dir(entry)
-        @path_defaults[File.dirname(path) + File::SEPARATOR] = SafeYAML.load_file(path)
+        @path_defaults[File.dirname(path) + File::SEPARATOR] = YAMLParser.load_file(path)
       end
 
       @path_defaults

data/lib/bridgetown-core/readers/page_reader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Bridgetown
+  # TODO: to be retired once the Resource engine is made official
   class PageReader
     attr_reader :site, :dir, :unfiltered_content
 

data/lib/bridgetown-core/readers/post_reader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Bridgetown
+  # TODO: to be retired once the Resource engine is made official
   class PostReader
     attr_reader :site, :unfiltered_content
 
@@ -47,7 +48,7 @@ module Bridgetown
           # Process as Document
           Document.new(path,
                        site: @site,
-                       collection: @site.posts)
+                       collection: @site.collections.posts)
         else
           # Process as Static File
           read_static_file(
@@ -66,7 +67,7 @@ module Bridgetown
         site.source,
         relative_dir,
         File.basename(full_path),
-        @site.posts
+        @site.collections.posts
       )
     end
 
@@ -96,9 +97,9 @@ module Bridgetown
       return false unless processable?(item)
 
       if item.is_a?(Document)
-        site.posts.docs << item
+        site.collections.posts.docs << item
       elsif item.is_a?(StaticFile)
-        site.posts.files << item
+        site.collections.posts.static_files << item
         site.static_files << item
       end
 

data/lib/bridgetown-core/regenerator.rb

@@ -19,7 +19,7 @@ module Bridgetown
     # Checks if a renderable object needs to be regenerated
     #
     # Returns a boolean.
-    def regenerate?(document)
+    def regenerate?(document) # rubocop:todo Metrics/CyclomaticComplexity
       return true if disabled
 
       case document
@@ -27,6 +27,8 @@ module Bridgetown
         regenerate_page?(document)
       when Document
         regenerate_document?(document)
+      when Bridgetown::Resource::Base
+        regenerate_resource?(document)
       else
         source_path = document.respond_to?(:path) ? document.path : nil
         dest_path = document.destination(@site.dest) if document.respond_to?(:destination)
@@ -152,7 +154,7 @@ module Bridgetown
           begin
             Marshal.load(content)
           rescue TypeError
-            SafeYAML.load(content)
+            YAMLParser.load(content)
           rescue ArgumentError => e
             Bridgetown.logger.warn("Failed to load #{metadata_file}: #{e}")
             {}
@@ -176,6 +178,11 @@ module Bridgetown
         )
     end
 
+    # TODO: need to manage dependencies, but for now always regenerate
+    def regenerate_resource?(_resource)
+      true
+    end
+
     def existing_file_modified?(path)
       # If one of this file dependencies have been modified,
       # set the regeneration bit for both the dependency and the file to true

data/lib/bridgetown-core/related_posts.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Bridgetown
+  # TODO: to be retired once the Resource engine is made official
   class RelatedPosts
     class << self
       attr_accessor :lsi
@@ -11,13 +12,15 @@ module Bridgetown
     def initialize(post)
       @post = post
       @site = post.site
-      Bridgetown::External.require_with_graceful_fail("classifier-reborn") if site.lsi
+      if site.config.lsi
+        Bridgetown::Utils::RequireGems.require_with_graceful_fail("classifier-reborn")
+      end
     end
 
     def build
-      return [] unless site.posts.docs.size > 1
+      return [] unless site.collections.posts.docs.size > 1
 
-      if site.lsi
+      if site.config.lsi
         build_index
         lsi_related_posts
       else
@@ -30,7 +33,7 @@ module Bridgetown
         lsi = ClassifierReborn::LSI.new(auto_rebuild: false)
         Bridgetown.logger.info("Populating LSI...")
 
-        site.posts.docs.each do |x|
+        site.collections.posts.docs.each do |x|
           lsi.add_item(x)
         end
 
@@ -42,11 +45,11 @@ module Bridgetown
     end
 
     def lsi_related_posts
-      self.class.lsi.find_related(post, 11)
+      self.class.lsi.find_related(post, 11) - [post]
     end
 
     def most_recent_posts
-      @most_recent_posts ||= (site.posts.docs.last(11).reverse - [post]).first(10)
+      @most_recent_posts ||= (site.collections.posts.docs.last(11).reverse - [post]).first(10)
     end
   end
 end

data/lib/bridgetown-core/renderer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Bridgetown
+  # This class handles the output rendering and layout placement of pages and
+  # documents. For rendering of resources in particular, see Bridgetown::Resource::Transformer
   class Renderer
     attr_reader :document, :site
 
@@ -50,7 +52,7 @@ module Bridgetown
       output = document.content
       Bridgetown.logger.debug "Rendering Markup:", document.relative_path
       output = convert(output.to_s, document)
-      document.content = output
+      document.content = output.html_safe
 
       if document.place_in_layout?
         Bridgetown.logger.debug "Rendering Layout:", document.relative_path
@@ -121,21 +123,11 @@ module Bridgetown
         "in #{document.relative_path} does not exist."
     end
 
-    def converters_for_layout(layout)
-      site.converters.select do |converter|
-        if converter.method(:matches).arity == 1
-          converter.matches(layout.ext)
-        else
-          converter.matches(layout.ext, layout)
-        end
-      end.sort
-    end
-
     # Render layout content into document.output
     #
     # Returns String rendered content
     def render_layout(output, layout)
-      layout_converters = converters_for_layout(layout)
+      layout_converters = site.matched_converters_for_convertible(layout)
 
       layout_content = layout.content.dup
       layout_converters.reduce(layout_content) do |layout_output, converter|
@@ -163,7 +155,8 @@ module Bridgetown
 
     def permalink_ext
       document_permalink = document.permalink
-      if document_permalink && !document_permalink.end_with?("/")
+      if document_permalink &&
+          !document_permalink.end_with?("/")
         permalink_ext = File.extname(document_permalink)
         permalink_ext unless permalink_ext.empty?
       end

data/lib/bridgetown-core/resource/base.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class Base
+      include Comparable
+      include Bridgetown::Publishable
+      include Bridgetown::LayoutPlaceable
+      include Bridgetown::LiquidRenderable
+
+      # @return [HashWithDotAccess::Hash]
+      attr_reader :data
+
+      # @return [Destination]
+      attr_reader :destination
+
+      # @return [Bridgetown::Model::Base]
+      attr_reader :model
+
+      # @return [Bridgetown::Site]
+      attr_reader :site
+
+      # @return [String]
+      attr_accessor :content, :untransformed_content, :output
+
+      DATE_FILENAME_MATCHER = %r!^(?>.+/)*?(\d{2,4}-\d{1,2}-\d{1,2})-([^/]*)(\.[^.]+)$!.freeze
+
+      # @param site [Bridgetown::Site]
+      # @param origin [Bridgetown::Resource::Origin]
+      def initialize(model:)
+        @model = model
+        @site = model.site
+        self.data = HashWithDotAccess::Hash.new
+
+        trigger_hooks(:post_init)
+      end
+
+      # Collection associated with this resource
+      #
+      # @return [Bridgetown::Collection]
+      def collection
+        model.collection
+      end
+
+      # The relative path of source file or file-like origin
+      #
+      # @return [Pathname]
+      def relative_path
+        model.origin.relative_path
+      end
+
+      # @return [Bridgetown::Resource::Transformer]
+      def transformer
+        @transformer ||= Bridgetown::Resource::Transformer.new(self)
+      end
+
+      # @return [Bridgetown::Resource::Relations]
+      def relations
+        @relations ||= Bridgetown::Resource::Relations.new(self)
+      end
+
+      # @param new_data [HashWithDotAccess::Hash]
+      def data=(new_data)
+        unless new_data.is_a?(HashWithDotAccess::Hash)
+          raise "#{self.class} data should be of type HashWithDotAccess::Hash"
+        end
+
+        @data = new_data
+        @data.default_proc = proc do |_, key|
+          site.frontmatter_defaults.find(
+            relative_path.to_s,
+            collection.label.to_sym,
+            key.to_s
+          )
+        end
+      end
+
+      # @return [Bridgetown::Resource::Base]
+      def read!
+        self.data = model.data_attributes
+        self.content = model.content # could be nil
+
+        unless collection.data?
+          self.untransformed_content = content
+          normalize_categories_and_tags
+          import_taxonomies_from_data
+          ensure_default_data
+          transformer.execute_inline_ruby!
+          set_date_from_string(data.date)
+        end
+
+        @destination = Destination.new(self) if requires_destination?
+
+        trigger_hooks(:post_read)
+
+        self
+      end
+      alias_method :read, :read! # TODO: eventually use the bang version only
+
+      def transform!
+        transformer.process! unless collection.data?
+      end
+
+      def trigger_hooks(hook_name, *args)
+        Bridgetown::Hooks.trigger collection.label.to_sym, hook_name, self, *args if collection
+        Bridgetown::Hooks.trigger :resources, hook_name, self, *args
+      end
+
+      def around_hook(hook_suffix)
+        trigger_hooks :"pre_#{hook_suffix}"
+        yield
+        trigger_hooks :"post_#{hook_suffix}"
+      end
+
+      # @return [String]
+      def relative_path_basename_without_prefix
+        return_path = Pathname.new("")
+        relative_path.each_filename do |filename|
+          if matches = DATE_FILENAME_MATCHER.match(filename) # rubocop:disable Lint/AssignmentInCondition
+            filename = matches[2] + matches[3]
+          end
+
+          return_path += filename unless filename.starts_with?("_")
+        end
+
+        (return_path.dirname + return_path.basename(".*")).to_s
+      end
+
+      # @return [String]
+      def basename_without_ext
+        relative_path.basename(".*").to_s
+      end
+
+      # @return [String]
+      def extname
+        relative_path.extname
+      end
+
+      # @return [String, nil]
+      def permalink
+        data&.permalink
+      end
+
+      # @return [String]
+      def path
+        (model.origin.respond_to?(:original_path) ? model.origin.original_path : relative_path).to_s
+      end
+
+      # @return [String]
+      def absolute_url
+        format_url destination&.absolute_url
+      end
+
+      # @return [String]
+      def relative_url
+        format_url destination&.relative_url
+      end
+
+      # @return [String]
+      def id
+        model.origin.id
+      end
+
+      def date
+        data["date"] ||= site.time
+      end
+
+      # @return [Hash<String, Hash<String => Bridgetown::Resource::TaxonomyType,
+      #   Array<Bridgetown::Resource::TaxonomyTerm>>>]
+      def taxonomies
+        @taxonomies ||= site.taxonomy_types.values.each_with_object(
+          HashWithDotAccess::Hash.new
+        ) do |taxonomy, hsh|
+          hsh[taxonomy.label] = {
+            type: taxonomy,
+            terms: [],
+          }
+        end
+      end
+
+      def requires_destination?
+        collection.write? && data.config&.output != false
+      end
+
+      def write?
+        requires_destination? && site.publisher.publish?(self)
+      end
+
+      # Write the generated Document file to the destination directory.
+      #
+      # dest - The String path to the destination dir.
+      #
+      # Returns nothing.
+      def write(_dest = nil)
+        destination.write(output)
+        trigger_hooks(:post_write)
+      end
+
+      def to_s
+        output || content || ""
+      end
+
+      # Create a Liquid-understandable version of this resource.
+      #
+      # @return [Drops::ResourceDrop] represents this resource's data.
+      def to_liquid
+        @to_liquid ||= Drops::ResourceDrop.new(self)
+      end
+
+      def to_h
+        {
+          id: id,
+          absolute_url: absolute_url,
+          relative_path: relative_path,
+          relative_url: relative_url,
+          date: date,
+          data: data,
+          taxonomies: taxonomies,
+          untransformed_content: untransformed_content,
+          content: content,
+          output: output,
+        }
+      end
+
+      def as_json(*)
+        to_h
+      end
+
+      ruby2_keywords def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+
+      def inspect
+        "#<#{self.class} #{id}>"
+      end
+
+      # Compare this document against another document.
+      # Comparison is a comparison between the 2 paths of the documents.
+      #
+      # Returns -1, 0, +1 or nil depending on whether this doc's path is less than,
+      #   equal or greater than the other doc's path. See String#<=> for more details.
+      def <=>(other) # rubocop:todo Metrics/AbcSize
+        return nil unless other.respond_to?(:data)
+
+        if data.date.respond_to?(:to_datetime) && other.data.date.respond_to?(:to_datetime)
+          return data.date.to_datetime <=> other.data.date.to_datetime
+        end
+
+        cmp = data["date"] <=> other.data["date"]
+        cmp = path <=> other.path if cmp.nil? || cmp.zero?
+        cmp
+      end
+
+      def next_resource
+        pos = collection.resources.index { |item| item.equal?(self) }
+        collection.resources[pos + 1] if pos && pos < collection.resources.length - 1
+      end
+      alias_method :next_doc, :next_resource
+
+      def previous_resource
+        pos = collection.resources.index { |item| item.equal?(self) }
+        collection.resources[pos - 1] if pos&.positive?
+      end
+      alias_method :previous_doc, :previous_resource
+
+      private
+
+      def ensure_default_data
+        slug = if matches = relative_path.to_s.match(DATE_FILENAME_MATCHER) # rubocop:disable Lint/AssignmentInCondition
+                 set_date_from_string(matches[1]) unless data.date
+                 matches[2]
+               else
+                 basename_without_ext
+               end
+
+        data.slug ||= slug
+        data.title ||= Bridgetown::Utils.titleize_slug(slug)
+      end
+
+      def set_date_from_string(new_date) # rubocop:disable Naming/AccessorMethodName
+        return unless new_date.is_a?(String)
+
+        data.date = Bridgetown::Utils.parse_date(
+          new_date,
+          "Document '#{relative_path}' does not have a valid date in the #{model}."
+        )
+      end
+
+      def normalize_categories_and_tags
+        data.categories = Bridgetown::Utils.pluralized_array_from_hash(
+          data, :category, :categories
+        )
+        data.tags = Bridgetown::Utils.pluralized_array_from_hash(
+          data, :tag, :tags
+        )
+      end
+
+      def import_taxonomies_from_data
+        taxonomies.each do |_label, metadata|
+          Array(data[metadata.type.key]).each do |term|
+            metadata.terms << TaxonomyTerm.new(
+              resource: self, label: term, type: metadata.type
+            )
+          end
+        end
+      end
+
+      def format_url(url)
+        url.to_s.sub(%r{index\.html?$}, "").sub(%r{\.html?$}, "")
+      end
+    end
+  end
+end