bridgetown-core 0.20.0 → 0.21.0

data/lib/bridgetown-core/renderer.rb

@@ -52,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

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

@@ -23,13 +23,6 @@ module Bridgetown
       # @return [String]
       attr_accessor :content, :untransformed_content, :output
 
-      # @!attribute [r] collection
-      #   @return [Bridgetown::Collection] collection of this resource
-
-      # @!attribute [r] relative_path
-      #   @return [Pathname] the relative path of source file or
-      #     file-like origin
-
       DATE_FILENAME_MATCHER = %r!^(?>.+/)*?(\d{2,4}-\d{1,2}-\d{1,2})-([^/]*)(\.[^.]+)$!.freeze
 
       # @param site [Bridgetown::Site]
@@ -42,11 +35,31 @@ module Bridgetown
         trigger_hooks(:post_init)
       end
 
+      # Collection associated with this resource
+      #
       # @return [Bridgetown::Collection]
       def collection
         model.collection
       end
 
+      # Layout associated with this resource
+      # This will output a warning if the layout can't be found.
+      #
+      # @return [Bridgetown::Layout]
+      def layout
+        return @layout if @layout
+        return if no_layout?
+
+        @layout = site.layouts[data.layout].tap do |layout|
+          unless layout
+            Bridgetown.logger.warn "Resource:", "Layout '#{data.layout}' " \
+            "requested via #{relative_path} does not exist."
+          end
+        end
+      end
+
+      # The relative path of source file or file-like origin
+      #
       # @return [Pathname]
       def relative_path
         model.origin.relative_path
@@ -57,6 +70,11 @@ module Bridgetown
         @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)
@@ -80,9 +98,11 @@ module Bridgetown
 
         unless collection.data?
           self.untransformed_content = content
-          determine_slug_and_date
           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?
@@ -108,6 +128,7 @@ module Bridgetown
         trigger_hooks :"post_#{hook_suffix}"
       end
 
+      # @return [String]
       def relative_path_basename_without_prefix
         return_path = Pathname.new("")
         relative_path.each_filename do |filename|
@@ -121,6 +142,7 @@ module Bridgetown
         (return_path.dirname + return_path.basename(".*")).to_s
       end
 
+      # @return [String]
       def basename_without_ext
         relative_path.basename(".*").to_s
       end
@@ -135,21 +157,28 @@ module Bridgetown
         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
-      alias_method :id, :relative_url
+
+      # @return [String]
+      def id
+        model.origin.id
+      end
 
       def date
-        data["date"] ||= site.time # TODO: this doesn't reflect documented behavior
+        data["date"] ||= site.time
       end
 
       # @return [Hash<String, Hash<String => Bridgetown::Resource::TaxonomyType,
@@ -189,13 +218,36 @@ module Bridgetown
 
       # Create a Liquid-understandable version of this resource.
       #
-      # @return [Drops::DocumentDrop] represents this resource's data.
+      # @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} [#{collection.label}] #{relative_path}>"
+        "#<#{self.class} #{id}>"
       end
 
       # Compare this document against another document.
@@ -222,30 +274,32 @@ module Bridgetown
       alias_method :next_doc, :next_resource
 
       def previous_resource
-        pos = collection.docs.index { |item| item.equal?(self) }
+        pos = collection.resources.index { |item| item.equal?(self) }
         collection.resources[pos - 1] if pos&.positive?
       end
       alias_method :previous_doc, :previous_resource
 
       private
 
-      def determine_slug_and_date
-        return unless relative_path.to_s =~ DATE_FILENAME_MATCHER
+      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
 
-        new_date, slug = Regexp.last_match.captures
-        modify_date(new_date)
-
-        slug.gsub!(%r!\.*\z!, "")
         data.slug ||= slug
+        data.title ||= Bridgetown::Utils.titleize_slug(slug)
       end
 
-      def modify_date(new_date)
-        if !data.date || data.date.to_i == site.time.to_i
-          data.date = Utils.parse_date(
-            new_date,
-            "Document '#{relative_path}' does not have a valid date in the #{model}."
-          )
-        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/lib/bridgetown-core/resource/permalink_processor.rb

@@ -32,7 +32,7 @@ module Bridgetown
 
         # Strip out file extension and process each segment of a URL to swap out
         # placeholders such as :categories or :title
