bridgetown-core 0.19.3 → 0.21.0.beta4

data/lib/bridgetown-core/component.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class Component
+    extend Forwardable
+
+    def_delegators :@view_context, :helpers, :liquid_render, :partial
+
+    # @return [Bridgetown::Site]
+    attr_reader :site # will be nil unless you explicitly set a `@site` ivar
+
+    # @return [Bridgetown::RubyTemplateView, Bridgetown::Component]
+    attr_reader :view_context
+
+    class << self
+      attr_accessor :source_location
+
+      def inherited(child)
+        # Code cribbed from ViewComponent by GitHub:
+        # Derive the source location of the component Ruby file from the call stack
+        child.source_location = caller_locations(1, 10).reject do |l|
+          l.label == "inherited"
+        end[0].absolute_path
+
+        super
+      end
+
+      # Return the appropriate template renderer for a given extension.
+      # TODO: make this extensible
+      #
+      # @param ext [String] erb, slim, etc.
+      def renderer_for_ext(ext, &block)
+        @_tmpl ||= case ext
+                   when "erb"
+                     include ERBCapture
+                     Tilt::ErubiTemplate.new(component_template_path,
+                                             outvar: "@_erbout",
+                                             bufval: "Bridgetown::OutputBuffer.new",
+                                             engine_class: Bridgetown::ERBEngine,
+                                             &block)
+                   when "serb" # requires serbea
+                     include Serbea::Helpers
+                     Tilt::SerbeaTemplate.new(component_template_path, &block)
+                   when "slim" # requires bridgetown-slim
+                     Slim::Template.new(component_template_path, &block)
+                   when "haml" # requires bridgetown-haml
+                     Tilt::HamlTemplate.new(component_template_path, &block)
+                   else
+                     raise NameError
+                   end
+      rescue NameError, LoadError
+        raise "No component rendering engine could be found for .#{ext} templates"
+      end
+
+      # Find the first matching template path based on source location and extension.
+      #
+      # @return [String]
+      def component_template_path
+        @_tmpl_path ||= begin
+          stripped_path = File.join(
+            File.dirname(source_location),
+            File.basename(source_location, ".*")
+          )
+          supported_template_extensions.each do |ext|
+            test_path = "#{stripped_path}.#{ext}"
+            break test_path if File.exist?(test_path)
+
+            test_path = "#{stripped_path}.html.#{ext}"
+            break test_path if File.exist?(test_path)
+          end
+        end
+
+        unless @_tmpl_path.is_a?(String)
+          raise "#{name}: no matching template could be found in #{File.dirname(source_location)}"
+        end
+
+        @_tmpl_path
+      end
+
+      # Read the template file.
+      #
+      # @return [String]
+      def component_template_content
+        @_tmpl_content ||= File.read(component_template_path)
+      end
+
+      # A list of extensions supported by the renderer
+      # TODO: make this extensible
+      #
+      # @return [Array<String>]
+      def supported_template_extensions
+        %w(erb serb slim haml)
+      end
+    end
+
+    # If a content block was originally passed into via `render`, capture its output.
+    #
+    # @return [String] or nil
+    def content
+      @_content ||= begin
+        view_context.capture(self, &@_content_block) if @_content_block
+      end
+    end
+
+    # Provide a render helper for evaluation within the component context.
+    #
+    # @param item [Object] a component supporting `render_in` or a partial name
+    # @param options [Hash] passed to the `partial` helper if needed
+    # @return [String]
+    def render(item, options = {}, &block)
+      if item.respond_to?(:render_in)
+        result = ""
+        capture do # this ensures no leaky interactions between BT<=>VC blocks
+          result = item.render_in(self, &block)
+        end
+        result&.html_safe
+      else
+        partial(item, options, &block)&.html_safe
+      end
+    end
+
+    # This is where the magic happens. Render the component within a view context.
+    #
+    # @param view_context [Bridgetown::RubyTemplateView]
+    def render_in(view_context, &block)
+      @view_context = view_context
+      @_content_block = block
+
+      if render?
+        before_render
+        template
+      else
+        ""
+      end
+    rescue StandardError => e
+      Bridgetown.logger.error "Component error:",
+                              "#{self.class} encountered an error while "\
+                              "rendering `#{self.class.component_template_path}'"
+      raise e
+    end
+
+    # Subclasses can override this method to return a string from their own
+    # template handling.
+    def template
+      call || _renderer.render(self)
+    end
+
+    # Typically not used but here as a compatibility nod toward ViewComponent.
+    def call
+      nil
+    end
+
+    # Subclasses can override this method to perform tasks before a render.
+    def before_render; end
+
+    # Subclasses can override this method to determine if the component should
+    # be rendered based on initialized data or other logic.
+    def render?
+      true
+    end
+
+    def _renderer
+      @_renderer ||= begin
+        ext = File.extname(self.class.component_template_path).delete_prefix(".")
+        self.class.renderer_for_ext(ext) { self.class.component_template_content }
+      end
+    end
+
+    # rubocop:disable Style/MissingRespondToMissing
+    ruby2_keywords def method_missing(method, *args, &block)
+      if helpers.respond_to?(method.to_sym)
+        helpers.send method.to_sym, *args, &block
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      helpers.respond_to?(method.to_sym, include_private) || super
+    end
+    # rubocop:enable Style/MissingRespondToMissing
+  end
+end

