bridgetown-core 0.21.4 → 1.0.0.alpha4

data/lib/bridgetown-core/site.rb

@@ -10,10 +10,11 @@ module Bridgetown
     include Localizable
     include Processable
     include Renderable
+    include SSR
     include Writable
 
     attr_reader   :root_dir, :source, :dest, :cache_dir, :config,
-                  :regenerator, :liquid_renderer, :components_load_paths,
+                  :liquid_renderer, :components_load_paths,
                   :includes_load_paths
 
     # All files not pages/documents or structured data in the source folder
@@ -23,12 +24,8 @@ module Bridgetown
     # @return [Array<Layout>]
     attr_accessor :layouts
 
-    # @return [Array<Page>]
-    attr_accessor :pages
-
-    # NOTE: Eventually pages will be deprecated once the Resource content engine
-    # is default
-    alias_method :generated_pages, :pages
+    # @return [Array<GeneratedPage>]
+    attr_accessor :generated_pages
 
     attr_accessor :permalink_style, :time, :data,
                   :file_read_opts, :plugin_manager, :converters,
@@ -44,7 +41,6 @@ module Bridgetown
       @plugin_manager  = PluginManager.new(self)
       @cleaner         = Cleaner.new(self)
       @reader          = Reader.new(self)
-      @regenerator     = Regenerator.new(self)
       @liquid_renderer = LiquidRenderer.new(self)
 
       ensure_not_in_dest

data/lib/bridgetown-core/static_file.rb

@@ -21,10 +21,11 @@ module Bridgetown
 
     # Initialize a new StaticFile.
     #
-    # site - The Site.
-    # base - The String path to the <source>.
-    # dir  - The String path between <source> and the file.
-    # name - The String filename of the file.
+    # @param site [Bridgetown::Site]
+    # @param base [String] path to the <source>.
+    # @param dir [String] path between <source> and the file.
+    # @param name [String] filename of the file.
+    # @param collection [Bridgetown::Collection] optional collection the file is attached to
     def initialize(site, base, dir, name, collection = nil) # rubocop:disable Metrics/ParameterLists
       @site = site
       @base = base
@@ -34,20 +35,16 @@ module Bridgetown
       @relative_path = File.join(*[@dir, @name].compact)
       @extname = File.extname(@name)
       @data = @site.frontmatter_defaults.all(relative_path, type).with_dot_access
-      if site.uses_resource? && !data.permalink
-        data.permalink = if collection && !collection.builtin?
-                           "/:collection/:path.*"
+      data.permalink ||= if collection && !collection.builtin?
+                           "#{collection.default_permalink.chomp("/").chomp(".*")}.*"
                          else
                            "/:path.*"
                          end
-      end
     end
 
     # Returns source file path.
     def path
-      @path ||= begin
-        File.join(*[@base, @dir, @name].compact)
-      end
+      @path ||= File.join(*[@base, @dir, @name].compact)
     end
 
     # Obtain destination path.
@@ -58,7 +55,7 @@ module Bridgetown
     def destination(dest)
       dest = site.in_dest_dir(dest)
       dest_url = url
-      if site.uses_resource? && site.base_path.present? && collection
+      if site.base_path.present? && collection
         dest_url = dest_url.delete_prefix site.base_path(strip_slash_only: true)
       end
       site.in_dest_dir(dest, Bridgetown::URL.unescape_path(dest_url))
@@ -112,6 +109,7 @@ module Bridgetown
 
       FileUtils.mkdir_p(File.dirname(dest_path))
       FileUtils.rm(dest_path) if File.exist?(dest_path)
+      Bridgetown.logger.debug "Saving file:", dest_path
       copy_file(dest_path)
 
       true
@@ -177,14 +175,9 @@ module Bridgetown
           site.config.content_engine != "resource"
         base = if @collection.nil? || special_posts_case
                  cleaned_relative_path
-               elsif site.uses_resource?
+               else
                  newly_processed = true
                  Bridgetown::Resource::PermalinkProcessor.new(self).transform
-               else
-                 Bridgetown::URL.new(
-                   template: @collection.url_template,
-                   placeholders: placeholders
-                 )
                end.to_s.chomp("/")
         newly_processed ? base : "#{base}#{extname}"
       end
