bridgetown-core 0.19.3 → 0.21.0.beta4

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class Relations
+      # @return [Bridgetown::Resource::Base]
+      attr_reader :resource
+
+      # @return [Bridgetown::Site]
+      attr_reader :site
+
+      # @param resource [Bridgetown::Resource::Base]
+      def initialize(resource)
+        @resource = resource
+        @site = resource.site
+      end
+
+      # @return [HashWithDotAccess::Hash]
+      def relation_schema
+        resource.collection.metadata.relations
+      end
+
+      # @return [Array<String>]
+      def relation_types
+        @relation_types ||= begin
+          types = []
+          relation_schema&.each do |_relation_type, collections|
+            types << collections
+            types << Array(collections).map { |item| ActiveSupport::Inflector.pluralize(item) }
+          end
+          types.flatten.uniq
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Resource::Base, Array<Bridgetown::Resource::Base>]
+      def resources_for_type(type)
+        relation_kind = kind_of_relation_for_type(type)
+        return [] unless relation_kind
+
+        case relation_kind.to_sym
+        when :belongs_to
+          belongs_to_relation_for_type(type)
+        when :has_many
+          has_many_relation_for_type(type)
+        when :has_one
+          has_one_relation_for_type(type)
+        end
+      end
+
+      def method_missing(type, *args)
+        return super unless type.to_s.in?(relation_types)
+
+        resources_for_type(type)
+      end
+
+      def respond_to_missing?(type, *_args)
+        type.to_s.in?(relation_types)
+      end
+
+      def to_liquid
+        @to_liquid ||= Drops::RelationsDrop.new(self)
+      end
+
+      private
+
+      # @param type [Symbol]
+      # @return [String]
+      def kind_of_relation_for_type(type)
+        relation_schema&.each do |relation_type, collections|
+          collections = Array(collections).yield_self do |collections_arr|
+            collections_arr +
+              collections_arr.map { |item| ActiveSupport::Inflector.pluralize(item) }
+          end.flatten.uniq
+          return relation_type if collections.include?(type.to_s)
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Collection]
+      def other_collection_for_type(type)
+        site.collections[type] || site.collections[ActiveSupport::Inflector.pluralize(type)]
+      end
+
+      # @return [Array<String>]
+      def collection_labels
+        [
+          resource.collection.label,
+          ActiveSupport::Inflector.singularize(resource.collection.label),
+        ]
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Resource::Base, Array<Bridgetown::Resource::Base>]
+      def belongs_to_relation_for_type(type)
+        if resource.data[type].is_a?(Array)
+          other_collection_for_type(type).resources.select do |other_resource|
+            other_resource.data.slug.in?(resource.data[type])
+          end
+        else
+          other_collection_for_type(type).resources.find do |other_resource|
+            other_resource.data.slug == resource.data[type]
+          end
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Array<Bridgetown::Resource::Base>]
+      def has_many_relation_for_type(type) # rubocop:disable Naming/PredicateName
+        label, singular_label = collection_labels
+
+        other_collection_for_type(type).resources.select do |other_resource|
+          resource.data.slug.in?(
+            Array(other_resource.data[label] || other_resource.data[singular_label])
+          )
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Resource::Base]
+      def has_one_relation_for_type(type) # rubocop:disable Naming/PredicateName
+        label, singular_label = collection_labels
+
+        other_collection_for_type(type).resources.find do |other_resource|
+          resource.data.slug.in?(
+            Array(other_resource.data[label] || other_resource.data[singular_label])
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# 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
+      alias_method :to_h, :to_liquid
+
+      def as_json(*)
+        to_h
+      end
+
+      ruby2_keywords def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# 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
+      alias_method :to_h, :to_liquid
+
+      def as_json(*)
+        to_h
+      end
+
+      ruby2_keywords def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+# 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
+
+      def initialize(resource)
+        @resource = resource
+        @site = resource.site
+        @conversions = []
+      end
+
+      # @return [String]
+      def output_ext
+        @output_ext ||= output_ext_from_converters
+      end
+
+      # @return [String]
+      def final_ext
+        output_ext # we always need this to get run
+
+        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 execute_inline_ruby!
+        return unless site.config.should_execute_inline_ruby?
+
+        Bridgetown::Utils::RubyExec.search_data_for_ruby_code(resource, self)
+      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 run_conversions # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        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]&.dig(:output_ext) ||
+              converter.output_ext(resource.extname),
+          }
+          output.html_safe
+        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

@@ -7,6 +7,7 @@ module Bridgetown
     require "bridgetown-core/helpers"
 
     attr_reader :layout, :page, :paginator, :site, :content
+    alias_method :resource, :page
 
     def initialize(convertible)
       if convertible.is_a?(Layout)
@@ -27,20 +28,17 @@ module Bridgetown
 
     def render(item, options = {}, &block)
       if item.respond_to?(:render_in)
-        previous_buffer_state = @_erbout
-        @_erbout = Bridgetown::ERBBuffer.new
-
-        @in_view_component ||= defined?(::ViewComponent::Base) && item.is_a?(::ViewComponent::Base)
         result = item.render_in(self, &block)
-        @in_view_component = false
-
-        @_erbout = previous_buffer_state
-        result
+        result&.html_safe
       else
-        partial(item, options, &block)
+        partial(item, options, &block)&.html_safe
       end
     end
 
+    def collections
+      site.collections
+    end
+
     def site_drop
       site.site_payload.site
     end
@@ -56,14 +54,15 @@ module Bridgetown
         Bridgetown.logger.warn "Liquid Warning:",
                                LiquidRenderer.format_error(e, path || document.relative_path)
       end
-      template.render!(options.deep_stringify_keys, _liquid_context)
+      template.render!(options.deep_stringify_keys, _liquid_context).html_safe
     end
 
     def helpers
       @helpers ||= Helpers.new(self, site)
     end
 
-    def method_missing(method, *args, &block)
+    # 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
@@ -74,6 +73,7 @@ module Bridgetown
     def respond_to_missing?(method, include_private = false)
       helpers.respond_to?(method.to_sym, include_private) || super
     end
+    # rubocop:enable Style/MissingRespondToMissing
 
     private