data/lib/bridgetown-core/concerns/data_accessible.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Bridgetown
+  # TODO: to be retired once the Resource engine is made official
   module DataAccessible
     # Returns the contents as a String.
     def to_s

data/lib/bridgetown-core/concerns/front_matter_importer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module FrontMatterImporter
+    # Requires klass#content and klass#front_matter_line_count accessors
+    def self.included(klass)
+      klass.include Bridgetown::Utils::RubyFrontMatterDSL
+    end
+
+    YAML_HEADER = %r!\A---\s*\n!.freeze
+    YAML_BLOCK = %r!\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)!m.freeze
+    RUBY_HEADER = %r!\A[~`#\-]{3,}(?:ruby|<%|{%)\s*\n!.freeze
+    RUBY_BLOCK =
+      %r!#{RUBY_HEADER.source}(.*?\n?)^((?:%>|%})?[~`#\-]{3,}\s*$\n?)!m.freeze
+
+    def read_front_matter(file_path) # rubocop:todo Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+      file_contents = File.read(
+        file_path, **Bridgetown::Utils.merged_file_read_opts(Bridgetown::Current.site, {})
+      )
+      yaml_content = file_contents.match(YAML_BLOCK)
+      if !yaml_content && Bridgetown::Current.site.config.should_execute_inline_ruby?
+        ruby_content = file_contents.match(RUBY_BLOCK)
+      end
+
+      if yaml_content
+        self.content = yaml_content.post_match
+        self.front_matter_line_count = yaml_content[1].lines.size - 1
+        YAMLParser.load(yaml_content[1])
+      elsif ruby_content
+        # rbfm header + content underneath
+        self.content = ruby_content.post_match
+        self.front_matter_line_count = ruby_content[1].lines.size
+        process_ruby_data(ruby_content[1], file_path, 2)
+      elsif Bridgetown::Utils.has_rbfm_header?(file_path)
+        process_ruby_data(File.read(file_path).lines[1..-1].join("\n"), file_path, 2)
+      elsif is_a?(Layout)
+        self.content = file_contents
+        {}
+      else
+        yaml_data = YAMLParser.load_file(file_path)
+        yaml_data.is_a?(Array) ? { rows: yaml_data } : yaml_data
+      end
+    end
+
+    def process_ruby_data(rubycode, file_path, starting_line)
+      ruby_data = instance_eval(rubycode, file_path.to_s, starting_line)
+      ruby_data.is_a?(Array) ? { rows: ruby_data } : ruby_data.to_h
+    rescue StandardError => e
+      raise "Ruby code isn't returning an array, or object which responds to `to_h' (#{e.message})"
+    end
+  end
+end

data/lib/bridgetown-core/concerns/layout_placeable.rb

@@ -11,7 +11,7 @@ module Bridgetown
     end
 
     def no_layout?
-      data["layout"] == "none" || data["layout"] == false
+      data.layout.nil? || data.layout == "none" || data.layout == false
     end
   end
 end

data/lib/bridgetown-core/concerns/site/configurable.rb

@@ -18,23 +18,22 @@ class Bridgetown::Site
       @root_dir        = File.expand_path(config["root_dir"]).freeze
       @source          = File.expand_path(config["source"]).freeze
       @dest            = File.expand_path(config["destination"]).freeze
-      @cache_dir       = in_root_dir(config["cache_dir"]).freeze
-
-      %w(lsi highlighter baseurl exclude include future unpublished
-         limit_posts keep_files).each do |opt|
-        send("#{opt}=", config[opt])
-      end
 
       configure_cache
       configure_component_paths
       configure_include_paths
       configure_file_read_opts
 
-      self.permalink_style = config["permalink"].to_sym
+      self.baseurl = config.baseurl
+      self.permalink_style = (config["permalink"] || "pretty").to_sym
 
       @config
     end
 
+    def uses_resource?
+      config[:content_engine] == "resource"
+    end
+
     def defaults_reader
       @defaults_reader ||= Bridgetown::DefaultsReader.new(self)
     end
@@ -78,7 +77,7 @@ class Bridgetown::Site
     # @return [Array<String>] Return an array of updated paths if multiple paths given.
     def in_root_dir(*paths)
       paths.reduce(root_dir) do |base, path|
-        Bridgetown.sanitized_path(base, path)
+        Bridgetown.sanitized_path(base, path.to_s)
       end
     end
 
@@ -91,7 +90,7 @@ class Bridgetown::Site
     # @return [Array<String>] Return an array of updated paths if multiple paths given.
     def in_source_dir(*paths)
       paths.reduce(source) do |base, path|
-        Bridgetown.sanitized_path(base, path)
+        Bridgetown.sanitized_path(base, path.to_s)
       end
     end
 
@@ -149,7 +148,8 @@ class Bridgetown::Site
 
     # Disable Marshaling cache to disk in Safe Mode
     def configure_cache
