bridgetown-core 1.0.0.alpha8 → 1.0.0.beta1

data/lib/bridgetown-core/configurations/turbo/turbo_transitions.js

@@ -0,0 +1,48 @@
+document.addEventListener("turbo:visit", () => {
+  let main = document.querySelector("main");
+  if (main.dataset.turboTransition == "false") return;
+
+  let [movement, scale] = ["15px", "0.99"];
+
+  if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) {
+    [movement, scale] = ["7px", "1"]
+  };
+
+  main.style.transformOrigin = "50% 0%";
+  main.dataset.animatingOut = true;
+
+  main.animate(
+    [
+      { opacity: 1, transform: "translateY(0px) scale(1)" },
+      { opacity: 0, transform: `translateY(${movement}) scale(${scale})` }
+    ],
+    { duration: 300, easing: "cubic-bezier(0.45, 0, 0.55, 1)" }
+  );
+
+  Promise.all(main.getAnimations().map(animation => animation.finished)).then(() => {
+    if (main.dataset.animatingOut) main.style.visibility = "hidden"
+  })
+});
+
+document.addEventListener("turbo:load", () => {
+  let main = document.querySelector("main");
+  if (main.dataset.turboTransition == "false") return;
+
+  let [movement, scale] = ["-10px", "0.99"];
+
+  if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) {
+    [movement, scale] = ["-5px", "1"]
+  };
+
+  main.style.visibility = "visible";
+  main.style.transformOrigin = "50% 0%";
+  delete main.dataset.animatingOut;
+
+  main.animate(
+    [
+      { opacity: 0, transform: `translateY(${movement}) scale(${scale})` },
+      { opacity: 1, transform: "translateY(0px) scale(1)" }
+    ],
+    { duration: 150, easing: "cubic-bezier(0.45, 0, 0.55, 1)" }
+  )
+})

data/lib/bridgetown-core/configurations/turbo.rb

@@ -1,16 +1,26 @@
 # frozen_string_literal: true
 
-say "Installing Turbo...", :green
+say_status :turbo, "Installing Turbo..."
 
 run("yarn add @hotwired/turbo")
 
-say 'Adding Turbo to "frontend/javascript/index.js"...', :magenta
+say_status :turbo, 'Adding Turbo to "frontend/javascript/index.js"...', :magenta
 
 javascript_import do
   <<~JS
-    import Turbo from "@hotwired/turbo"
+    import * as Turbo from "@hotwired/turbo"
+
+    // Uncomment the line below to add transition animations when Turbo navigates.
+    // We recommend adding <meta name="turbo-cache-control" content="no-preview" />
+    // to your HTML head if you turn on transitions. Use data-turbo-transition="false"
+    // on your <main> element for pages where you don't want any transition animation.
+    //
+    // import "./turbo_transitions.js"
   JS
 end
 
-say "Turbo successfully added", :green
-say 'For further reading, check out "https://turbo.hotwired.dev/"', :blue
+copy_file in_templates_dir("turbo_transitions.js"), "frontend/javascript/turbo_transitions.js"
+
+say_status :turbo, "Turbo successfully added!", :magenta
+say_status :turbo, "Take a look in your index.js file for optional animation setup.", :blue
+say_status :turbo, 'For further reading, check out "https://turbo.hotwired.dev/"', :blue

data/lib/bridgetown-core/converters/erb_templates.rb

@@ -38,7 +38,7 @@ module Bridgetown
       return if text.empty?
 
       src << bufvar << ".safe_append='"
