bridgetown-core 0.18.6 → 0.20.0

data/lib/bridgetown-core/drops/unified_payload_drop.rb

@@ -15,6 +15,10 @@ module Bridgetown
         @site_drop ||= SiteDrop.new(@obj)
       end
 
+      def collections
+        @obj.collections
+      end
+
       private
 
       def fallback_data

data/lib/bridgetown-core/entry_filter.rb

@@ -4,12 +4,14 @@ module Bridgetown
   class EntryFilter
     attr_reader :site
     SPECIAL_LEADING_CHAR_REGEX = %r!\A#{Regexp.union([".", "_", "#", "~"])}!o.freeze
+    SPECIAL_LEADING_CHAR_NO_UNDERSCORES_REGEX = %r!\A#{Regexp.union([".", "#", "~"])}!o.freeze
 
-    def initialize(site, base_directory = nil)
+    def initialize(site, base_directory: nil, include_underscores: false)
       @site = site
       @base_directory = derive_base_directory(
         @site, base_directory.to_s.dup
       )
+      @include_underscores = include_underscores
     end
 
     def base_directory
@@ -32,8 +34,6 @@ module Bridgetown
         # Reject this entry if it is just a "dot" representation.
         #   e.g.: '.', '..', '_movies/.', 'music/..', etc
         next true if e.end_with?(".")
-        # Reject this entry if it is a symlink.
-        next true if symlink?(e)
         # Do not reject this entry if it is included.
         next false if included?(e)
 
@@ -48,8 +48,13 @@ module Bridgetown
     end
 
     def special?(entry)
-      SPECIAL_LEADING_CHAR_REGEX.match?(entry) ||
-        SPECIAL_LEADING_CHAR_REGEX.match?(File.basename(entry))
+      use_regex = if @include_underscores
+                    SPECIAL_LEADING_CHAR_NO_UNDERSCORES_REGEX
+                  else
+                    SPECIAL_LEADING_CHAR_REGEX
+                  end
+
+      use_regex.match?(entry) || use_regex.match?(File.basename(entry))
     end
 
     def backup?(entry)
@@ -67,24 +72,6 @@ module Bridgetown
       end
     end
 
-    # --
-    # TODO: this is for old Safe mode and can be removed.
-    # --
-    def symlink?(_entry)
-      false
-    end
-
-    # --
-    # NOTE: Pathutil#in_path? gets the realpath.
-    # @param [<Anything>] entry the entry you want to validate.
-    # Check if a path is outside of our given root.
-    # --
-    def symlink_outside_site_source?(entry)
-      !Pathutil.new(entry).in_path?(
-        site.in_source_dir
-      )
-    end
-
     # Check if an entry matches a specific pattern.
     # Returns true if path matches against any glob pattern, else false.
     def glob_include?(enumerator, entry)

data/lib/bridgetown-core/errors.rb

@@ -4,8 +4,6 @@ module Bridgetown
   module Errors
     FatalException = Class.new(::RuntimeError)
 
-    InvalidThemeName = Class.new(FatalException)
-
     DropMutationException       = Class.new(FatalException)
     InvalidPermalinkError       = Class.new(FatalException)
     InvalidYAMLFrontMatterError = Class.new(FatalException)

data/lib/bridgetown-core/filters.rb

@@ -63,6 +63,7 @@ module Bridgetown
     # Returns the given filename or title as a lowercase URL String.
     # See Utils.slugify for more detail.
     def slugify(input, mode = nil)
+      mode = @context.registers[:site].config.slugify_mode if mode.nil?
       Utils.slugify(input, mode: mode)
     end
 
@@ -102,7 +103,7 @@ module Bridgetown
     #
     # Returns the escaped String.
     def cgi_escape(input)
-      CGI.escape(input)
+      CGI.escape(input.to_s)
     end
 
     # URI escape a string.
