bridgetown-core 0.20.0 → 0.21.0.beta1

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

@@ -17,9 +17,18 @@ module Bridgetown
 
       def to_liquid
         {
-          label: label,
+          "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

@@ -42,6 +42,15 @@ module Bridgetown
           "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

@@ -12,18 +12,20 @@ module Bridgetown
       # @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 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
 
@@ -35,6 +37,12 @@ module Bridgetown
         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
@@ -102,12 +110,6 @@ module Bridgetown
 
       ### 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
 
@@ -125,7 +127,7 @@ module Bridgetown
             output: Bridgetown.env.production? ? nil : output,
             output_ext: conversions[index][:output_ext],
           }
-          output
+          output.html_safe
         rescue StandardError => e
           Bridgetown.logger.error "Conversion error:",
                                   "#{converter.class} encountered an error while "\

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,17 +28,10 @@ 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
 
@@ -60,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
@@ -78,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
 

data/lib/bridgetown-core/utils.rb

@@ -5,6 +5,7 @@ module Bridgetown
     extend self
     autoload :Ansi, "bridgetown-core/utils/ansi"
     autoload :RubyExec, "bridgetown-core/utils/ruby_exec"
+    autoload :RubyFrontMatterDSL, "bridgetown-core/utils/ruby_front_matter"
     autoload :Platforms, "bridgetown-core/utils/platforms"
     autoload :ThreadEvent, "bridgetown-core/utils/thread_event"
 
@@ -118,7 +119,13 @@ module Bridgetown
     # @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!
+      File.open(file, "rb", &:readline).match? Bridgetown::FrontMatterImporter::YAML_HEADER
+    rescue EOFError
+      false
+    end
+
+    def has_rbfm_header?(file)
+      File.open(file, "rb", &:readline).match? Bridgetown::FrontMatterImporter::RUBY_HEADER
     rescue EOFError
       false
     end

data/lib/bridgetown-core/utils/ruby_exec.rb

@@ -5,8 +5,8 @@ module Bridgetown
     module RubyExec
       extend self
 
-      # rubocop:disable Metrics/AbcSize
-      def search_data_for_ruby_code(convertible, renderer)
+      # TODO: Deprecate storing Ruby code in YAML, Rb, etc. and just use native Ruby Front Matter
+      def search_data_for_ruby_code(convertible, renderer) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         return if convertible.data.empty?
 
         # Iterate using `keys` here so inline Ruby script can add new data keys
@@ -14,24 +14,21 @@ module Bridgetown
         data_keys = convertible.data.keys
         data_keys.each do |k|
           v = convertible.data[k]
-          next unless v.is_a?(Rb) || v.is_a?(Hash)
+          next unless v.is_a?(Rb) || v.is_a?(Hash) || v.is_a?(Proc)
 
-          if v.is_a?(Hash)
+          if v.is_a?(Proc)
+            convertible.data[k] = convertible.instance_exec(&v)
+          elsif v.is_a?(Hash)
             v.each do |nested_k, nested_v|
               next unless nested_v.is_a?(Rb)
 
-              Bridgetown.logger.debug("Executing inline Ruby…", convertible.relative_path)
               convertible.data[k][nested_k] = run(nested_v, convertible, renderer)
-              Bridgetown.logger.debug("Inline Ruby completed!", convertible.relative_path)
             end
           else
-            Bridgetown.logger.debug("Executing inline Ruby…", convertible.relative_path)
             convertible.data[k] = run(v, convertible, renderer)
-            Bridgetown.logger.debug("Inline Ruby completed!", convertible.relative_path)
           end
         end
       end
-      # rubocop:enable Metrics/AbcSize
 
       # Sets up a new context in which to eval Ruby coming from front matter.
       #

data/lib/bridgetown-core/utils/ruby_front_matter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Utils
+    module RubyFrontMatterDSL
+      def front_matter(&block)
+        RubyFrontMatter.new.tap { |fm| fm.instance_exec(&block) }
+      end
+    end
+
+    class RubyFrontMatter
+      def initialize
+        @data = {}
+      end
+
+      def method_missing(key, value) # rubocop:disable Style/MissingRespondToMissing
+        return super if respond_to?(key)
+
+        set(key, value)
+      end
+
+      def each(&block)
+        @data.each(&block)
+      end
+
+      def get(key)
+        @data[key]
+      end
+
+      def set(key, value)
+        @data[key] = value
+      end
+
+      def to_h
+        @data
+      end
+    end
+  end
+end

data/lib/bridgetown-core/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Bridgetown
-  VERSION = "0.20.0"
-  CODE_NAME = "Healy Heights"
+  VERSION = "0.21.0.beta1"
+  CODE_NAME = "Broughton Beach"
 end

data/lib/bridgetown-core/watcher.rb

@@ -140,7 +140,7 @@ module Bridgetown
         if options[:trace]
           Bridgetown.logger.info e.backtrace.join("\n")
         else
-          Bridgetown.logger.warn "Error:", "Use the --trace option for more information."
+          Bridgetown.logger.warn "Backtrace:", "Use the --trace option for more information."
         end
       end
       Bridgetown.logger.info ""

data/lib/site_template/package.json.erb

@@ -30,8 +30,8 @@
     "postcss-loader": "^4.1.0",
     "postcss-preset-env": "^6.7.0",
     <% else %>
-    "node-sass": "^4.13.1",
-    "sass-loader": "^8.0.2",    
+    "sass": "^1.32.8",
+    "sass-loader": "^8.0.2",
     <% end %>
     "webpack": "^4.44.2",
     "webpack-cli": "^3.3.11",

data/lib/site_template/src/_posts/0000-00-00-welcome-to-bridgetown.md.erb

@@ -21,6 +21,6 @@ def print_hi(name)
 end
 print_hi('Tom')
 #=> prints 'Hi, Tom' to STDOUT.
-````
+```
 
 Check out the [Bridgetown docs](https://bridgetownrb.com/docs/) for more info on how to get the most out of Bridgetown. File all bugs/feature requests at [Bridgetown’s GitHub repo](https://github.com/bridgetownrb/bridgetown). If you have questions, you can ask them on [Bridgetown Discussions on GitHub](https://github.com/bridgetownrb/bridgetown/discussions).

data/lib/site_template/webpack.config.js.erb

@@ -72,7 +72,7 @@ module.exports = {
           },
           "postcss-loader"
         ],
-      },      
+      },
       <% else %>
       {
         test: /\.(s[ac]|c)ss$/,
@@ -87,7 +87,9 @@ module.exports = {
           {
             loader: "sass-loader",
             options: {
+              implementation: require("sass"),
               sassOptions: {
+                fiber: false,
                 includePaths: [
                   path.resolve(__dirname, "src/_components")
                 ],