@@ -212,9 +205,9 @@ module Bridgetown
     def copy_file(dest_path)
       FileUtils.copy_entry(path, dest_path)
 
-      unless File.symlink?(dest_path)
-        File.utime(self.class.mtimes[path], self.class.mtimes[path], dest_path)
-      end
+      return if File.symlink?(dest_path)
+
+      File.utime(self.class.mtimes[path], self.class.mtimes[path], dest_path)
     end
   end
 end

data/lib/bridgetown-core/tags/find.rb

@@ -11,12 +11,7 @@ module Bridgetown
 
       def initialize(tag_name, markup, tokens)
         super
-        if markup.strip =~ SYNTAX
-          @new_var_name = Regexp.last_match(1).strip
-          @single_or_group = Regexp.last_match(2)
-          @arr_name = Regexp.last_match(3).strip
-          @conditions = process_conditions(Regexp.last_match(4).strip)
-        else
+        unless markup.strip =~ SYNTAX
           raise SyntaxError, <<~MSG
             Syntax Error in tag 'find' while parsing the following markup:
 
@@ -25,6 +20,11 @@ module Bridgetown
             Valid syntax: find <varname> where|in <array>, <condition(s)>
           MSG
         end
+
+        @new_var_name = Regexp.last_match(1).strip
+        @single_or_group = Regexp.last_match(2)
+        @arr_name = Regexp.last_match(3).strip
+        @conditions = process_conditions(Regexp.last_match(4).strip)
       end
 
       def render(context)

data/lib/bridgetown-core/tags/highlight.rb

@@ -14,10 +14,7 @@ module Bridgetown
 
       def initialize(tag_name, markup, tokens)
         super
-        if markup.strip =~ SYNTAX
-          @lang = Regexp.last_match(1).downcase
-          @highlight_options = parse_options(Regexp.last_match(2))
-        else
+        unless markup.strip =~ SYNTAX
           raise SyntaxError, <<~MSG
             Syntax Error in tag 'highlight' while parsing the following markup:
 
@@ -26,6 +23,9 @@ module Bridgetown
             Valid syntax: highlight <lang> [linenos]
           MSG
         end
+
+        @lang = Regexp.last_match(1).downcase
+        @highlight_options = parse_options(Regexp.last_match(2))
       end
 
       LEADING_OR_TRAILING_LINE_TERMINATORS = %r!\A(\n|\r)+|(\n|\r)+\z!.freeze
@@ -89,7 +89,7 @@ module Bridgetown
           "data-lang=\"#{@lang}\"",
         ].join(" ")
         "<figure class=\"highlight\"><pre><code #{code_attributes}>"\
-        "#{code.chomp}</code></pre></figure>"
+          "#{code.chomp}</code></pre></figure>"
       end
     end
   end

data/lib/bridgetown-core/tags/include.rb

@@ -9,15 +9,18 @@ module Bridgetown
 
       VALID_SYNTAX = %r!
         ([\w-]+)\s*=\s*
-        (?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([\w\.-]+))
+        (?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([\w.-]+))
       !x.freeze
+
+      # rubocop:disable Lint/MixedRegexpCaptureTypes
       VARIABLE_SYNTAX = %r!