@@ -126,7 +127,7 @@ module Bridgetown
     # @return [String] a link unreadable for bots but will be recovered on focus or mouseover
     def obfuscate_link(input, prefix = "mailto")
       link = "<a href=\"#{prefix}:#{input}\">#{input}</a>"
-      script = "<script type=\"text/javascript\">document.currentScript.insertAdjacentHTML("
+      script = "<script type=\"text/javascript\">document.currentScript.insertAdjacentHTML('"
       script += "beforebegin', '#{rot47(link).gsub(%r!\\!, '\\\\\\')}'.replace(/[!-~]/g,"
       script += "function(c){{var j=c.charCodeAt(0);if((j>=33)&&(j<=126)){"
       script += "return String.fromCharCode(33+((j+ 14)%94));}"
@@ -375,7 +376,7 @@ module Bridgetown
       case target
       when NilClass
         return true if property.nil?
-      when Liquid::Expression::MethodLiteral # `empty` or `blank`
+      when "" # aka `empty` or `blank`
         target = target.to_s
         return true if property == target || Array(property).join == target
       else

data/lib/bridgetown-core/generator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module Bridgetown
-  Generator = Class.new(Plugin)
+  class Generator < Plugin
+  end
 end

data/lib/bridgetown-core/generators/prototype_generator.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+# Handles Legacy Pages
 Bridgetown::Hooks.register :pages, :post_init, reloadable: false do |page|
   if page.class != Bridgetown::PrototypePage && page.data["prototype"].is_a?(Hash)
     Bridgetown::PrototypeGenerator.add_matching_template(page)
   end
 end
 
+# Handles Resources
+Bridgetown::Hooks.register :resources, :post_read, reloadable: false do |resource|
+  if resource.data["prototype"].is_a?(Hash)
+    Bridgetown::PrototypeGenerator.add_matching_template(resource)
+  end
+end
+
 module Bridgetown
   class PrototypeGenerator < Generator
     priority :low
@@ -13,27 +21,27 @@ module Bridgetown
     # @return [Bridgetown::Site]
     attr_reader :site
 
-    @matching_templates = []
-
-    def self.add_matching_template(template)
-      @matching_templates << template
+    # @return [Array<Bridgetown::Page, Bridgetown::Resource::Base>]
+    def self.matching_templates
+      @matching_templates ||= []
     end
 
-    class << self
-      # @return [Array<Page>]
-      attr_reader :matching_templates
+    def self.add_matching_template(template)
+      matching_templates << template
     end
 
+    # @param site [Bridgetown::Site]
     def generate(site)
       @site = site
-      @configured_collection = "posts"
+      @configured_collection = "posts" unless site.uses_resource?
+      page_list = site.uses_resource? ? site.collections.pages.resources : site.pages
 
       prototype_pages = self.class.matching_templates.select do |page|
-        site.pages.include? page
+        page_list.include?(page)
       end
 
       if prototype_pages.length.positive?
-        site.pages.reject! do |page|
+        page_list.reject! do |page|
           prototype_pages.include? page
         end
 
@@ -42,7 +50,7 @@ module Bridgetown
           next if search_term.nil?
 
           terms_matching_pages(search_term).each do |term|
-            generate_new_page_from_prototype(prototype_page, search_term, term).data
+            generate_new_page_from_prototype(prototype_page, search_term, term)
           end
         end
       end
@@ -50,7 +58,7 @@ module Bridgetown
 
     # Check incoming prototype configuration and normalize options.
     #
-    # @param prototype_page [PrototypePage]
+    # @param prototype_page [Bridgetown::Page, Bridgetown::Resource::Base]
     #
     # @return [String, nil]
     def validate_search_term(prototype_page)
@@ -71,7 +79,7 @@ module Bridgetown
 
     def generate_new_page_from_prototype(prototype_page, search_term, term)
       new_page = PrototypePage.new(prototype_page, @configured_collection, search_term, term)
-      site.pages << new_page
+      site.add_generated_page new_page
       new_page
     end
 
