bridgetown-core 0.19.1 → 0.21.0.beta2

data/lib/bridgetown-core/helpers.rb

@@ -4,8 +4,13 @@ module Bridgetown
   class RubyTemplateView
     class Helpers
       include Bridgetown::Filters
+      include Bridgetown::Filters::FromLiquid
 
-      attr_reader :view, :site
+      # @return [Bridgetown::RubyTemplateView]
+      attr_reader :view
+
+      # @return [Bridgetown::Site]
+      attr_reader :site
 
       Context = Struct.new(:registers)
 
@@ -28,20 +33,44 @@ module Bridgetown
         pairs.select { |_key, truthy| truthy }.keys.join(" ")
       end
 
+      # Convert a Markdown string into HTML output.
+      #
+      # @param input [String] the Markdown to convert, if no block is passed
+      # @return [String]
+      def markdownify(input = nil, &block)
+        content = Bridgetown::Utils.reindent_for_markdown(
+          block.nil? ? input.to_s : view.capture(&block)
+        )
+        converter = site.find_converter_instance(Bridgetown::Converters::Markdown)
+        safe(converter.convert(content).strip)
+      end
+
       # This helper will generate the correct permalink URL for the file path.
       #
       # @param relative_path [String, Object] source file path, e.g.
-      #   "_posts/2020-10-20-my-post.md", or object that responds to `url`
+      #   "_posts/2020-10-20-my-post.md", or object that responds to either
+      #   `url` or `relative_url`
       # @return [String] the permalink URL for the file
-      # @raise [ArgumentError] if the file cannot be found
       def url_for(relative_path)
-        path_string = !relative_path.is_a?(String) ? relative_path.url : relative_path
+        if relative_path.respond_to?(:relative_url)
+          return safe(relative_path.relative_url) # new resource engine
+        elsif relative_path.respond_to?(:url)
+          return safe(relative_url(relative_path.url)) # old legacy engine
+        elsif relative_path.start_with?("/", "http")
+          return safe(relative_path)
+        end
 
-        return path_string if path_string.start_with?("/", "http")
+        find_relative_url_for_path(relative_path)
+      end
+      alias_method :link, :url_for
 
+      # @param relative_path [String] source file path, e.g.
+      #   "_posts/2020-10-20-my-post.md"
+      # @raise [ArgumentError] if the file cannot be found
+      def find_relative_url_for_path(relative_path)
         site.each_site_file do |item|
-          if item.relative_path == path_string || item.relative_path == "/#{path_string}"
-            return relative_url(item)
+          if item.relative_path == relative_path || item.relative_path == "/#{relative_path}"
+            return safe(item.respond_to?(:relative_url) ? item.relative_url : relative_url(item))
           end
         end
 
@@ -51,7 +80,6 @@ module Bridgetown
           Make sure the document exists and the path is correct.
         MSG
       end
-      alias_method :link, :url_for
 
       # This helper will generate the correct permalink URL for the file path.
       #
@@ -69,7 +97,8 @@ module Bridgetown
           attr = attr.to_s.tr("_", "-")
           segments << "#{attr}=\"#{Utils.xml_escape(option)}\""
         end
-        "<#{segments.join(" ")}>#{text}</a>"
+        # TODO: this might leak an XSS string into text, need to check
+        safe("<#{segments.join(" ")}>#{text}</a>")
       end
 
       # Forward all arguments to I18n.t method
@@ -79,6 +108,16 @@ module Bridgetown
       def t(*args)
         I18n.send :t, *args
       end
+
+      # For template contexts where ActiveSupport's output safety is loaded, we
+      # can ensure a string has been marked safe
+      #
+      # @param input [Object]
+      # @return [String]
+      def safe(input)
+        input.to_s.html_safe
+      end
+      alias_method :raw, :safe
     end
   end
 end

data/lib/bridgetown-core/layout.rb

@@ -3,8 +3,8 @@
 module Bridgetown
   class Layout
     include DataAccessible
+    include FrontMatterImporter
     include LiquidRenderable
-    include Validatable
 
     # Gets the Site object.
     attr_reader :site
@@ -21,12 +21,18 @@ 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
 
     # Gets/Sets the content of this layout.
+    # @return [String]
     attr_accessor :content
 
+    # @return [Integer]
+    attr_accessor :front_matter_line_count
+
     # Gets/Sets the current document (for layout-compatible converters)
     attr_accessor :current_document
 
@@ -52,11 +58,29 @@ module Bridgetown
         @path = site.in_source_dir(base, name)
       end
       @relative_path = @path.sub(@base_dir, "")
+      @ext = File.extname(name)
+
+      @data = read_front_matter(@path)&.with_dot_access
+    rescue SyntaxError => e
+      Bridgetown.logger.error "Error:",
+                              "Ruby Exception in #{e.message}"
+    rescue StandardError => e
+      handle_read_error(e)
+    ensure
+      @data ||= HashWithDotAccess::Hash.new
+    end
 
-      self.data = {}
+    def handle_read_error(error)
+      if error.is_a? Psych::SyntaxError
+        Bridgetown.logger.warn "YAML Exception reading #{@path}: #{error.message}"
+      else
+        Bridgetown.logger.warn "Error reading file #{@path}: #{error.message}"
+      end
 
