bridgetown-core 0.7.0 → 0.7.1

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

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Commands
+    class Serve < Command
+      # Similar to the pattern in Utils::ThreadEvent except we are maintaining the
+      # state of @running instead of just signaling an event.  We have to maintain this
+      # state since Serve is just called via class methods instead of an instance
+      # being created each time.
+      @mutex = Mutex.new
+      @run_cond = ConditionVariable.new
+      @running = false
+
+      class << self
+        COMMAND_OPTIONS = {
+          "ssl_cert"           => ["--ssl-cert [CERT]", "X.509 (SSL) certificate."],
+          "host"               => ["host", "-H", "--host [HOST]", "Host to bind to"],
+          "open_url"           => ["-o", "--open-url", "Launch your site in a browser"],
+          "detach"             => ["-B", "--detach",
+                                   "Run the server in the background",],
+          "ssl_key"            => ["--ssl-key [KEY]", "X.509 (SSL) Private Key."],
+          "port"               => ["-P", "--port [PORT]", "Port to listen on"],
+          "show_dir_listing"   => ["--show-dir-listing",
+                                   "Show a directory listing instead of loading" \
+                                   " your index file.",],
+          "skip_initial_build" => ["skip_initial_build", "--skip-initial-build",
+                                   "Skips the initial site build which occurs before" \
+                                   " the server is started.",],
+        }.freeze
+
+        DIRECTORY_INDEX = %w(
+          index.htm
+          index.html
+          index.rhtml
+          index.xht
+          index.xhtml
+          index.cgi
+          index.xml
+          index.json
+        ).freeze
+
+        attr_reader :mutex, :run_cond, :running
+        alias_method :running?, :running
+
+        def init_with_program(prog)
+          prog.command(:serve) do |cmd|
+            cmd.description "Serve your site locally"
+            cmd.syntax "serve [options]"
+            cmd.alias :server
+            cmd.alias :s
+
+            add_build_options(cmd)
+            COMMAND_OPTIONS.each do |key, val|
+              cmd.option key, *val
+            end
+
+            cmd.action do |_, opts|
+              opts["serving"] = true
+              opts["watch"]   = true unless opts.key?("watch")
+
+              config = configuration_from_options(opts)
+              config["url"] = default_url(config) if Bridgetown.env == "development"
+
+              process_with_graceful_fail(cmd, config, Build, Serve)
+            end
+          end
+        end
+
+        #
+
+        def process(opts)
+          opts = configuration_from_options(opts)
+          destination = opts["destination"]
+          setup(destination)
+
+          start_up_webrick(opts, destination)
+        end
+
+        def shutdown
+          @server.shutdown if running?
+        end
+
+        private
+
+        # Do a base pre-setup of WEBRick so that everything is in place
+        # when we get ready to party, checking for an setting up an error page
+        # and making sure our destination exists.
+
+        def setup(destination)
+          require_relative "serve/servlet"
+
+          FileUtils.mkdir_p(destination)
+          if File.exist?(File.join(destination, "404.html"))
+            WEBrick::HTTPResponse.class_eval do
+              def create_error_page
+                @header["Content-Type"] = "text/html; charset=UTF-8"
+                @body = IO.read(File.join(@config[:DocumentRoot], "404.html"))
+              end
+            end
+          end
+        end
+
+        def webrick_opts(opts)
+          opts = {
+            :BridgetownOptions  => opts,
+            :DoNotReverseLookup => true,
+            :MimeTypes          => mime_types,
+            :DocumentRoot       => opts["destination"],
+            :StartCallback      => start_callback(opts["detach"]),
+            :StopCallback       => stop_callback(opts["detach"]),
+            :BindAddress        => opts["host"],
+            :Port               => opts["port"],
+            :DirectoryIndex     => DIRECTORY_INDEX,
+          }
+
+          opts[:DirectoryIndex] = [] if opts[:BridgetownOptions]["show_dir_listing"]
+
+          enable_ssl(opts)
+          enable_logging(opts)
+          opts
+        end
+
+        def start_up_webrick(opts, destination)
+          @reload_reactor.start(opts) if opts["livereload"]
+
+          @server = WEBrick::HTTPServer.new(webrick_opts(opts)).tap { |o| o.unmount("") }
+          @server.mount(opts["baseurl"].to_s, Servlet, destination, file_handler_opts)
+
+          Bridgetown.logger.info "Server address:", server_address(@server, opts)
+          launch_browser @server, opts if opts["open_url"]
+          boot_or_detach @server, opts
+        end
+
+        # Recreate NondisclosureName under utf-8 circumstance
+        def file_handler_opts
+          WEBrick::Config::FileHandler.merge(
+            :FancyIndexing     => true,
+            :NondisclosureName => [
+              ".ht*", "~*",
+            ]
+          )
+        end
+
+        def server_address(server, options = {})
+          format_url(
+            server.config[:SSLEnable],
+            server.config[:BindAddress],
+            server.config[:Port],
+            options["baseurl"]
+          )
+        end
+
+        def format_url(ssl_enabled, address, port, baseurl = nil)
+          format("%<prefix>s://%<address>s:%<port>i%<baseurl>s",
+                 :prefix  => ssl_enabled ? "https" : "http",
+                 :address => address,
+                 :port    => port,
+                 :baseurl => baseurl ? "#{baseurl}/" : "")
+        end
+
+        def default_url(opts)
+          config = configuration_from_options(opts)
+          format_url(
+            config["ssl_cert"] && config["ssl_key"],
+            config["host"] == "127.0.0.1" ? "localhost" : config["host"],
+            config["port"]
+          )
+        end
+
+        def launch_browser(server, opts)
+          address = server_address(server, opts)
+          return system "start", address if Utils::Platforms.windows?
+          return system "xdg-open", address if Utils::Platforms.linux?
+          return system "open", address if Utils::Platforms.osx?
+
+          Bridgetown.logger.error "Refusing to launch browser; " \
+            "Platform launcher unknown."
+        end
+
+        # Keep in our area with a thread or detach the server as requested
+        # by the user.  This method determines what we do based on what you
+        # ask us to do.
+        def boot_or_detach(server, opts)
+          if opts["detach"]
+            pid = Process.fork do
+              server.start
+            end
+
+            Process.detach(pid)
+            Bridgetown.logger.info "Server detached with pid '#{pid}'.", \
+                                   "Run `pkill -f bridgetown' or `kill -9 #{pid}'" \
+                                   " to stop the server."
+          else
+            t = Thread.new { server.start }
+            trap("INT") { server.shutdown }
+            t.join
+          end
+        end
+
+        # Make the stack verbose if the user requests it.
+        def enable_logging(opts)
+          opts[:AccessLog] = []
+          level = WEBrick::Log.const_get(opts[:BridgetownOptions]["verbose"] ? :DEBUG : :WARN)
+          opts[:Logger] = WEBrick::Log.new($stdout, level)
+        end
+
+        # Add SSL to the stack if the user triggers --enable-ssl and they
+        # provide both types of certificates commonly needed.  Raise if they
+        # forget to add one of the certificates.
+        def enable_ssl(opts)
+          cert, key, src =
+            opts[:BridgetownOptions].values_at("ssl_cert", "ssl_key", "source")
+
+          return if cert.nil? && key.nil?
+          raise "Missing --ssl_cert or --ssl_key. Both are required." unless cert && key
+
+          require "openssl"
+          require "webrick/https"
+
+          opts[:SSLCertificate] = OpenSSL::X509::Certificate.new(read_file(src, cert))
+          begin
+            opts[:SSLPrivateKey] = OpenSSL::PKey::RSA.new(read_file(src, key))
+          rescue StandardError
+            if defined?(OpenSSL::PKey::EC)
+              opts[:SSLPrivateKey] = OpenSSL::PKey::EC.new(read_file(src, key))
+            else
+              raise
+            end
+          end
+          opts[:SSLEnable] = true
+        end
+
+        def start_callback(detached)
+          unless detached
+            proc do
+              mutex.synchronize do
+                # Block until EventMachine reactor starts
+                @reload_reactor&.started_event&.wait
+                @running = true
+                Bridgetown.logger.info("Server running…", "press ctrl-c to stop.")
+                @run_cond.broadcast
+              end
+            end
+          end
+        end
+
+        def stop_callback(detached)
+          unless detached
+            proc do
+              mutex.synchronize do
+                unless @reload_reactor.nil?
+                  @reload_reactor.stop
+                  @reload_reactor.stopped_event.wait
+                end
+                @running = false
+                @run_cond.broadcast
+              end
+            end
+          end
+        end
+
+        def mime_types
+          file = File.expand_path("../mime.types", __dir__)
+          WEBrick::HTTPUtils.load_mime_types(file)
+        end
+
+        def read_file(source_dir, file_path)
+          File.read(Bridgetown.sanitized_path(source_dir, file_path))
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/commands/serve/servlet.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Bridgetown
+  module Commands
+    class Serve
+      class Servlet < WEBrick::HTTPServlet::FileHandler
+        DEFAULTS = {
+          "Cache-Control" => "private, max-age=0, proxy-revalidate, " \
+            "no-store, no-cache, must-revalidate",
+        }.freeze
+
+        def initialize(server, root, callbacks)
+          # So we can access them easily.
+          @bridgetown_opts = server.config[:BridgetownOptions]
+          set_defaults
+          super
+        end
+
+        def search_index_file(req, res)
+          super ||
+            search_file(req, res, ".html") ||
+            search_file(req, res, ".xhtml")
+        end
+
+        # Add the ability to tap file.html the same way that Nginx does on our
+        # Docker images (or on GitHub Pages.) The difference is that we might end
+        # up with a different preference on which comes first.
+
+        def search_file(req, res, basename)
+          # /file.* > /file/index.html > /file.html
+          super ||
+            super(req, res, "#{basename}.html") ||
+            super(req, res, "#{basename}.xhtml")
+        end
+
+        # rubocop:disable Naming/MethodName
+        def do_GET(req, res)
+          rtn = super
+
+          validate_and_ensure_charset(req, res)
+          res.header.merge!(@headers)
+          rtn
+        end
+        # rubocop:enable Naming/MethodName
+
+        private
+
+        def validate_and_ensure_charset(_req, res)
+          key = res.header.keys.grep(%r!content-type!i).first
+          typ = res.header[key]
+
+          unless %r!;\s*charset=!.match?(typ)
+            res.header[key] = "#{typ}; charset=#{@bridgetown_opts["encoding"]}"
+          end
+        end
+
+        def set_defaults
+          hash_ = @bridgetown_opts.fetch("webrick", {}).fetch("headers", {})
+          DEFAULTS.each_with_object(@headers = hash_) do |(key, val), hash|
+            hash[key] = val unless hash.key?(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/configuration.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class Configuration < Hash
+    # Default options. Overridden by values in bridgetown.config.yml.
+    # Strings rather than symbols are used for compatibility with YAML.
+    DEFAULTS = {
+      # Where things are
+      "root_dir"            => Dir.pwd,
+      "plugins_dir"         => "plugins",
+      "source"              => File.join(Dir.pwd, "src"),
+      "destination"         => File.join(Dir.pwd, "output"),
+      "collections_dir"     => "",
+      "cache_dir"           => ".bridgetown-cache",
+      "layouts_dir"         => "_layouts",
+      "data_dir"            => "_data",
+      "includes_dir"        => "_includes",
+      "collections"         => {},
+
+      # Handling Reading
+      "include"             => [".htaccess", "_redirects", ".well-known"],
+      "exclude"             => [],
+      "keep_files"          => [".git", ".svn", "_bridgetown"],
+      "encoding"            => "utf-8",
+      "markdown_ext"        => "markdown,mkdown,mkdn,mkd,md",
+      "strict_front_matter" => false,
+
+      # Filtering Content
+      "limit_posts"         => 0,
+      "future"              => false,
+      "unpublished"         => false,
+
+      # Conversion
+      "markdown"            => "kramdown",
+      "highlighter"         => "rouge",
+      "lsi"                 => false,
+      "excerpt_separator"   => "\n\n",
+      "incremental"         => false,
+
+      # Serving
+      "detach"              => false, # default to not detaching the server
+      "port"                => "4000",
+      "host"                => "127.0.0.1",
+      "baseurl"             => nil, # this mounts at /, i.e. no subdirectory
+      "show_dir_listing"    => false,
+
+      # Output Configuration
+      "permalink"           => "date",
+      "paginate_path"       => "/page:num",
+      "timezone"            => nil, # use the local timezone
+
+      "quiet"               => false,
+      "verbose"             => false,
+      "defaults"            => [],
+
+      "liquid"              => {
+        "error_mode"       => "warn",
+        "strict_filters"   => false,
+        "strict_variables" => false,
+      },
+
+      "kramdown"            => {
+        "auto_ids"      => true,
+        "toc_levels"    => (1..6).to_a,
+        "entity_output" => "as_char",
+        "smart_quotes"  => "lsquo,rsquo,ldquo,rdquo",
+        "input"         => "GFM",
+        "hard_wrap"     => false,
+        "guess_lang"    => true,
+        "footnote_nr"   => 1,
+        "show_warnings" => false,
+      },
+    }.each_with_object(Configuration.new) { |(k, v), hsh| hsh[k] = v.freeze }.freeze
+
+    # The modern default config file name is bridgetown.config.EXT, but we also
+    # need to check for _config.EXT as a backward-compatibility nod to our
+    # progenitor
+    CONFIG_FILE_PREFIXES = %w(bridgetown.config _config).freeze
+    CONFIG_FILE_EXTS = %w(yml yaml toml).freeze
+
+    class << self
+      # Static: Produce a Configuration ready for use in a Site.
+      # It takes the input, fills in the defaults where values do not exist.
+      #
+      # user_config - a Hash or Configuration of overrides.
+      #
+      # Returns a Configuration filled with defaults.
+      def from(user_config)
+        Utils.deep_merge_hashes(DEFAULTS, Configuration[user_config].stringify_keys)
+          .add_default_collections.add_default_excludes
+      end
+    end
+
+    # Public: Turn all keys into string
+    #
+    # Return a copy of the hash where all its keys are strings
+    def stringify_keys
+      each_with_object({}) { |(k, v), hsh| hsh[k.to_s] = v }
+    end
+
+    def get_config_value_with_override(config_key, override)
+      override[config_key] || self[config_key] || DEFAULTS[config_key]
+    end
+
+    # Public: Directory of the top-level root where config files are located
+    #
+    # override - the command-line options hash
+    #
+    # Returns the path to the Bridgetown root directory
+    def root_dir(override)
+      get_config_value_with_override("root_dir", override)
+    end
+
+    # Public: Directory of the Bridgetown source folder
+    #
+    # override - the command-line options hash
+    #
+    # Returns the path to the Bridgetown source directory
+    def source(override)
+      get_config_value_with_override("source", override)
+    end
+
+    def quiet(override = {})
+      get_config_value_with_override("quiet", override)
+    end
+    alias_method :quiet?, :quiet
+
+    def verbose(override = {})
+      get_config_value_with_override("verbose", override)
+    end
+    alias_method :verbose?, :verbose
+
+    def safe_load_file(filename)
+      case File.extname(filename)
+      when %r!\.toml!i
+        Bridgetown::External.require_with_graceful_fail("tomlrb") unless defined?(Tomlrb)
+        Tomlrb.load_file(filename)
+      when %r!\.ya?ml!i
+        SafeYAML.load_file(filename) || {}
+      else
+        raise ArgumentError,
+              "No parser for '#{filename}' is available. Use a .y(a)ml or .toml file instead."
+      end
+    end
+
+    # Public: Generate list of configuration files from the override
+    #
+    # override - the command-line options hash
+    #
+    # Returns an Array of config files
+    def config_files(override)
+      # Adjust verbosity quickly
+      Bridgetown.logger.adjust_verbosity(
+        :quiet   => quiet?(override),
+        :verbose => verbose?(override)
+      )
+
+      # Get configuration from <root_dir>/<matching_default_config>
+      # or <root_dir>/<config_file> if there's a command line override.
+      # By default only the first matching config file will be loaded, but
+      # multiple configs can be specified via command line.
+      config_files = override["config"]
+      if config_files.to_s.empty?
+        file_lookups = CONFIG_FILE_PREFIXES.map do |prefix|
+          CONFIG_FILE_EXTS.map do |ext|
+            Bridgetown.sanitized_path(root_dir(override), "#{prefix}.#{ext}")
+          end
+        end.flatten.freeze
+
+        found_file = file_lookups.find do |path|
+          File.exist?(path)
+        end
+
+        config_files = found_file || file_lookups.first
+        @default_config_file = true
+      end
+      Array(config_files)
+    end
+
+    # Public: Read configuration and return merged Hash
+    #
+    # file - the path to the YAML file to be read in
+    #
+    # Returns this configuration, overridden by the values in the file
+    def read_config_file(file)
+      file = File.expand_path(file)
+      next_config = safe_load_file(file)
+
+      unless next_config.is_a?(Hash)
+        raise ArgumentError, "Configuration file: (INVALID) #{file}".yellow
+      end
+
+      Bridgetown.logger.info "Configuration file:", file
+      next_config
+    rescue SystemCallError
+      if @default_config_file ||= nil
+        Bridgetown.logger.warn "Configuration file:", "none"
+        {}
+      else
+        Bridgetown.logger.error "Fatal:", "The configuration file '#{file}' could not be found."
+        raise LoadError, "The Configuration file '#{file}' could not be found."
+      end
+    end
+
+    # Public: Read in a list of configuration files and merge with this hash
+    #
+    # files - the list of configuration file paths
+    #
+    # Returns the full configuration, with the defaults overridden by the values in the
+    # configuration files
+    def read_config_files(files)
+      configuration = clone
+
+      begin
+        files.each do |config_file|
+          next if config_file.nil? || config_file.empty?
+
+          new_config = read_config_file(config_file)
+          configuration = Utils.deep_merge_hashes(configuration, new_config)
+        end
+      rescue ArgumentError => e
+        Bridgetown.logger.warn "WARNING:", "Error reading configuration. Using defaults" \
+                                " (and options)."
+        warn e
+      end
+
+      configuration.validate.add_default_collections
+    end
+
+    # Public: Split a CSV string into an array containing its values
+    #
+    # csv - the string of comma-separated values
+    #
+    # Returns an array of the values contained in the CSV
+    def csv_to_array(csv)
+      csv.split(",").map(&:strip)
+    end
+
+    # Public: Ensure the proper options are set in the configuration
+    #
+    # Returns the configuration Hash
+    def validate
+      config = clone
+
+      check_include_exclude(config)
+
+      config
+    end
+
+    def add_default_collections
+      config = clone
+
+      # It defaults to `{}`, so this is only if someone sets it to null manually.
+      return config if config["collections"].nil?
+
+      # Ensure we have a hash.
+      if config["collections"].is_a?(Array)
+        config["collections"] = config["collections"].each_with_object({}) do |collection, hash|
+          hash[collection] = {}
+        end
+      end
+
+      config["collections"] = Utils.deep_merge_hashes(
+        { "posts" => {} }, config["collections"]
+      ).tap do |collections|
+        collections["posts"]["output"] = true
+        if config["permalink"]
+          collections["posts"]["permalink"] ||= style_to_permalink(config["permalink"])
+        end
+      end
+
+      config
+    end
+
+    DEFAULT_EXCLUDES = %w(
+      .sass-cache .bridgetown-cache
+      gemfiles Gemfile Gemfile.lock
+      node_modules
+      vendor/bundle/ vendor/cache/ vendor/gems/ vendor/ruby/
+    ).freeze
+
+    def add_default_excludes
+      config = clone
+      return config if config["exclude"].nil?
+
+      config["exclude"].concat(DEFAULT_EXCLUDES).uniq!
+      config
+    end
+
+    private
+
+    # rubocop:disable Metrics/CyclomaticComplexity #
+    def style_to_permalink(permalink_style)
+      case permalink_style.to_sym
+      when :pretty
+        "/:categories/:year/:month/:day/:title/"
+      when :simple
+        "/:categories/:title/"
+      when :none
+        "/:categories/:title:output_ext"
+      when :date
+        "/:categories/:year/:month/:day/:title:output_ext"
+      when :ordinal
+        "/:categories/:year/:y_day/:title:output_ext"
+      when :weekdate
+        "/:categories/:year/W:week/:short_day/:title:output_ext"
+      else
+        permalink_style.to_s
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity #
+
+    def check_include_exclude(config)
+      %w(include exclude).each do |option|
+        next unless config.key?(option)
+        next if config[option].is_a?(Array)
+
+        raise Bridgetown::Errors::InvalidConfigurationError,
+              "'#{option}' should be set as an array, but was: #{config[option].inspect}."
+      end
+    end
+  end
+end