@@ -81,16 +89,26 @@ module Bridgetown
     #
     # @return [Array<String>]
     def terms_matching_pages(search_term)
+      pages_list = if site.uses_resource?
+                     site.collections[@configured_collection].resources
+                   else
+                     site.collections[@configured_collection].docs
+                   end
+
       Bridgetown::Paginate::PaginationIndexer.index_documents_by(
-        site.collections[@configured_collection].docs, search_term
+        pages_list, search_term
       ).keys
     end
   end
 
-  class PrototypePage < Page
-    # @return [Page]
+  class PrototypePage < GeneratedPage
+    # @return [Bridgetown::Page, Bridgetown::Resource::Base]
     attr_reader :prototyped_page
 
+    # @param prototyped_page [Bridgetown::Page, Bridgetown::Resource::Base]
+    # @param collection [Bridgetown::Collection]
+    # @param search_term [String]
+    # @param term [String]
     def initialize(prototyped_page, collection, search_term, term)
       @prototyped_page = prototyped_page
       @site = prototyped_page.site
@@ -107,7 +125,7 @@ module Bridgetown
       validate_data! prototyped_page.path
       validate_permalink! prototyped_page.path
 
-      @dir = Pathname.new(prototyped_page.relative_path).dirname.to_s
+      @dir = Pathname.new(prototyped_page.relative_path).dirname.to_s.sub(%r{^_pages}, "")
       @path = site.in_source_dir(@dir, @name)
 
       process_prototype_page_data(collection, search_term, term)
@@ -132,7 +150,7 @@ module Bridgetown
       slugify_term(term)
     end
 
-    # rubocop:disable Metrics/AbcSize
+    # rubocop:todo Metrics/AbcSize
     def process_title_data_placeholder(search_term, term)
       if prototyped_page.data["prototype"]["data"]
         if data["title"]&.include?(":prototype-data-label")
@@ -164,7 +182,7 @@ module Bridgetown
     end
 
     def slugify_term(term)
-      term_slug = Bridgetown::Utils.slugify(term)
+      term_slug = Bridgetown::Utils.slugify(term, mode: site.config.slugify_mode)
       @url = if permalink.is_a?(String)
                data["permalink"] = data["permalink"].sub(":term", term_slug)
              else

data/lib/bridgetown-core/layout.rb

@@ -21,6 +21,8 @@ module Bridgetown
     # Gets/Sets the extension of this layout.
     attr_accessor :ext
 
+    alias_method :extname, :ext
+
     # Gets/Sets the Hash that holds the metadata for this layout.
     attr_accessor :data
 
@@ -53,8 +55,6 @@ module Bridgetown
       end
       @relative_path = @path.sub(@base_dir, "")
 
-      self.data = {}
-
       process(name)
       read_yaml(base, name)
     end

data/lib/bridgetown-core/liquid_renderer/file.rb

@@ -2,6 +2,7 @@
 
 module Bridgetown
   class LiquidRenderer
+    # TODO: deprecate or move to a separate repo/plugin
     class File
       def initialize(renderer, filename)
         @renderer = renderer

data/lib/bridgetown-core/liquid_renderer/table.rb

@@ -2,6 +2,7 @@
 
 module Bridgetown
   class LiquidRenderer