-      src << text.gsub(%r{['\\]}, '\\\\\&') # rubocop:disable Style/StringLiterals
+      src << text.gsub(%r{['\\]}, '\\\\\&')
       src << "'.freeze;"
     end
 
@@ -115,7 +115,7 @@ module Bridgetown
         erb_view = Bridgetown::ERBView.new(convertible)
 
         erb_renderer = Tilt::ErubiTemplate.new(
-          convertible.relative_path,
+          convertible.path,
           line_start(convertible),
           outvar: "@_erbout",
           bufval: "Bridgetown::OutputBuffer.new",

data/lib/bridgetown-core/converters/ruby_templates.rb

@@ -9,7 +9,7 @@ module Bridgetown
       def convert(content, convertible)
         erb_view = Bridgetown::ERBView.new(convertible)
         erb_view.instance_eval(
-          content, convertible.relative_path.to_s, line_start(convertible)
+          content, convertible.path.to_s, line_start(convertible)
         ).to_s
       end
     end

data/lib/bridgetown-core/converters/serbea_templates.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "serbea"
+require "rouge/lexers/serbea"
+
+module Bridgetown
+  class SerbeaView < ERBView
+    include Serbea::Helpers
+
+    def partial(partial_name, options = {}, &block)
+      options.merge!(options[:locals]) if options[:locals]
+      options[:content] = capture(&block) if block
+
+      partial_segments = partial_name.split("/")
+      partial_segments.last.sub!(%r!^!, "_")
+      partial_name = partial_segments.join("/")
+
+      Tilt::SerbeaTemplate.new(
+        site.in_source_dir(site.config[:partials_dir], "#{partial_name}.serb")
+      ).render(self, options)
+    end
+  end
+
+  module Converters
+    class SerbeaTemplates < Converter
+      priority :highest
+      input :serb
+
+      # Logic to do the Serbea content conversion.
+      #
+      # @param content [String] Content of the file (without front matter).
+      # @param convertible [
+      #   Bridgetown::GeneratedPage, Bridgetown::Resource::Base, Bridgetown::Layout]
+      #   The instantiated object which is processing the file.
+      #
+      # @return [String] The converted content.
+      def convert(content, convertible)
+        return content if convertible.data[:template_engine].to_s != "serbea"
+
+        serb_view = Bridgetown::SerbeaView.new(convertible)
+
+        serb_renderer = Tilt::SerbeaTemplate.new(convertible.path) { content }
+
+        if convertible.is_a?(Bridgetown::Layout)
+          serb_renderer.render(serb_view) do
+            convertible.current_document_output
+          end
+        else
+          serb_renderer.render(serb_view)
+        end
+      end
+
+      def matches(ext, convertible)
+        if convertible.data[:template_engine].to_s == "serbea" ||
+            (convertible.data[:template_engine].nil? &&
+              @config[:template_engine].to_s == "serbea")
+          convertible.data[:template_engine] = "serbea"
+          return true
+        end
+
+        super(ext).tap do |ext_matches|
+          convertible.data[:template_engine] = "serbea" if ext_matches
+        end
+      end
+
+      def output_ext(ext)
+        ext == ".serb" ? ".html" : ext
+      end
+    end
+  end
+end

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

@@ -110,7 +110,7 @@ module Bridgetown
       # underlying data hashes and performs a set union to ensure a list
       # of unique keys for the Drop.
       #
-      # Returns an Array of unique keys for content for the Drop.
+      # @return [Array<String>]
       def keys
         (content_methods |
           mutations.keys |

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

@@ -6,7 +6,7 @@ module Bridgetown
       extend Forwardable
 
       NESTED_OBJECT_FIELD_BLACKLIST = %w(
-        content output excerpt next previous
+        content output excerpt next previous next_resource previous_resource
       ).freeze
 
       mutable false
@@ -44,13 +44,15 @@ module Bridgetown
         cmp
       end
 
-      def previous
-        @previous ||= @obj.previous_resource.to_liquid
+      def next_resource
+        @next ||= @obj.next_resource.to_liquid
       end
+      alias_method :next, :next_resource
 
-      def next
-        @next ||= @obj.next_resource.to_liquid
+      def previous_resource
+        @previous ||= @obj.previous_resource.to_liquid
       end
+      alias_method :previous, :previous_resource
 
       # Generate a Hash for use in generating JSON.
       # This is useful if fields need to be cleared before the JSON can generate.
@@ -79,6 +81,27 @@ module Bridgetown
           result[key] = doc[key] unless NESTED_OBJECT_FIELD_BLACKLIST.include?(key)
         end
       end
+
+      # Generates a list of keys with user content as their values.
+      # This gathers up the Drop methods and keys of the mutations and
+      # underlying data hashes and performs a set union to ensure a list
+      # of unique keys for the Drop.
+      #
+      # @return [Array<String>]
+      def keys
+        keys_to_remove = %w[next_resource previous_resource]
+        (content_methods |
+          mutations.keys |
+          fallback_data.keys).flatten.reject do |key|
+          keys_to_remove.include?(key)
+        end
+      end
+
+      # Inspect the drop's keys and values through a JSON representation
+      # of its keys and values.
+      def inspect
+        JSON.pretty_generate hash_for_json
+      end
     end
   end
 end

data/lib/bridgetown-core/errors.rb

@@ -14,5 +14,26 @@ module Bridgetown
     PostURLError                = Class.new(FatalException)
     InvalidURLError             = Class.new(FatalException)
     InvalidConfigurationError   = Class.new(FatalException)
+
+    def self.print_build_error(exc, trace: false)
+      Bridgetown.logger.error "Exception raised:", exc.class.to_s.bold
+      Bridgetown.logger.error exc.message.reset_ansi
+
+      trace_args = ["-t", "--trace"]
+      print_trace_msg = true
+      traces = if trace || ARGV.find { |arg| trace_args.include?(arg) }
+                 print_trace_msg = false
+                 exc.backtrace
+               else
+                 exc.backtrace[0..4]
+               end
+      traces.each_with_index do |backtrace_line, index|
+        Bridgetown.logger.error "#{index + 1}:", backtrace_line.reset_ansi
+      end
+
+      return unless print_trace_msg
+
+      Bridgetown.logger.warn "Backtrace:", "Use the --trace option for complete information."
+    end
   end
 end

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

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
 # Handles Generated Pages
-Bridgetown::Hooks.register :generated_pages, :post_init, reloadable: false do |page|
+Bridgetown::Hooks.register_one :generated_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|
+Bridgetown::Hooks.register_one :resources, :post_read, reloadable: false do |resource|
   if resource.data["prototype"].is_a?(Hash)
     Bridgetown::PrototypeGenerator.add_matching_template(resource)
   end
 end
 
 # Ensure sites clear out templates before rebuild
-Bridgetown::Hooks.register :site, :after_reset, reloadable: false do |_site|
+Bridgetown::Hooks.register_one :site, :after_reset, reloadable: false do |_site|
   Bridgetown::PrototypeGenerator.matching_templates.clear
 end
 

data/lib/bridgetown-core/helpers.rb

@@ -22,9 +22,10 @@ module Bridgetown
         @context = Context.new({ site: site })
       end
 
-      def webpack_path(asset_type)
-        Bridgetown::Utils.parse_webpack_manifest_file(site, asset_type.to_s)
+      def asset_path(asset_type)
+        Bridgetown::Utils.parse_frontend_manifest_file(site, asset_type.to_s)
       end
+      alias_method :webpack_path, :asset_path
 
       def live_reload_dev_js
         Bridgetown::Utils.live_reload_js(site)

data/lib/bridgetown-core/hooks.rb

@@ -17,34 +17,59 @@ module Bridgetown
 
     DEFAULT_PRIORITY = 20
 
-    # compatibility layer for octopress-hooks users
     PRIORITY_MAP = {
       low: 10,
       normal: 20,
       high: 30,
     }.freeze
 
-    # initial empty hooks
     @registry = {}
 
     NotAvailable = Class.new(RuntimeError)
     Uncallable = Class.new(RuntimeError)
 
-    # Ensure the priority is a Fixnum
     def self.priority_value(priority)
       return priority if priority.is_a?(Integer)
 
       PRIORITY_MAP[priority] || DEFAULT_PRIORITY
     end
 
-    # register hook(s) to be called later
+    # Sort registered hooks according to priority and load order
+    #
+    # @param hooks [Array<HookRegistration>]
+    def self.prioritized_hooks(hooks)
+      grouped_hooks = hooks.group_by(&:priority)
+      grouped_hooks.keys.sort.reverse.map { |priority| grouped_hooks[priority] }.flatten
+    end
+
+    # Register one or more hooks which may be triggered later for a particular event
+    #
+    # @param owners [Symbol, Array<Symbol>] name of the owner (`:site`, `:resource`, etc.)
+    # @param event [Symbol] name of the event (`:pre_read`, `:post_render`, etc.)
+    # @param priority [Integer, Symbol] either `:low`, `:normal`, or `:high`, or an integer.
+    #   Default is normal (20)
+    # @param reloadable [Boolean] whether the hook should be removed prior to a site reload.
+    #   Default is true.
+    # @yield the block will be called when the event is triggered. Typically it receives at
+    #   least one argument.
+    # @yieldparam obj the object which triggered the event hook
     def self.register(owners, event, priority: DEFAULT_PRIORITY, reloadable: true, &block)
       Array(owners).each do |owner|
         register_one(owner, event, priority: priority, reloadable: reloadable, &block)
       end
     end
 
-    # register a single hook to be called later
+    # Register a hook which may be triggered later for a particular event
+    #
+    # @param owner [Symbol] name of the owner (`:site`, `:resource`, etc.)
+    # @param event [Symbol] name of the event (`:pre_read`, `:post_render`, etc.)
+    # @param priority [Integer, Symbol] either `:low`, `:normal`, or `:high`, or an integer.
+    #   Default is normal (20)
+    # @param reloadable [Boolean] whether the hook should be removed prior to a site reload.
+    #   Default is true.
+    # @yield the block will be called when the event is triggered. Typically it receives at
+    #   least one argument.
+    # @yieldparam obj the object which triggered the event hook
     def self.register_one(owner, event, priority: DEFAULT_PRIORITY, reloadable: true, &block)
       @registry[owner] ||= []
 
@@ -68,10 +93,28 @@ module Bridgetown
       block
     end
 
-    def self.remove_hook(owner, _event, block)
+    # Delete a previously-registered hook
+    #
+    # @param owners [Symbol] name of the owner (`:site`, `:resource`, etc.)
+    # @param block [Proc] the exact block used originally to register the hook
+    def self.remove_hook(owner, block)
       @registry[owner].delete_if { |item| item.block == block }
     end
 
+    # Clear all hooks marked as reloadable from the registry
+    def self.clear_reloadable_hooks
+      Bridgetown.logger.debug("Clearing reloadable hooks")
+
+      @registry.each_value do |hooks|
+        hooks.delete_if(&:reloadable)
+      end
+    end
+
+    # Trigger all registered hooks for a particular owner and event.
+    # Any arguments after the initial two will be directly passed along to the hooks.
+    #
+    # @param owner [Symbol] name of the owner (`:site`, `:resource`, etc.)
+    # @param event [Symbol] name of the event (`:pre_read`, `:post_render`, etc.)
     def self.trigger(owner, event, *args) # rubocop:disable Metrics/CyclomaticComplexity
       # proceed only if there are hooks to call
       hooks = @registry[owner]&.select { |item| item.event == event }
@@ -79,25 +122,13 @@ module Bridgetown
 
       prioritized_hooks(hooks).each do |hook|
         if ENV["BRIDGETOWN_LOG_LEVEL"] == "debug"
-          hook_info = args[0].respond_to?(:url) ? args[0].relative_path : hook.block
+          hook_info = args[0].respond_to?(:relative_path) ? args[0].relative_path : hook.block
           Bridgetown.logger.debug("Triggering hook:", "#{owner}:#{event} for #{hook_info}")
         end
         hook.block.call(*args)
       end
-    end
-
-    def self.prioritized_hooks(hooks)
-      # sort hooks according to priority and load order
-      grouped_hooks = hooks.group_by(&:priority)
-      grouped_hooks.keys.sort.reverse.map { |priority| grouped_hooks[priority] }.flatten
-    end
 
-    def self.clear_reloadable_hooks
-      Bridgetown.logger.debug("Clearing reloadable hooks")
-
-      @registry.each_value do |hooks|
-        hooks.delete_if(&:reloadable)
-      end
+      true
     end
   end
 end

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

@@ -31,9 +31,7 @@ module Bridgetown
         raise Liquid::FileSystemError, "No such template '#{template_path}'" if found_paths.empty?
 
         # Last path in the list wins
-        LiquidComponent.parse(
-          ::File.read(found_paths.last, **site.file_read_opts)
-        ).content
+        ::File.read(found_paths.last, **site.file_read_opts)
       end
     end
   end

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

@@ -69,8 +69,23 @@ module Bridgetown
         attributes[:_origin_]
       end
 
+      def origin=(new_origin)
+        attributes[:_id_] = new_origin.id
+        attributes[:_origin_] = new_origin
+      end
+
       def persisted?
-        id && origin.exists?
+        (id && origin&.exists?) == true
+      end
+
+      def save
+        unless origin.respond_to?(:write)
+          raise "`#{origin.class}' doesn't allow writing of model objects"
+        end
+
+        run_callbacks :save do
+          origin.write(self)
+        end
       end
 
       # @return [Bridgetown::Resource::Base]
@@ -100,11 +115,19 @@ module Bridgetown
         attributes[:_collection_]
       end
 
+      def collection=(new_collection)
+        attributes[:_collection_] = new_collection
+      end
+
       # @return [String]
       def content
         attributes[:_content_]
       end
 
+      def content=(new_content)
+        attributes[:_content_] = new_content
+      end
+
       def attributes
         @attributes ||= HashWithDotAccess::Hash.new
       end

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

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-# See bottom of file for specific origin requires...
-
 module Bridgetown
   module Model
     # Abstract Superclass
     class Origin
       extend ActiveSupport::DescendantsTracker
 
+      EAGER_LOAD_DESCENDANTS = %i(BuilderOrigin RepoOrigin PluginOrigin).freeze
+
       # @return [String]
       attr_accessor :id
 
@@ -42,9 +42,7 @@ module Bridgetown
         raise "Implement #exists? in a subclass of Bridgetown::Model::Origin"
       end
     end
+
+    Origin::EAGER_LOAD_DESCENDANTS.each { const_get _1 }
   end
 end
-
-require "bridgetown-core/model/builder_origin"
-require "bridgetown-core/model/repo_origin"
-require "bridgetown-core/model/plugin_origin"

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

@@ -25,6 +25,18 @@ module Bridgetown
         def data_file_extensions
           %w(.yaml .yml .json .csv .tsv .rb).freeze
         end
+
+        # Initializes a new repo object using a collection and a relative source path.
+        # You'll need to use this when you want to create and save a model to the source.
+        #
+        # @param collection [Bridgetown::Collection, String, Symbol] either a collection
+        #   label or Collection object
+        # @param relative_path [Pathname, String] the source path of the file to save
+        def new_with_collection_path(collection, relative_path)
+          collection = collection.label if collection.is_a?(Bridgetown::Collection)
+
+          new("repo://#{collection}.collection/#{relative_path}")
+        end
       end
 
       def read
@@ -46,6 +58,23 @@ module Bridgetown
         @data
       end
 
+      def write(model)
+        if File.exist?(original_path) && !Bridgetown::Utils.has_yaml_header?(original_path)
+          raise Bridgetown::Errors::InvalidYAMLFrontMatterError,
+                "Only existing files containing YAML front matter can be overwritten by the model"
+        end
+
+        contents = "#{front_matter_to_yaml(model)}---\n\n#{model.content}"
+
+        # Create folders if necessary
+        dir = File.dirname(original_path)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+        File.write(original_path, contents)
+
+        true
+      end
+
       def url
         @url ||= URI.parse(id)
       end
@@ -121,6 +150,25 @@ module Bridgetown
           raise error
         end
       end
+
+      def front_matter_to_yaml(model)
+        data = model.data_attributes.to_h
+        data = data.deep_merge(data) do |_, _, v|
+          case v
+          when DateTime
+            v.to_time
+          when Symbol
+            v.to_s
+          else
+            v
+          end
+        end
+        data.each do |k, v|
+          data.delete(k) if v.nil?
+        end
+
+        data.to_yaml
+      end
     end
   end
 end

data/lib/bridgetown-core/rack/boot.rb

@@ -51,15 +51,11 @@ module Bridgetown
         loader.do_not_eager_load(File.join(server_folder, "roda_app.rb"))
 
         unless ENV["BRIDGETOWN_ENV"] == "production"
-          begin
-            Listen.to(server_folder) do |_modified, _added, _removed|
-              loader.reload
-              loader.eager_load
-              Bridgetown::Rack::Routes.reload_subclasses
-            end.start
-          # interrupt isn't handled well by the listener
-          rescue ThreadError # rubocop:disable Lint/SuppressedException
-          end
+          Listen.to(server_folder) do |_modified, _added, _removed|
+            loader.reload
+            loader.eager_load
+            Bridgetown::Rack::Routes.reload_subclasses
+          end.start
         end
       end
 

data/lib/bridgetown-core/rack/roda.rb

@@ -23,6 +23,7 @@ module Bridgetown
       plugin :json
       plugin :json_parser
       plugin :cookies
+      plugin :streaming
       plugin :public, root: Bridgetown::Current.preloaded_configuration.destination
       plugin :not_found do
         output_folder = Bridgetown::Current.preloaded_configuration.destination
@@ -39,7 +40,7 @@ module Bridgetown
         "500 Internal Server Error"
       end
 
-      def _roda_run_main_route(r) # rubocop:disable Naming/MethodParameterName
+      before do
         if self.class.opts[:bridgetown_site]
           # The site had previously been initialized via the bridgetown_ssr plugin
           Bridgetown::Current.site ||= self.class.opts[:bridgetown_site]
@@ -47,14 +48,12 @@ module Bridgetown
         Bridgetown::Current.preloaded_configuration ||=
           self.class.opts[:bridgetown_preloaded_config]
 
-        r.public
+        request.public
 
-        r.root do
+        request.root do
           output_folder = Bridgetown::Current.preloaded_configuration.destination
           File.read(File.join(output_folder, "index.html"))
         end
-
-        super
       end
 
       # Helper shorthand for Bridgetown::Current.site