-        url_segments = permalink.sub(%r{\.[^/]*$}, "").split("/")
+        url_segments = Bridgetown::Filters::URLFilters.strip_extname(permalink).split("/")
         new_url = url_segments.map do |segment|
           segment.starts_with?(":") ? process_segment(segment.sub(%r{^:}, "")) : segment
         end.select(&:present?).join("/")

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class Relations
+      # @return [Bridgetown::Resource::Base]
+      attr_reader :resource
+
+      # @return [Bridgetown::Site]
+      attr_reader :site
+
+      # @param resource [Bridgetown::Resource::Base]
+      def initialize(resource)
+        @resource = resource
+        @site = resource.site
+      end
+
+      # @return [HashWithDotAccess::Hash]
+      def relation_schema
+        resource.collection.metadata.relations
+      end
+
+      # @return [Array<String>]
+      def relation_types
+        @relation_types ||= begin
+          types = []
+          relation_schema&.each do |_relation_type, collections|
+            types << collections
+            types << Array(collections).map { |item| ActiveSupport::Inflector.pluralize(item) }
+          end
+          types.flatten.uniq
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Resource::Base, Array<Bridgetown::Resource::Base>]
+      def resources_for_type(type)
+        relation_kind = kind_of_relation_for_type(type)
+        return [] unless relation_kind
+
+        case relation_kind.to_sym
+        when :belongs_to
+          belongs_to_relation_for_type(type)
+        when :has_many
+          has_many_relation_for_type(type)
+        when :has_one
+          has_one_relation_for_type(type)
+        end
+      end
+
+      def method_missing(type, *args)
+        return super unless type.to_s.in?(relation_types)
+
+        resources_for_type(type)
+      end
+
+      def respond_to_missing?(type, *_args)
+        type.to_s.in?(relation_types)
+      end
+
+      def to_liquid
+        @to_liquid ||= Drops::RelationsDrop.new(self)
+      end
+
+      private
+
+      # @param type [Symbol]
+      # @return [String]
+      def kind_of_relation_for_type(type)
+        relation_schema&.each do |relation_type, collections|
+          collections = Array(collections).yield_self do |collections_arr|
+            collections_arr +
+              collections_arr.map { |item| ActiveSupport::Inflector.pluralize(item) }
+          end.flatten.uniq
+          return relation_type if collections.include?(type.to_s)
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Collection]
+      def other_collection_for_type(type)
+        site.collections[type] || site.collections[ActiveSupport::Inflector.pluralize(type)]
+      end
+
+      # @return [Array<String>]
+      def collection_labels
+        [
+          resource.collection.label,
+          ActiveSupport::Inflector.singularize(resource.collection.label),
+        ]
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Resource::Base, Array<Bridgetown::Resource::Base>]
+      def belongs_to_relation_for_type(type)
+        if resource.data[type].is_a?(Array)
+          other_collection_for_type(type).resources.select do |other_resource|
+            other_resource.data.slug.in?(resource.data[type])
+          end
+        else
+          other_collection_for_type(type).resources.find do |other_resource|
+            other_resource.data.slug == resource.data[type]
+          end
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Array<Bridgetown::Resource::Base>]
+      def has_many_relation_for_type(type) # rubocop:disable Naming/PredicateName
+        label, singular_label = collection_labels
+
+        other_collection_for_type(type).resources.select do |other_resource|
+          resource.data.slug.in?(
+            Array(other_resource.data[label] || other_resource.data[singular_label])
+          )
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Resource::Base]
+      def has_one_relation_for_type(type) # rubocop:disable Naming/PredicateName
+        label, singular_label = collection_labels
+
+        other_collection_for_type(type).resources.find do |other_resource|
+          resource.data.slug.in?(
+            Array(other_resource.data[label] || other_resource.data[singular_label])
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -17,9 +17,18 @@ module Bridgetown
 
       def to_liquid
         {
-          label: label,
+          "label" => label,
         }
       end
+      alias_method :to_h, :to_liquid
+
+      def as_json(*)
+        to_h
+      end
+
+      ruby2_keywords def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
     end
   end
 end

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

@@ -42,6 +42,15 @@ module Bridgetown
           "metadata" => metadata,
         }
       end
+      alias_method :to_h, :to_liquid
+
+      def as_json(*)
+        to_h
+      end
+
+      ruby2_keywords def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
     end
   end
 end

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

@@ -12,18 +12,21 @@ module Bridgetown
       # @return [Bridgetown::Site]
       attr_reader :site
 
-      # @return [String]
-      attr_reader :output_ext
-
       def initialize(resource)
         @resource = resource
         @site = resource.site
-        execute_inline_ruby
-        @output_ext = output_ext_from_converters
+        @conversions = []
+      end
+
+      # @return [String]
+      def output_ext
+        @output_ext ||= output_ext_from_converters
       end
 
       # @return [String]
       def final_ext
+        output_ext # we always need this to get run
+
         permalink_ext || output_ext
       end
 
@@ -35,6 +38,12 @@ module Bridgetown
         end
       end
 
+      def execute_inline_ruby!
+        return unless site.config.should_execute_inline_ruby?
+
+        Bridgetown::Utils::RubyExec.search_data_for_ruby_code(resource, self)
+      end
+
       def inspect
         "#<#{self.class} Conversion Steps: #{conversions.length}>"
       end
@@ -102,13 +111,7 @@ module Bridgetown
 
       ### Transformation Actions
 
-      def execute_inline_ruby
-        return unless site.config.should_execute_inline_ruby?
-
-        Bridgetown::Utils::RubyExec.search_data_for_ruby_code(resource, self)
-      end
-
-      def run_conversions # rubocop:disable Metrics/AbcSize
+      def run_conversions # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         input = resource.content.to_s
 
         # @param content [String]
@@ -123,9 +126,10 @@ module Bridgetown
             type: :content,
             converter: converter,
             output: Bridgetown.env.production? ? nil : output,
-            output_ext: conversions[index][:output_ext],
+            output_ext: conversions[index]&.dig(:output_ext) ||
+              converter.output_ext(resource.extname),
           }
-          output
+          output.html_safe
         rescue StandardError => e
           Bridgetown.logger.error "Conversion error:",
                                   "#{converter.class} encountered an error while "\