-        (?<variable>[^{]*(\{\{\s*[\w\-\.]+\s*(\|.*)?\}\}[^\s{}]*)+)
+        (?<variable>[^{]*(\{\{\s*[\w\-.]+\s*(\|.*)?\}\}[^\s{}]*)+)
         (?<params>.*)
       !mx.freeze
+      # rubocop:enable Lint/MixedRegexpCaptureTypes
 
       FULL_VALID_SYNTAX = %r!\A\s*(?:#{VALID_SYNTAX}(?=\s|\z)\s*)*\z!.freeze
-      VALID_FILENAME_CHARS = %r!^[\w/\.-]+$!.freeze
+      VALID_FILENAME_CHARS = %r!^[\w/.-]+$!.freeze
       INVALID_SEQUENCES = %r![./]{2,}!.freeze
 
       def initialize(tag_name, markup, tokens)
@@ -66,33 +69,33 @@ module Bridgetown
       end
 
       def validate_file_name(file)
-        if INVALID_SEQUENCES.match?(file) || !VALID_FILENAME_CHARS.match?(file)
-          raise ArgumentError, <<~MSG
-            Invalid syntax for include tag. File contains invalid characters or sequences:
+        return unless INVALID_SEQUENCES.match?(file) || !VALID_FILENAME_CHARS.match?(file)
 
-              #{file}
+        raise ArgumentError, <<~MSG
+          Invalid syntax for include tag. File contains invalid characters or sequences:
 
-            Valid syntax:
+            #{file}
 
-              #{syntax_example}
+          Valid syntax:
 
-          MSG
-        end
+            #{syntax_example}
+
+        MSG
       end
 
       def validate_params
-        unless FULL_VALID_SYNTAX.match?(@params)
-          raise ArgumentError, <<~MSG
-            Invalid syntax for include tag:
+        return if FULL_VALID_SYNTAX.match?(@params)
 
-            #{@params}
+        raise ArgumentError, <<~MSG
+          Invalid syntax for include tag:
 
-            Valid syntax:
+          #{@params}
 
-            #{syntax_example}
+          Valid syntax:
 
-          MSG
-        end
+          #{syntax_example}
+
+        MSG
       end
 
       # Grab file read opts in the context
@@ -119,16 +122,12 @@ module Bridgetown
       end
 
       def render(context)
-        site = context.registers[:site]
-
         file = render_variable(context) || @file
         validate_file_name(file)
 
         path = locate_include_file(context, file)
         return unless path
 
-        add_include_to_dependency(site, path, context)
-
         partial = load_cached_partial(path, context)
 
         context.stack do
@@ -143,15 +142,6 @@ module Bridgetown
         end
       end
 
-      def add_include_to_dependency(site, path, context)
-        if context.registers[:page]&.key?("path")
-          site.regenerator.add_dependency(
-            site.in_source_dir(context.registers[:page]["path"]),
-            path
-          )
-        end
-      end
-
       def load_cached_partial(path, context)
         context.registers[:cached_partials] ||= {}
         cached_partial = context.registers[:cached_partials]

data/lib/bridgetown-core/tags/link.rb

@@ -23,6 +23,10 @@ module Bridgetown
         relative_path = Liquid::Template.parse(@relative_path).render(context)
 
         site.each_site_file do |item|
+          # Resource engine:
+          if item.respond_to?(:relative_url) && item.relative_path.to_s == relative_path
+            return item.relative_url
+          end
           return relative_url(item) if item.relative_path == relative_path
           # This takes care of the case for static files that have a leading /
           return relative_url(item) if item.relative_path == "/#{relative_path}"

data/lib/bridgetown-core/tags/live_reload_dev_js.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Tags
+    class LiveReloadJsTag < Liquid::Tag
+      def render(context)
+        Bridgetown::Utils.live_reload_js(context.registers[:site])
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("live_reload_dev_js", Bridgetown::Tags::LiveReloadJsTag)

data/lib/bridgetown-core/tags/post_url.rb

@@ -29,7 +29,7 @@ module Bridgetown
       end
 
       def ==(other)
-        other.relative_path.match(@name_regex)
+        other.relative_path.to_s.match(@name_regex)
       end
 
       def deprecated_equality(other)
@@ -47,12 +47,7 @@ module Bridgetown
       #
       # Returns the post slug with the subdirectory (relative to _posts)
       def post_slug(other)
-        path = other.basename.split("/")[0...-1].join("/")
-        if path.nil? || path == ""
-          other.data["slug"]
-        else
-          path + "/" + other.data["slug"]
-        end
+        other.data.slug
       end
     end
 
@@ -77,21 +72,21 @@ module Bridgetown
         @context = context
         site = context.registers[:site]
 
-        site.collections.posts.docs.each do |document|
+        site.collections.posts.resources.each do |document|
           return relative_url(document) if @post == document
-        end
 
-        # New matching method did not match, fall back to old method
-        # with deprecation warning if this matches
-
-        site.collections.posts.docs.each do |document|
+          # New matching method did not match, fall back to old method
+          # with deprecation warning if this matches
           next unless @post.deprecated_equality document
 
-          Bridgetown::Deprecator.deprecation_message "A call to "\
+          Bridgetown::Deprecator.deprecation_message(
+            "A call to "\
             "'{% post_url #{@post.name} %}' did not match " \
             "a post using the new matching method of checking name " \
             "(path-date-slug) equality. Please make sure that you " \
             "change this tag to match the post's name exactly."
+          )
+
           return relative_url(document)
         end
 

data/lib/bridgetown-core/tags/render_content.rb

@@ -3,7 +3,7 @@
 module Bridgetown
   module Tags
     class BlockRenderTag < Liquid::Block
-      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       def render(context)
         context.stack({}) do
           # unindent the incoming text
@@ -37,7 +37,7 @@ module Bridgetown
             .render_tag(context, +"")
         end
       end
-      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
       private
 

data/lib/bridgetown-core/tasks/bridgetown_tasks.rake

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+desc "Generate a secret key for use in sessions, token generation, and beyond"
+task :secret do
+  require "securerandom"
+  puts SecureRandom.hex(64) # rubocop:disable Bridgetown/NoPutsAllowed
+end
+
+namespace :frontend do
+  desc "Run frontend bundler independently"
+  task :watcher, :sidecar do |_task, args|
+    # sidecar is when the task is running alongside the start command
+    sidecar = args[:sidecar] == true
+    Bridgetown::Utils::Aux.group do
+      run_process "Frontend", :yellow, "bundle exec bridgetown frontend:dev"
+    end
+    if sidecar
+      sleep 4 # give Webpack time to boot before returning control to the start command
+    else
+      trap("INT") do
+        Bridgetown::Utils::Aux.kill_processes
+        sleep 0.5
+        exit(0)
+      end
+      loop { sleep 1000 }
+    end
+  end
+end
+
+desc "Prerequisite task which loads site and provides automation"
+task :environment do
+  class HammerActions < Thor # rubocop:disable Lint/ConstantDefinitionInBlock
+    include Thor::Actions
+    include Bridgetown::Commands::Actions
+
+    def self.source_root
+      Dir.pwd
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+
+    private
+
+    def site
+      @site ||= Bridgetown::Site.new(Bridgetown.configuration)
+    end
+  end
+
+  define_singleton_method :automation do |*args, &block|
+    @hammer ||= HammerActions.new
+    @hammer.instance_exec(*args, &block)
+  end
+
+  define_singleton_method :site do
+    @hammer ||= HammerActions.new
+    @hammer.send(:site)
+  end
+end

data/lib/bridgetown-core/url.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Public: Methods that generate a URL for a resource such as a Post or a Page.
+# Public: Methods that generate a URL for GeneratedPage.
 #
 # Examples
 #
@@ -10,6 +10,7 @@
 #   }).to_s
 #
 module Bridgetown
+  # TODO: remove this class in favor of the new Resource permalink processor
   class URL
     # options - One of :permalink or :template must be supplied.
     #           :template     - The String used as template for URL generation,
@@ -27,9 +28,9 @@ module Bridgetown
       @placeholders = options[:placeholders] || {}
       @permalink    = options[:permalink]
 
-      if (@template || @permalink).nil?
-        raise ArgumentError, "One of :template or :permalink must be supplied."
-      end
+      return unless (@template || @permalink).nil?
+
+      raise ArgumentError, "One of :template or :permalink must be supplied."
     end
 
     # The generated relative URL of the resource

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Utils
+    module Aux
+      def self.with_color(name, message)
+        return message unless !name.nil? && Bridgetown::Utils::Ansi::COLORS[name.to_sym]
+
+        Bridgetown::Utils::Ansi.send(name, message)
+      end
+
+      def self.running_pids
+        @running_pids ||= []
+      end
+
+      def self.add_pid(pid)
+        running_pids << pid
+      end
+
+      def self.run_process(name, color, cmd)
+        Thread.new do
+          rd, wr = IO.pipe("BINARY")
+          pid = Process.spawn(cmd, out: wr, err: wr, pgroup: true)
+          @mutex.synchronize do
+            add_pid pid
+          end
+
+          loop do
+            line = rd.gets
+            line.to_s.lines.map(&:chomp).each do |message|
+              output = +""
+              output << with_color(color, "[#{name}] ") if color
+              output << message
+              @mutex.synchronize do
+                $stdout.puts output
+                $stdout.flush
+              end
+            end
+          end
+        end
+      end
+
+      def self.group(&block)
+        @mutex = Thread::Mutex.new
+        instance_exec(&block)
+      end
+
+      def self.kill_processes
+        Bridgetown.logger.info "Stopping auxiliary processes..."
+        running_pids.each do |pid|
+          Process.kill("SIGTERM", -Process.getpgid(pid))
+        rescue Errno::ESRCH, Errno::EPERM, Errno::ECHILD # rubocop:disable Lint/SuppressedException
+        end
+      end
+    end
+  end
+end

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

@@ -3,10 +3,7 @@
 module Bridgetown
   module Utils
     module RubyExec
-      extend self
-
-      # 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
+      def self.search_data_for_ruby_code(convertible)
         return if convertible.data.empty?
 
         # Iterate using `keys` here so inline Ruby script can add new data keys
@@ -14,49 +11,10 @@ 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) || v.is_a?(Proc)
-
-          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)
-
-              convertible.data[k][nested_k] = run(nested_v, convertible, renderer)
-            end
-          else
-            convertible.data[k] = run(v, convertible, renderer)
-          end
-        end
-      end
-
-      # Sets up a new context in which to eval Ruby coming from front matter.
-      #
-      # ruby_code - a string of code
-      # convertible - the Document/Page/Layout with the Ruby front matter
-      # renderer - the Renderer instance that's processing the document (optional)
-      #
-      # Returns the transformed output of the code
-      def run(ruby_code, convertible, renderer)
-        return unless ruby_code.is_a?(Rb)
+          next unless v.is_a?(Proc)
 
-        klass = Class.new
-        obj = klass.new
-
-        if convertible.is_a?(Layout)
-          klass.attr_accessor :layout, :site, :data
-          obj.layout = convertible
-        else
-          klass.attr_accessor :document, :page, :renderer, :site, :data
-          obj.document = obj.page = convertible
-          obj.renderer = renderer
+          convertible.data[k] = convertible.instance_exec(&v)
         end
-        obj.site = convertible.site
-        obj.data = convertible.data
-
-        # This is where the magic happens! DON'T BE EVIL!!! ;-)
-        output = obj.instance_eval(ruby_code)
-        output.is_a?(Hash) ? output.with_dot_access : output
       end
     end
   end

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

@@ -3,20 +3,23 @@
 module Bridgetown
   module Utils
     module RubyFrontMatterDSL
-      def front_matter(&block)
-        RubyFrontMatter.new.tap { |fm| fm.instance_exec(&block) }
+      def front_matter(scope: nil, &block)
+        RubyFrontMatter.new(scope: scope).tap { |fm| fm.instance_exec(&block) }
       end
     end
 
     class RubyFrontMatter
-      def initialize
+      def initialize(scope: nil)
         @data = {}
+        @scope = scope
       end
 
-      def method_missing(key, value) # rubocop:disable Style/MissingRespondToMissing
-        return super if respond_to?(key)
+      def method_missing(key, *value, &block) # rubocop:disable Metrics/CyclomaticComplexity, Style/MissingRespondToMissing
+        return super if respond_to?(key) || (value.length.zero? && block.nil? && !@data.key?(key))
 
-        set(key, value)
+        return get(key) if value.length.zero? && block.nil? && @data.key?(key)
+
+        set(key, value[0], &block)
       end
 
       def each(&block)
@@ -27,7 +30,19 @@ module Bridgetown
         @data[key]
       end
 
-      def set(key, value)
+      def set(key, value = nil, &block)
+        # Handle nested data within a block
+        if block
+          value = self.class.new(scope: @scope).tap do |fm|
+            fm.instance_exec(&block)
+          end.to_h
+        end
+
+        # Execute lambda value within the resolver
+        if @scope && value.is_a?(Hash) && value[:from].is_a?(Proc)
+          value = @scope.instance_exec(&value[:from])
+        end
+
         @data[key] = value
       end