bridgetown-core 0.18.6 → 0.20.0

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

@@ -0,0 +1,275 @@
+# 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
+
+      # @!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]
+      # @param origin [Bridgetown::Resource::Origin]
+      def initialize(model:)
+        @model = model
+        @site = model.site
+        self.data = HashWithDotAccess::Hash.new
+
+        trigger_hooks(:post_init)
+      end
+
+      # @return [Bridgetown::Collection]
+      def collection
+        model.collection
+      end
+
+      # @return [Pathname]
+      def relative_path
+        model.origin.relative_path
+      end
+
+      # @return [Bridgetown::Resource::Transformer]
+      def transformer
+        @transformer ||= Bridgetown::Resource::Transformer.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
+          determine_slug_and_date
+          normalize_categories_and_tags
+          import_taxonomies_from_data
+        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
+
+      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
+
+      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
+
+      def path
+        (model.origin.respond_to?(:original_path) ? model.origin.original_path : relative_path).to_s
+      end
+
+      def absolute_url
+        format_url destination&.absolute_url
+      end
+
+      def relative_url
+        format_url destination&.relative_url
+      end
+      alias_method :id, :relative_url
+
+      def date
+        data["date"] ||= site.time # TODO: this doesn't reflect documented behavior
+      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::DocumentDrop] represents this resource's data.
+      def to_liquid
+        @to_liquid ||= Drops::ResourceDrop.new(self)
+      end
+
+      def inspect
+        "#<#{self.class} [#{collection.label}] #{relative_path}>"
+      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.docs.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
+
+        new_date, slug = Regexp.last_match.captures
+        modify_date(new_date)
+
+        slug.gsub!(%r!\.*\z!, "")
+        data.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
+      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

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class Destination
+      # @return [Bridgetown::Resource::Base]
+      attr_accessor :resource
+
+      # @return [String]
+      attr_accessor :output_ext
+
+      # @param resource [Bridgetown::Resource::Base]
+      def initialize(resource)
+        @resource = resource
+        @output_ext = resource.transformer.final_ext
+      end
+
+      def absolute_url
+        Addressable::URI.parse(
+          resource.site.config.url.to_s + relative_url
+        ).normalize.to_s
+      end
+
+      def relative_url
+        @processor ||= PermalinkProcessor.new(resource)
+        @processor.transform
+      end
+
+      def final_ext
+        output_ext || resource.extname
+      end
+
+      def output_path
+        path = URL.unescape_path(relative_url)
+        path = path.delete_prefix(resource.site.baseurl) if resource.site.baseurl.present?
+        path = resource.site.in_dest_dir(path)
+        path = File.join(path, "index.html") if relative_url.end_with? "/"
+        path
+      end
+
+      def write(output)
+        path = output_path
+        FileUtils.mkdir_p(File.dirname(path))
+        Bridgetown.logger.debug "Writing:", path
+        File.write(path, output, mode: "wb")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class PermalinkProcessor
+      # @return [Bridgetown::Resource::Base]
+      attr_accessor :resource
+
+      attr_accessor :slugify_mode
+
+      def self.placeholder_processors
+        @placeholder_processors || {}
+      end
+
+      def self.register_placeholder(key, block)
+        @placeholder_processors ||= {}
+        @placeholder_processors[key] = block
+      end
+
+      def initialize(resource)
+        @resource = resource
+        @slugify_mode = @resource.site.config.slugify_mode
+      end
+
+      def final_ext
+        resource.method(:destination).arity == 1 ? resource.extname : resource.destination.final_ext
+      end
+
+      def transform
+        permalink = resource.data.permalink ||
+          permalink_for_permalink_style(resource.collection.default_permalink)
+
+        # 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("/")
+        new_url = url_segments.map do |segment|
+          segment.starts_with?(":") ? process_segment(segment.sub(%r{^:}, "")) : segment
+        end.select(&:present?).join("/")
+
+        # No relative URLs should ever end in /index.html
+        new_url.sub!(%r{/index$}, "") if final_ext == ".html"
+
+        add_baseurl finalize_permalink(new_url, permalink)
+      end
+
+      def process_segment(segment)
+        segment = segment.to_sym
+        if self.class.placeholder_processors[segment]
+          segment_value = self.class.placeholder_processors[segment].(resource)
+          if segment_value.is_a?(Hash)
+            segment_value[:raw_value]
+          elsif segment_value.is_a?(Array)
+            segment_value.map do |subsegment|
+              Utils.slugify(subsegment, mode: slugify_mode)
+            end.join("/")
+          else
+            Utils.slugify(segment_value, mode: slugify_mode)
+          end
+        else
+          segment
+        end
+      end
+
+      def permalink_for_permalink_style(permalink_style)
+        collection_prefix = ("/:collection" unless resource.collection.builtin?)
+
+        case permalink_style.to_sym
+        when :pretty
+          "#{collection_prefix}/:categories/:year/:month/:day/:slug/"
+        when :pretty_ext, :date
+          "#{collection_prefix}/:categories/:year/:month/:day/:slug.*"
+        when :simple
+          "#{collection_prefix}/:categories/:slug/"
+        when :simple_ext
+          "#{collection_prefix}/:categories/:slug.*"
+        else
+          permalink_style.to_s
+        end
+      end
+
+      # @param new_url [String]
+      # @param permalink [String]
+      def finalize_permalink(new_url, permalink)
+        # Handle .* style permalinks or files not ending in .html
+        if permalink.ends_with?(".*") || !%r{\.html?$}.match?(final_ext)
+          "/#{new_url}#{final_ext}"
+        # If permalink includes the file extension, add it back in to the URL
+        elsif permalink =~ %r{\.[^/]*$}
+          "/#{new_url}#{Regexp.last_match[0]}"
+        # Ensure index-style URLs get output correctly
+        elsif permalink.ends_with?("/")
+          "/#{new_url}/".sub(%r{^/index/$}, "/")
+        # We good :)
+        else
+          "/#{new_url}"
+        end
+      end
+
+      def add_baseurl(permalink)
+        resource.site.baseurl.present? ? "#{resource.site.baseurl}#{permalink}" : permalink
+      end
+
+      ### Default Placeholders Processors
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :path, ->(resource) do
+        { raw_value: resource.relative_path_basename_without_prefix }
+      end
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :name, ->(resource) do
+        resource.basename_without_ext
+      end
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :slug, ->(resource) do
+        resource.data.slug || placeholder_processors[:name].(resource)
+      end
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :title, ->(resource) do
+        resource.data.title || placeholder_processors[:slug].(resource)
+      end
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :locale, ->(resource) do
+        locale_data = resource.data.locale
+        resource.site.config.available_locales.include?(locale_data) ? locale_data : nil
+      end
+      register_placeholder :lang, placeholder_processors[:locale]
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :collection, ->(resource) do
+        resource.collection.label
+      end
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :categories, ->(resource) do
+        resource.taxonomies.category&.terms&.map(&:label)&.uniq
+      end
+
+      # YYYY
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :year, ->(resource) do
+        resource.date.strftime("%Y")
+      end
+
+      # MM: 01..12
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :month, ->(resource) do
+        resource.date.strftime("%m")
+      end
+
+      # DD: 01..31
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :day, ->(resource) do
+        resource.date.strftime("%d")
+      end
+
+      # D: 1..31
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :i_day, ->(resource) do
+        resource.date.strftime("%-d")
+      end
+
+      # M: 1..12
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :i_month, ->(resource) do
+        resource.date.strftime("%-m")
+      end
+
+      # YY: 00..99
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :short_year, ->(resource) do
+        resource.date.strftime("%y")
+      end
+    end
+  end
+end