bridgetown-core 0.19.0 → 0.21.0.beta1

data/lib/bridgetown-core/commands/apply.rb

@@ -26,6 +26,7 @@ module Bridgetown
 
       def apply_automation
         @source_paths = [Dir.pwd]
+        @logger = Bridgetown.logger
 
         if options[:apply]
           apply_after_new_command
@@ -33,9 +34,9 @@ module Bridgetown
           apply_in_pwd
         end
       rescue SystemExit => e
-        Bridgetown.logger.error "Problem occurred while running automation:"
+        @logger.error "Problem occurred while running automation:"
         e.backtrace[0..3].each do |backtrace_line|
-          Bridgetown.logger.info backtrace_line if backtrace_line.include?(":in `apply'")
+          @logger.info backtrace_line if backtrace_line.include?(":in `apply'")
         end
         raise e
       end
@@ -66,7 +67,7 @@ module Bridgetown
           apply_from_url automation_command
         end
       rescue ArgumentError => e
-        Bridgetown.logger.warn "Oops!", e.message
+        @logger.warn "Oops!", e.message
       end
     end
   end

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

@@ -25,6 +25,15 @@ module Bridgetown
         end
       end
 
+      desc "dream", "There's a place where that idea still exists as a reality"
+      def dream
+        puts ""
+        puts "🎶 The Dream of the 90s is Alive in Portland... ✨"
+        puts "          https://youtu.be/U4hShMEk1Ew"
+        puts "          https://youtu.be/0_HGqPGp9iY"
+        puts ""
+      end
+
       desc "help <command>", "Show detailed command usage information and exit"
       def help(subcommand = nil)
         if subcommand && respond_to?(subcommand)

data/lib/bridgetown-core/commands/concerns/actions.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-# Mostly not used here, but may come in handy in new automations
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/string/strip"
-require "active_support/core_ext/string/indent"
-
 module Bridgetown
   module Commands
     module Actions

data/lib/bridgetown-core/commands/configure.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Commands
+    class Configure < Thor::Group
+      include Thor::Actions
+      extend Summarizable
+
+      Registrations.register do
+        register(Configure, "configure", "configure CONFIGURATION", Configure.summary)
+      end
+
+      def self.banner
+        "bridgetown configure CONFIGURATION(S)"
+      end
+      summary "Set up bundled Bridgetown configurations"
+
+      def self.exit_on_failure?
+        true
+      end
+
+      def perform_configurations
+        logger = Bridgetown.logger
+        list_configurations if args.empty?
+
+        args.each do |configuration|
+          configure configuration
+        rescue Thor::Error
+          logger.error "Error:".red, "🚨 Configuration doesn't exist: #{configuration}"
+        end
+      end
+
+      def self.source_root
+        File.expand_path("../configurations", __dir__)
+      end
+
+      protected
+
+      def configure(configuration)
+        configuration_file = find_in_source_paths("#{configuration}.rb")
+
+        inside(New.created_site_dir || Dir.pwd) do
+          Apply.new.invoke(:apply_automation, [configuration_file])
+        end
+      end
+
+      def list_configurations
+        say "Please specify a valid packaged configuration from the below list:\n\n"
+        configurations.each do |configuration|
+          configuration = set_color configuration, :blue, :bold
+          say configuration
+        end
+        say "\n"
+
+        docs_url = "https://www.bridgetownrb.com/docs/bundled-configurations".yellow.bold
+        say "For more info, check out the docs at: #{docs_url}"
+      end
+
+      def configurations
+        inside self.class.source_root do
+          return Dir.glob("*.rb").map { |file| file.sub(".rb", "") }
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/commands/console.rb

@@ -28,6 +28,7 @@ module Bridgetown
 
       def console
         require "irb"
+        require "irb/ext/save-history"
         require "amazing_print" unless options[:"bypass-ap"]
 
         Bridgetown.logger.info "Starting:", "Bridgetown v#{Bridgetown::VERSION.magenta}" \