+    # TODO: deprecate or move to a separate repo/plugin
     class Table
       GAUGES = [:count, :bytes, :time].freeze
 

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module Bridgetown
+  module Model
+    class Base
+      include ActiveModel::Model
+      extend ActiveModel::Callbacks # also extends with DescendantsTracker
+      define_model_callbacks :load, :save, :destroy
+
+      def self.loads_id?(id)
+        name == ActiveSupport::Inflector.classify(
+          URI.parse(id).host.chomp(".collection")
+        )
+      end
+
+      def self.find(id)
+        unless Bridgetown::Current.site
+          raise "A Bridgetown site must be initialized and added to Current"
+        end
+
+        model_klass = klass_for_id(id)
+        model_klass.new(read_data_for_id(id))
+      end
+
+      def self.klass_for_id(id)
+        descendants.find do |klass|
+          klass.loads_id?(id)
+        end || self
+      end
+
+      def self.read_data_for_id(id)
+        origin_for_id(id).read
+      end
+
+      def self.origin_for_id(id)
+        scheme = URI.parse(id).scheme
+        origin_klass = Origin.descendants.find do |klass|
+          klass.handle_scheme?(scheme)
+        end
+
+        raise "No origin could be found for #{id}" unless origin_klass
+
+        origin_klass.new(id)
+      end
+
+      class << self
+        def build(collection_name, path, data)
+          data = Bridgetown::Model::BuilderOrigin.new("builder://#{path}").read do
+            data[:_collection_] = Bridgetown::Current.site.collections[collection_name]
+            data
+          end
+          new(data)
+        end
+      end
+
+      def initialize(attributes = {})
+        run_callbacks :load do
+          super
+        end
+      end
+
+      def id
+        attributes[:id] || attributes[:_id_]
+      end
+
+      # @return [Bridgetown::Model::Origin]
+      def origin
+        attributes[:_origin_]
+      end
+
+      def persisted?
+        id && origin.exists?
+      end
+
+      # @return [Bridgetown::Resource::Base]
+      def to_resource
+        Bridgetown::Resource::Base.new(model: self)
+      end
+
+      def as_resource_in_collection
+        collection.resources << to_resource.read!
+        collection.resources.last
+      end
+
+      # override if need be
+      # @return [Bridgetown::Site]
+      def site
+        Bridgetown::Current.site
+      end
+
+      # @return [Bridgetown::Collection]
+      def collection
+        attributes[:_collection_]
+      end
+
+      # @return [String]
+      def content
+        attributes[:_content_]
+      end
+
+      def attributes
+        @attributes ||= HashWithDotAccess::Hash.new
+      end
+
+      # Strip out keys like _origin_, _collection_, etc.
+      # @return [HashWithDotAccess::Hash]
+      def data_attributes
+        attributes.reject { |k| k.starts_with?("_") && k.ends_with?("_") }
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        attributes.key?(method_name) || method_name.to_s.end_with?("=") || super
+      end
+
+      def method_missing(method_name, *args) # rubocop:disable Style/MethodMissingSuper
+        return attributes[method_name] if attributes.key?(method_name)
+
+        key = method_name.to_s
+        if key.end_with?("=")
+          key.chop!
+          # attribute_will_change!(key)
+          attributes[key] = args.first
+          return attributes[key]
+        end
+
+        Bridgetown.logger.warn "key `#{method_name}' not found in attributes for" \
+                               " #{attributes[:id].presence || ("new " + self.class.to_s)}"
+        nil
+      end
+
+      def inspect
+        "#<#{self.class} #{data_attributes.inspect.delete_prefix("{").delete_suffix("}")}>"
+      end
+    end
+  end
+end

data/lib/bridgetown-core/model/builder_origin.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Model
+    # Abstract Superclass
+    class BuilderOrigin < Origin
+      # @return [Pathname]
+      attr_reader :relative_path
+
+      # Override in subclass
+      def self.handle_scheme?(scheme)
+        scheme == "builder"
+      end
+
+      def initialize(id)
+        self.id = id
+        @relative_path = Pathname.new(id.delete_prefix("builder://"))
+      end
+
+      def read
+        @data = if block_given?
+                  yield
+                elsif defined?(SiteBuilder) && SiteBuilder.respond_to?(:data_for_id)
+                  SiteBuilder.data_for_id(id)
+                else
+                  raise "No builder exists which can read #{id}"
+                end
+        @data[:_id_] = id
+        @data[:_origin_] = self
+        @relative_path = Pathname.new(@data[:_relative_path_]) if @data[:_relative_path_]
+
+        @data
+      end
+
+      def exists?
+        false
+      end
+    end
+  end
+end