-      process(name)
-      read_yaml(base, name)
+      if site.config["strict_front_matter"] ||
+          error.is_a?(Bridgetown::Errors::FatalException)
+        raise error
+      end
     end
 
     # The inspect string for this document.
@@ -67,15 +91,6 @@ module Bridgetown
       "#<#{self.class} #{@path}>"
     end
 
-    # Extract information from the layout filename.
-    #
-    # name - The String filename of the layout file.
-    #
-    # Returns nothing.
-    def process(name)
-      self.ext = File.extname(name)
-    end
-
     # Provide this Layout's data to a Hash suitable for use by Liquid.
     #
     # Returns the Hash representation of this Layout.

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

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Model
+    # Abstract Superclass
+    class Origin
+      extend ActiveSupport::DescendantsTracker
+
+      # @return [String]
+      attr_accessor :id
+
+      # Override in subclass
+      def self.handle_scheme?(_scheme)
+        false
+      end
+
+      def initialize(id)
+        self.id = id
+      end
+
+      def read
+        raise "Implement #read in a subclass of Bridgetown::Model::Origin"
+      end
+
+      # @return [Pathname]
+      def relative_path
+        raise "Implement #relative_path in a subclass of Bridgetown::Model::Origin"
+      end
+
+      def exists?
+        raise "Implement #exists? in a subclass of Bridgetown::Model::Origin"
+      end
+    end
+  end
+end
+
+require "bridgetown-core/model/builder_origin"
+require "bridgetown-core/model/repo_origin"

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Model
+    class RepoOrigin < Origin
+      include Bridgetown::FrontMatterImporter
+      include Bridgetown::Utils::RubyFrontMatterDSL
+
+      YAML_FRONT_MATTER_REGEXP = %r!\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)!m.freeze
+      RUBY_FRONT_MATTER_HEADER = %r!\A[~`#\-]{3,}(?:ruby|<%|{%)\s*\n!.freeze
+      RUBY_FRONT_MATTER_REGEXP =
+        %r!#{RUBY_FRONT_MATTER_HEADER.source}(.*?\n?)^((?:%>|%})?[~`#\-]{3,}\s*$\n?)!m.freeze
+
+      # @return [String]
+      attr_accessor :content
+
+      # @return [Integer]
+      attr_accessor :front_matter_line_count
+
+      class << self
+        def handle_scheme?(scheme)
+          scheme == "repo"
+        end
+
+        def data_file_extensions
+          %w(.yaml .yml .json .csv .tsv .rb).freeze
+        end
+      end
+
+      def read
+        begin
+          @data = (in_data_collection? ? read_file_data : read_front_matter(original_path)) || {}
+        rescue SyntaxError => e
+          Bridgetown.logger.error "Error:",
+                                  "Ruby Exception in #{e.message}"
+        rescue StandardError => e
+          handle_read_error(e)
+        end
+
+        @data ||= {}
+        @data[:_id_] = id
+        @data[:_origin_] = self
+        @data[:_collection_] = collection
+        @data[:_content_] = content if content
+
+        @data
+      end
+
+      def url
+        @url = URI.parse(id)
+      end
+
+      def relative_path
+        @relative_path ||= Pathname.new(
+          Addressable::URI.unescape(url.path.delete_prefix("/"))
+        )
+      end
+
+      def collection
+        return @collection if @collection
+
+        collection_name = if url.host.ends_with?(".collection")
+                            url.host.chomp(".collection")
+                          else
+                            "pages"
+                          end
+        @collection = Bridgetown::Current.site.collections[collection_name]
+      end
+
+      def original_path
+        @original_path ||= relative_path.expand_path(Bridgetown::Current.site.source)
+      end
+
+      def exists?
+        File.exist?(original_path)
+      end
+
+      private
+
+      def in_data_collection?
+        original_path.extname.downcase.in?(self.class.data_file_extensions) &&
+          collection.data?
+      end
+
+      def read_file_data # rubocop:todo Metrics/MethodLength
+        case original_path.extname.downcase
+        when ".csv"
+          {
+            rows:
+              CSV.read(original_path,
+                       headers: true,
+                       encoding: Bridgetown::Current.site.config["encoding"]).map(&:to_hash),
+          }
+        when ".tsv"
+          {
+            rows:
+              CSV.read(original_path,
+                       col_sep: "\t",
+                       headers: true,
+                       encoding: Bridgetown::Current.site.config["encoding"]).map(&:to_hash),
+          }
+        when ".rb"
+          process_ruby_data(File.read(original_path), original_path, 1)
+        else
+          yaml_data = SafeYAML.load_file(original_path)
+          yaml_data.is_a?(Array) ? { rows: yaml_data } : yaml_data
+        end
+      end
+
+      def handle_read_error(error)
+        if error.is_a? Psych::SyntaxError
+          Bridgetown.logger.error "Error:",
+                                  "YAML Exception reading #{original_path}: #{error.message}"
+        else
+          Bridgetown.logger.error "Error:",
+                                  "could not read file #{original_path}: #{error.message}"
+        end
+
+        if Bridgetown::Current.site.config["strict_front_matter"] ||
+            error.is_a?(Bridgetown::Errors::FatalException)
+          raise error
+        end
+      end
+    end
+  end
+end