@@ -50,6 +51,7 @@ module Bridgetown
         IRB.setup(nil)
         workspace = IRB::WorkSpace.new
         irb = IRB::Irb.new(workspace)
+        IRB.conf[:IRB_RC]&.call(irb.context)
         IRB.conf[:MAIN_CONTEXT] = irb.context
         eval("site = $BRIDGETOWN_SITE", workspace.binding, __FILE__, __LINE__)
         Bridgetown.logger.info "Console:", "Now loaded as " + "site".cyan + " variable."
@@ -68,6 +70,8 @@ module Bridgetown
             end
             irb.eval_input
           end
+        ensure
+          IRB.conf[:AT_EXIT].each(&:call)
         end
       end
     end

data/lib/bridgetown-core/commands/new.rb

@@ -19,6 +19,10 @@ module Bridgetown
                    aliases: "-a",
                    banner: "PATH|URL",
                    desc: "Apply an automation after creating the site scaffold"
+      class_option :configure,
+                   aliases: "-c",
+                   banner: "CONFIGURATION(S)",
+                   desc: "Comma separated list of bundled configurations to perform"
       class_option :force,
                    type: :boolean,
                    desc: "Force creation even if PATH already exists"
@@ -100,6 +104,7 @@ module Bridgetown
       # then automatically execute bundle install from within the new site dir
       # unless the user opts to skip 'bundle install'.
       # rubocop:todo Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       def after_install(path, cli_path, options = {})
         git_init path
 
@@ -110,6 +115,7 @@ module Bridgetown
         yarn_install path unless options["skip-yarn"]
 
         invoke(Apply, [], options) if options[:apply]
+        invoke(Configure, options[:configure].split(","), {}) if options[:configure]
 
         logger = Bridgetown.logger
         yarn_start = "yarn start"
@@ -130,6 +136,7 @@ module Bridgetown
         logger.info "Yarn install skipped.".yellow if @skipped_yarn
       end
       # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
 
       def bundle_install(path)
         unless Bridgetown.environment == "test"
@@ -151,6 +158,7 @@ module Bridgetown
         unless Bridgetown.environment == "test"
           inside(path) do
             run "git init", abort_on_failure: true
+            run "if [[ -n $(git status | grep 'On branch master') ]]; then git checkout -b main; fi"
           end
         end
       rescue SystemExit

data/lib/bridgetown-core/commands/plugins.rb

@@ -150,6 +150,7 @@ module Bridgetown
         inside name do # rubocop:todo Metrics/BlockLength
           run "rm -rf .git"
           run "git init"
+          run "if [[ -n $(git status | grep 'On branch master') ]]; then git checkout -b main; fi"
 
           run "mv bridgetown-sample-plugin.gemspec #{new_gemspec}"
           gsub_file new_gemspec, "https://github.com/bridgetownrb/bridgetown-sample-plugin", "https://github.com/username/#{name}"

data/lib/bridgetown-core/component.rb

@@ -0,0 +1,178 @@
+# 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)
+        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
+        stripped_path = File.join(
+          File.dirname(source_location),
+          File.basename(source_location, ".*")
+        )
+        supported_template_extensions.each do |ext|
+          test_path = "#{stripped_path}.#{ext}"
+          return test_path if File.exist?(test_path)
+
+          test_path = "#{stripped_path}.html.#{ext}"
+          return test_path if File.exist?(test_path)
+        end
+
+        raise "No matching templates could be found in #{File.dirname(source_location)}"
+      end
+
+      # Read the template file.
+      #
+      # @return [String]
+      def component_template_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
+      # TODO: figure out a way to compile templates for increased performance
+      @_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
+        SafeYAML.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 = SafeYAML.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/site/configurable.rb

@@ -30,11 +30,15 @@ class Bridgetown::Site
       configure_include_paths
       configure_file_read_opts
 
-      self.permalink_style = config["permalink"].to_sym
+      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 +82,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 +95,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