-      Bridgetown::Cache.cache_dir = in_root_dir(config["cache_dir"], "Bridgetown/Cache")
+      @cache_dir = in_root_dir(config["cache_dir"]).freeze
+      Bridgetown::Cache.cache_dir = File.join(cache_dir, "Bridgetown/Cache")
       Bridgetown::Cache.disable_disk_cache! if config["disable_disk_cache"]
     end
 

data/lib/bridgetown-core/concerns/site/content.rb

@@ -32,6 +32,18 @@ class Bridgetown::Site
       end
     end
 
+    def resources_grouped_by_taxonomy(taxonomy)
+      @post_attr_hash[taxonomy.label] ||= begin
+        taxonomy.terms.transform_values { |terms| terms.map(&:resource).sort.reverse }
+      end
+    end
+
+    def taxonomies
+      taxonomy_types.transform_values do |taxonomy|
+        resources_grouped_by_taxonomy(taxonomy)
+      end
+    end
+
     # Returns a hash of "tags" using {#post_attr_hash} where each tag is a key
     #  and each value is a post which contains the key.
     # @example
@@ -41,7 +53,7 @@ class Bridgetown::Site
     # @return [Hash{String, Array<Post>}] Returns a hash of all tags and their corresponding posts
     # @see post_attr_hash
     def tags
-      post_attr_hash("tags")
+      uses_resource? ? taxonomies.tag : post_attr_hash("tags")
     end
 
     # Returns a hash of "categories" using {#post_attr_hash} where each tag is
@@ -54,7 +66,7 @@ class Bridgetown::Site
     #   their corresponding posts
     # @see post_attr_hash
     def categories
-      post_attr_hash("categories")
+      uses_resource? ? taxonomies.category : post_attr_hash("categories")
     end
 
     # Returns the value of `data["site_metadata"]` or creates a new instance of
@@ -121,19 +133,25 @@ class Bridgetown::Site
     # An array of collection names.
     # @return [Array<String>] an array of collection names from the configuration,
     #   or an empty array if the `config["collections"]` key is not set.
-    # @raise ArgumentError Raise an error if `config["collections"]` is not
-    #   an Array or a Hash
     def collection_names
-      case config["collections"]
-      when Hash
-        config["collections"].keys
-      when Array
-        config["collections"]
-      when nil
-        []
-      else
-        raise ArgumentError, "Your `collections` key must be a hash or an array."
-      end
+      Array(config.collections&.keys)
+    end
+
+    # @return [Array<Bridgetown::Resource::TaxonomyType>]
+    def taxonomy_types
+      @taxonomy_types ||= config.taxonomies.map do |label, key_or_metadata|
+        key = key_or_metadata
+        tax_metadata = if key_or_metadata.is_a? Hash
+                         key = key_or_metadata["key"]
+                         key_or_metadata.reject { |k| k == "key" }
+                       else
+                         HashWithDotAccess::Hash.new
+                       end
+
+        [label, Bridgetown::Resource::TaxonomyType.new(
+          site: self, label: label, key: key, metadata: tax_metadata
+        ),]
+      end.to_h.with_dot_access
     end
 
     # Get all documents.
@@ -155,11 +173,28 @@ class Bridgetown::Site
       documents.select(&:write?)
     end
 
-    # Get all posts.
+    # Get all loaded resources.
+    # @return [Array<Bridgetown::Resource::Base>] an array of resources
+    def resources
+      collections.each_with_object(Set.new) do |(_, collection), set|
+        set.merge(collection.resources)
+      end.to_a
+    end
+
+    def resources_to_write
+      resources.select(&:write?)
+    end
+
+    # Get all posts. Deprecated, to be removed in v1.0.
     #
     # @return [Collection] Returns {#collections}`["posts"]`, creating it if need be
     # @see Collection
     def posts
+      unless @wrote_deprecation_msg
+        Bridgetown::Deprecator.deprecation_message "Call site.collections.posts " \
+                                                   "instead of site.posts (Ruby code)"
+      end
+      @wrote_deprecation_msg ||= true
       collections["posts"] ||= Bridgetown::Collection.new(self, "posts")
     end
 
@@ -177,7 +212,13 @@ class Bridgetown::Site
     #
     # @return [Array]
     def contents
+      return resources if uses_resource?
+
       pages + documents
     end
+
+    def add_generated_page(generated_page)
+      generated_pages << generated_page
+    end
   end
 end

data/lib/bridgetown-core/concerns/site/localizable.rb

@@ -5,13 +5,11 @@ class Bridgetown::Site
     # Returns the current and/or default configured locale
     # @return String
     def locale
-      if @locale
-        @locale
-      else
-        @locale = ENV.fetch("BRIDGETOWN_LOCALE", config[:default_locale]).to_sym
+      @locale ||= begin
+        locale = ENV.fetch("BRIDGETOWN_LOCALE", config[:default_locale]).to_sym
         I18n.load_path << Dir[in_source_dir("_locales") + "/*.yml"]
         I18n.available_locales = config[:available_locales]
-        I18n.default_locale = @locale
+        I18n.default_locale = locale
       end
     end