bridgetown-core 0.19.3 → 0.20.0

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class TaxonomyTerm
+      attr_reader :resource
+
+      attr_reader :label
+
+      attr_reader :type
+
+      def initialize(resource:, label:, type:)
+        @resource = resource
+        @label = label
+        @type = type
+      end
+
+      def to_liquid
+        {
+          label: label,
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class TaxonomyType
+      # @return [Bridgetown::Site]
+      attr_reader :site
+
+      # @return [String] aka `category`, `tag`, `region`, etc.
+      attr_reader :label
+
+      # @return [String] the key used in front matter
+      attr_reader :key
+
+      # @return [HashWithDotAccess::Hash] any associated metadata
+      attr_reader :metadata
+
+      # @param site [Bridgetown::Site]
+      # @param label [String]
+      # @param key [String]
+      def initialize(site:, label:, key:, metadata:)
+        @site = site
+        @label = label
+        @key = key
+        @metadata = metadata
+      end
+
+      def terms
+        site.resources.map do |resource|
+          resource.taxonomies[label].terms
+        end.flatten.group_by(&:label).with_dot_access
+      end
+
+      def inspect
+        "#<#{self.class} label=#{label}>"
+      end
+
+      def to_liquid
+        {
+          "label"    => label,
+          "key"      => key,
+          "metadata" => metadata,
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class Transformer
+      # @return [Array<Hash>]
+      attr_reader :conversions
+
+      # @return [Bridgetown::Resource::Base]
+      attr_reader :resource
+
+      # @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
+      end
+
+      # @return [String]
+      def final_ext
+        permalink_ext || output_ext
+      end
+
+      def process!
+        Bridgetown.logger.debug "Transforming:", resource.relative_path
+        resource.around_hook :render do
+          run_conversions
+          resource.place_in_layout? ? place_into_layouts : resource.output = resource.content.dup
+        end
+      end
+
+      def inspect
+        "#<#{self.class} Conversion Steps: #{conversions.length}>"
+      end
+
+      private
+
+      ### Utilities
+
+      def permalink_ext
+        resource_permalink = resource.permalink
+        if resource_permalink &&
+            !resource_permalink.end_with?("/") &&
+            !resource_permalink.end_with?(".*")
+          permalink_ext = File.extname(resource_permalink)
+          permalink_ext unless permalink_ext.empty?
+        end
+      end
+
+      # @return [Array<Bridgetown::Converter>]
+      def converters
+        @converters ||= site.matched_converters_for_convertible(resource)
+      end
+
+      # @return [String]
+      def output_ext_from_converters
+        @conversions = converters.map do |converter|
+          {
+            converter: converter,
+            output_ext: converter.output_ext(resource.extname),
+          }
+        end
+
+        conversions
+          .reverse
+          .find do |conversion|
+            conversions.length == 1 ||
+              !conversion[:converter].is_a?(Bridgetown::Converters::Identity)
+          end
+          .fetch(:output_ext)
+      end
+
+      # @return [Array<Bridgetown::Layout>]
+      def validated_layouts
+        layout = site.layouts[resource.data.layout]
+        warn_on_missing_layout layout, resource.data.layout
+
+        layout_list = Set.new([layout])
+        while layout
+          layout_name = layout.data.layout
+          layout = site.layouts[layout_name]
+          warn_on_missing_layout layout, layout_name
+
+          layout_list << layout
+        end
+
+        layout_list.to_a.compact
+      end
+
+      def warn_on_missing_layout(layout, layout_name)
+        if layout.nil? && layout_name
+          Bridgetown.logger.warn "Build Warning:", "Layout '#{layout_name}' " \
+          "requested via #{resource.relative_path} does not exist."
+        end
+      end
+
+      ### 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
+        input = resource.content.to_s
+
+        # @param content [String]
+        # @param converter [Bridgetown::Converter]
+        resource.content = converters.each_with_index.inject(input) do |content, (converter, index)|
+          output = if converter.method(:convert).arity == 1
+                     converter.convert content
+                   else
+                     converter.convert content, resource
+                   end
+          conversions[index] = {
+            type: :content,
+            converter: converter,
+            output: Bridgetown.env.production? ? nil : output,
+            output_ext: conversions[index][:output_ext],
+          }
+          output
+        rescue StandardError => e
+          Bridgetown.logger.error "Conversion error:",
+                                  "#{converter.class} encountered an error while "\
+                                  "converting `#{resource.relative_path}'"
+          raise e
+        end
+      end
+
+      def place_into_layouts
+        Bridgetown.logger.debug "Placing in Layouts:", resource.relative_path
+        output = resource.content.dup
+        validated_layouts.each do |layout|
+          output = run_layout_conversions layout, output
+        end
+        resource.output = output
+      end
+
+      def run_layout_conversions(layout, output)
+        layout_converters = site.matched_converters_for_convertible(layout)
+        layout_input = layout.content.dup
+
+        layout_converters.inject(layout_input) do |content, converter|
+          next(content) unless [2, -2].include?(converter.method(:convert).arity)
+
+          layout.current_document = resource
+          layout.current_document_output = output
+          layout_output = converter.convert content, layout
+
+          conversions << {
+            type: :layout,
+            layout: layout,
+            converter: converter,
+            output: Bridgetown.env.production? ? nil : layout_output,
+          }
+          layout_output
+        rescue StandardError => e
+          Bridgetown.logger.error "Conversion error:",
+                                  "#{converter.class} encountered an error while "\
+                                  "converting `#{resource.relative_path}'"
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/ruby_template_view.rb

@@ -41,6 +41,10 @@ module Bridgetown
       end
     end
 
+    def collections
+      site.collections
+    end
+
     def site_drop
       site.site_payload.site
     end

data/lib/bridgetown-core/site.rb

@@ -26,6 +26,10 @@ module Bridgetown
     # @return [Array<Page>]
     attr_accessor :pages
 
+    # NOTE: Eventually pages will be deprecated once the Resource content engine
+    # is default
+    alias_method :generated_pages, :pages
+
     attr_accessor :exclude, :include, :lsi, :highlighter, :permalink_style,
                   :time, :future, :unpublished, :limit_posts,
                   :keep_files, :baseurl, :data, :file_read_opts,
@@ -46,7 +50,7 @@ module Bridgetown
 
       ensure_not_in_dest
 
-      Bridgetown.sites << self
+      Bridgetown::Current.site = self
       Bridgetown::Hooks.trigger :site, :after_init, self
 
       reset   # Processable
@@ -64,5 +68,9 @@ module Bridgetown
         end
       end
     end
+
+    def inspect
+      "#<Bridgetown::Site #{metadata.inspect.delete_prefix("{").delete_suffix("}")}>"
+    end
   end
 end

data/lib/bridgetown-core/static_file.rb

@@ -4,7 +4,7 @@ module Bridgetown
   class StaticFile
     extend Forwardable
 
-    attr_reader :relative_path, :extname, :name, :data
+    attr_reader :relative_path, :extname, :name, :data, :site, :collection
 
     def_delegator :to_liquid, :to_json, :to_json
 
@@ -25,8 +25,7 @@ module Bridgetown
     # base - The String path to the <source>.
     # dir  - The String path between <source> and the file.
     # name - The String filename of the file.
-    # rubocop: disable Metrics/ParameterLists
-    def initialize(site, base, dir, name, collection = nil)
+    def initialize(site, base, dir, name, collection = nil) # rubocop:disable Metrics/ParameterLists
       @site = site
       @base = base
       @dir  = dir
@@ -34,9 +33,15 @@ module Bridgetown
       @collection = collection
       @relative_path = File.join(*[@dir, @name].compact)
       @extname = File.extname(@name)
-      @data = @site.frontmatter_defaults.all(relative_path, type)
+      @data = @site.frontmatter_defaults.all(relative_path, type).with_dot_access
+      if site.uses_resource? && !data.permalink
+        data.permalink = if collection && !collection.builtin?
+                           "/:collection/:path.*"
+                         else
+                           "/:path.*"
+                         end
+      end
     end
-    # rubocop: enable Metrics/ParameterLists
 
     # Returns source file path.
     def path
@@ -51,8 +56,11 @@ module Bridgetown
     #
     # Returns destination file path.
     def destination(dest)
-      dest = @site.in_dest_dir(dest)
-      @site.in_dest_dir(dest, Bridgetown::URL.unescape_path(url))
+      dest = site.in_dest_dir(dest)
+      dest_url = url
+      dest_url = dest_url.delete_prefix(site.baseurl) if site.uses_resource? &&
+        site.baseurl.present? && collection
+      site.in_dest_dir(dest, Bridgetown::URL.unescape_path(dest_url))
     end
 
     def destination_rel_dir
@@ -118,6 +126,15 @@ module Bridgetown
       @basename ||= File.basename(name, extname).gsub(%r!\.*\z!, "")
     end
 
+    def relative_path_basename_without_prefix
+      return_path = Pathname.new("")
+      Pathname.new(cleaned_relative_path).each_filename do |filename|
+        return_path += filename unless filename.starts_with?("_")
+      end
+
+      (return_path.dirname + return_path.basename(".*")).to_s
+    end
+
     def placeholders
       {
         collection: @collection.label,
@@ -154,15 +171,21 @@ module Bridgetown
     # be overriden in the collection's configuration in bridgetown.config.yml.
     def url
       @url ||= begin
-        base = if @collection.nil? || @collection.label == "posts"
+        newly_processed = false
+        special_posts_case = @collection&.label == "posts" &&
+          site.config.content_engine != "resource"
+        base = if @collection.nil? || special_posts_case
                  cleaned_relative_path
+               elsif site.uses_resource?
+                 newly_processed = true
+                 Bridgetown::Resource::PermalinkProcessor.new(self).transform
                else
                  Bridgetown::URL.new(
                    template: @collection.url_template,
                    placeholders: placeholders
                  )
                end.to_s.chomp("/")
-        base << extname
+        newly_processed ? base : "#{base}#{extname}"
       end
     end
 
@@ -174,7 +197,7 @@ module Bridgetown
     # Returns the front matter defaults defined for the file's URL and/or type
     # as defined in bridgetown.config.yml.
     def defaults
-      @defaults ||= @site.frontmatter_defaults.all url, type
+      @defaults ||= site.frontmatter_defaults.all url, type
     end
 
     # Returns a debug string on inspecting the static file.

data/lib/bridgetown-core/url.rb

@@ -129,6 +129,7 @@ module Bridgetown
     #
     # Returns the escaped path.
     def self.escape_path(path)
+      path = path.to_s
       return path if path.empty? || %r!^[a-zA-Z0-9./-]+$!.match?(path)
 
       # Because URI.escape doesn't escape "?", "[" and "]" by default,

data/lib/bridgetown-core/utils.rb

@@ -4,12 +4,9 @@ module Bridgetown
   module Utils
     extend self
     autoload :Ansi, "bridgetown-core/utils/ansi"
-    autoload :Exec, "bridgetown-core/utils/exec"
-    autoload :Internet, "bridgetown-core/utils/internet"
     autoload :RubyExec, "bridgetown-core/utils/ruby_exec"
     autoload :Platforms, "bridgetown-core/utils/platforms"
     autoload :ThreadEvent, "bridgetown-core/utils/thread_event"
-    autoload :WinTZ, "bridgetown-core/utils/win_tz"
 
     # Constants for use in #slugify
     SLUGIFY_MODES = %w(raw default pretty simple ascii latin).freeze
@@ -74,38 +71,32 @@ module Bridgetown
       end
     end
 
-    # Read array from the supplied hash favouring the singular key
-    # and then the plural key, and handling any nil entries.
+    # Read array from the supplied hash, merging the singular key with the
+    # plural key as needing, and handling any nil or duplicate entries.
     #
-    # hash - the hash to read from
-    # singular_key - the singular key
-    # plural_key - the plural key
-    #
-    # Returns an array
-    def pluralized_array_from_hash(hash, singular_key, plural_key)
-      array = []
-      value = value_from_singular_key(hash, singular_key)
-      value ||= value_from_plural_key(hash, plural_key)
+    # @param hsh [Hash] the hash to read from
+    # @param singular_key [Symbol] the singular key
+    # @param plural_key [Symbol] the plural key
+    # @return [Array]
+    def pluralized_array_from_hash(hsh, singular_key, plural_key)
+      array = [
+        hsh[singular_key],
+        value_from_plural_key(hsh, plural_key),
+      ]
 
-      array << value
       array.flatten!
       array.compact!
+      array.uniq!
       array
     end
 
-    def value_from_singular_key(hash, key)
-      hash[key] if hash.key?(key) || (hash.default_proc && hash[key])
-    end
-
-    def value_from_plural_key(hash, key)
-      if hash.key?(key) || (hash.default_proc && hash[key])
-        val = hash[key]
-        case val
-        when String
-          val.split
-        when Array
-          val.compact
-        end
+    def value_from_plural_key(hsh, key)
+      val = hsh[key]
+      case val
+      when String
+        val.split
+      when Array
+        val.compact
       end
     end
 
@@ -124,7 +115,7 @@ module Bridgetown
 
     # Determines whether a given file has
     #
-    # Returns true if the YAML front matter is present.
+    # @return [Boolean] if the YAML front matter is present.
     # rubocop: disable Naming/PredicateName
     def has_yaml_header?(file)
       File.open(file, "rb", &:readline).match? %r!\A---\s*\r?\n!
@@ -134,7 +125,7 @@ module Bridgetown
 
     # Determine whether the given content string contains Liquid Tags or Vaiables
     #
-    # Returns true is the string contains sequences of `{%` or `{{`
+    # @return [Boolean] if the string contains sequences of `{%` or `{{`
     def has_liquid_construct?(content)
       return false if content.nil? || content.empty?
 
@@ -207,7 +198,7 @@ module Bridgetown
       slug.gsub!(%r!^\-|\-$!i, "")
 
       slug.downcase! unless cased
-      Bridgetown.logger.warn("Warning:", "Empty `slug` generated for '#{string}'.") if slug.empty?
+
       slug
     end
 
@@ -347,7 +338,7 @@ module Bridgetown
 
     # Return an asset path based on the Webpack manifest file
     # @param site [Bridgetown::Site] The current site object
-    # @param asset_type [String] js or css
+    # @param asset_type [String] js or css, or filename in manifest
     #
     # @return [String] Returns "MISSING_WEBPACK_MANIFEST" if the manifest
     # file isnt found
@@ -363,21 +354,30 @@ module Bridgetown
       manifest = JSON.parse(File.read(manifest_file))
 
       known_assets = %w(js css)
+      asset_path = nil
       if known_assets.include?(asset_type)
         asset_path = manifest["main.#{asset_type}"]
-
         log_webpack_asset_error(asset_type) && return if asset_path.nil?
-
-        asset_path = asset_path.split("/").last
-        return [static_frontend_path(site), asset_type, asset_path].join("/")
+      else
+        asset_path = manifest.find do |item, _|
+          item.sub(%r{^../(frontend/|src/)?}, "") == asset_type
+        end&.last
       end
 
-      Bridgetown.logger.error("Unknown Webpack asset type", asset_type)
-      nil
+      if asset_path
+        static_frontend_path(site, ["js", asset_path])
+      else
+        Bridgetown.logger.error("Unknown Webpack asset type", asset_type)
+        nil
+      end
     end
 
-    def static_frontend_path(site)
-      path_parts = [site.config["baseurl"].to_s.chomp("/"), "_bridgetown/static"]
+    def static_frontend_path(site, additional_parts = [])
+      path_parts = [
+        site.config["baseurl"].to_s.gsub(%r(^/|/$), ""),
+        "_bridgetown/static",
+        *additional_parts,
+      ]
       path_parts[0] = "/#{path_parts[0]}" unless path_parts[0].empty?
       Addressable::URI.parse(path_parts.join("/")).normalize.to_s
     end