bridgetown-core 0.7.0 → 0.7.1

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Commands
+    class Build < Command
+      class << self
+        # Create the Mercenary command for the Bridgetown CLI for this Command
+        def init_with_program(prog)
+          prog.command(:build) do |c|
+            c.syntax      "build [options]"
+            c.description "Build your site"
+            c.alias :b
+
+            add_build_options(c)
+
+            c.action do |_, options|
+              options["serving"] = false
+              process_with_graceful_fail(c, options, self)
+            end
+          end
+        end
+
+        # Build your bridgetown site
+        # Continuously watch if `watch` is set to true in the config.
+        def process(options)
+          # Adjust verbosity quickly
+          Bridgetown.logger.adjust_verbosity(options)
+
+          Bridgetown.logger.info "#", "Your Bridgetown #{Bridgetown::VERSION}" \
+                                      " build is about to begin…"
+
+          options = configuration_from_options(options)
+          site = Bridgetown::Site.new(options)
+
+          if options.fetch("skip_initial_build", false)
+            Bridgetown.logger.warn "Build Warning:", "Skipping the initial build." \
+                               " This may result in an out-of-date site."
+          else
+            build(site, options)
+          end
+
+          if options.fetch("detach", false)
+            Bridgetown.logger.info "Auto-regeneration:",
+                                   "disabled when running server detached."
+          elsif options.fetch("watch", false)
+            watch(site, options)
+          else
+            Bridgetown.logger.info "Auto-regeneration:", "disabled. Use --watch to enable."
+          end
+        end
+
+        # Build your Bridgetown site.
+        #
+        # site - the Bridgetown::Site instance to build
+        # options - A Hash of options passed to the command
+        #
+        # Returns nothing.
+        def build(site, options)
+          t = Time.now
+          source = File.expand_path(options["source"])
+          destination = File.expand_path(options["destination"])
+          incremental = options["incremental"]
+          Bridgetown.logger.info "Source:", source
+          Bridgetown.logger.info "Destination:", destination
+          Bridgetown.logger.info "Incremental build:",
+                                 (incremental ? "enabled" : "disabled. Enable with --incremental")
+          Bridgetown.logger.info "Generating…"
+          process_site(site)
+          Bridgetown.logger.info "Done! 🎉", "Completed in #{(Time.now - t).round(3)} seconds."
+        end
+
+        # Private: Watch for file changes and rebuild the site.
+        #
+        # site - A Bridgetown::Site instance
+        # options - A Hash of options passed to the command
+        #
+        # Returns nothing.
+        def watch(site, options)
+          # Warn Windows users that they might need to upgrade.
+          if Utils::Platforms.bash_on_windows?
+            Bridgetown.logger.warn "",
+                                   "Auto-regeneration may not work on some Windows versions."
+            Bridgetown.logger.warn "",
+                                   "Please see: https://github.com/Microsoft/BashOnWindows/issues/216"
+            Bridgetown.logger.warn "",
+                                   "If it does not work, please upgrade Bash on Windows or "\
+                                   "run Bridgetown with --no-watch."
+          end
+
+          #          External.require_with_graceful_fail "bridgetown-watch"
+          Bridgetown::Watcher.watch(options, site)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Commands
+    class Clean < Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:clean) do |c|
+            c.syntax "clean [subcommand]"
+            c.description "Clean the site " \
+                  "(removes site output and metadata file) without building."
+
+            add_build_options(c)
+
+            c.action do |_, options|
+              Bridgetown::Commands::Clean.process(options)
+            end
+          end
+        end
+
+        def process(options)
+          options = configuration_from_options(options)
+          destination = options["destination"]
+          metadata_file = File.join(options["source"], ".bridgetown-metadata")
+          cache_dir = File.join(options["source"], options["cache_dir"])
+
+          remove(destination, :checker_func => :directory?)
+          remove(metadata_file, :checker_func => :file?)
+          remove(cache_dir, :checker_func => :directory?)
+        end
+
+        def remove(filename, checker_func: :file?)
+          if File.public_send(checker_func, filename)
+            Bridgetown.logger.info "Cleaner:", "Removing #{filename}..."
+            FileUtils.rm_rf(filename)
+          else
+            Bridgetown.logger.info "Cleaner:", "Nothing to do for #{filename}."
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "irb"
+
+module Bridgetown
+  module Commands
+    class Console < Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:console) do |c|
+            c.syntax "console"
+            c.description "Invoke an IRB console with the site loaded"
+            c.alias :c
+
+            c.option "config", "--config CONFIG_FILE[,CONFIG_FILE2,...]", Array,
+                     "Custom configuration file"
+
+            c.action do |_, options|
+              Bridgetown::Commands::Console.process(options)
+            end
+          end
+        end
+
+        # TODO: is there a way to add a unit test for this command?
+        # rubocop:disable Style/GlobalVars, Metrics/AbcSize, Metrics/MethodLength
+        def process(options)
+          Bridgetown.logger.info "Starting Bridgetown #{Bridgetown::VERSION} console…"
+          site = Bridgetown::Site.new(configuration_from_options(options))
+          Bridgetown.logger.info "Loading site…"
+          site.reset
+          site.read
+          site.generate
+
+          $BRIDGETOWN_SITE = site
+          IRB.setup(nil)
+          workspace = IRB::WorkSpace.new
+          irb = IRB::Irb.new(workspace)
+          IRB.conf[:MAIN_CONTEXT] = irb.context
+          eval("site = $BRIDGETOWN_SITE", workspace.binding, __FILE__, __LINE__)
+          Bridgetown.logger.info "", "Now loaded as " + "site".cyan + " variable."
+
+          trap("SIGINT") do
+            irb.signal_handle
+          end
+
+          begin
+            catch(:IRB_EXIT) do
+              irb.eval_input
+            end
+          end
+        end
+        # rubocop:enable Style/GlobalVars, Metrics/AbcSize, Metrics/MethodLength
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Commands
+    class Doctor < Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:doctor) do |c|
+            c.syntax "doctor"
+            c.description "Search site and print specific deprecation warnings"
+
+            c.option "config", "--config CONFIG_FILE[,CONFIG_FILE2,...]", Array,
+                     "Custom configuration file"
+
+            c.action do |_, options|
+              Bridgetown::Commands::Doctor.process(options)
+            end
+          end
+        end
+
+        def process(options)
+          site = Bridgetown::Site.new(configuration_from_options(options))
+          site.reset
+          site.read
+          site.generate
+
+          if healthy?(site)
+            Bridgetown.logger.info "Your test results", "are in. Everything looks fine."
+          else
+            abort
+          end
+        end
+
+        def healthy?(site)
+          [
+            fsnotify_buggy?(site),
+            !deprecated_relative_permalinks(site),
+            !conflicting_urls(site),
+            !urls_only_differ_by_case(site),
+            proper_site_url?(site),
+            properly_gathered_posts?(site),
+          ].all?
+        end
+
+        def properly_gathered_posts?(site)
+          return true if site.config["collections_dir"].empty?
+
+          posts_at_root = site.in_source_dir("_posts")
+          return true unless File.directory?(posts_at_root)
+
+          Bridgetown.logger.warn "Warning:",
+                                 "Detected '_posts' directory outside custom `collections_dir`!"
+          Bridgetown.logger.warn "",
+                                 "Please move '#{posts_at_root}' into the custom directory at " \
+                "'#{site.in_source_dir(site.config["collections_dir"])}'"
+          false
+        end
+
+        def deprecated_relative_permalinks(site)
+          if site.config["relative_permalinks"]
+            Bridgetown::Deprecator.deprecation_message "Your site still uses relative permalinks," \
+                                                   " which was removed in Bridgetown v0.1"
+            true
+          end
+        end
+
+        def conflicting_urls(site)
+          conflicting_urls = false
+          urls = {}
+          urls = collect_urls(urls, site.pages, site.dest)
+          urls = collect_urls(urls, site.posts.docs, site.dest)
+          urls.each do |url, paths|
+            next unless paths.size > 1
+
+            conflicting_urls = true
+            Bridgetown.logger.warn "Conflict:", "The URL '#{url}' is the destination" \
+              " for the following pages: #{paths.join(", ")}"
+          end
+          conflicting_urls
+        end
+
+        def fsnotify_buggy?(_site)
+          return true unless Utils::Platforms.osx?
+
+          if Dir.pwd != `pwd`.strip
+            Bridgetown.logger.error "  " + <<-STR.strip.gsub(%r!\n\s+!, "\n  ")
+              We have detected that there might be trouble using fsevent on your
+              operating system, you can read https://github.com/thibaudgg/rb-fsevent/wiki/no-fsevents-fired-(OSX-bug)
+              for possible work arounds or you can work around it immediately
+              with `--force-polling`.
+            STR
+
+            false
+          end
+
+          true
+        end
+
+        def urls_only_differ_by_case(site)
+          urls_only_differ_by_case = false
+          urls = case_insensitive_urls(site.pages + site.docs_to_write, site.dest)
+          urls.each_value do |real_urls|
+            next unless real_urls.uniq.size > 1
+
+            urls_only_differ_by_case = true
+            Bridgetown.logger.warn "Warning:", "The following URLs only differ" \
+              " by case. On a case-insensitive file system one of the URLs" \
+              " will be overwritten by the other: #{real_urls.join(", ")}"
+          end
+          urls_only_differ_by_case
+        end
+
+        def proper_site_url?(site)
+          url = site.config["url"]
+          [
+            url_exists?(url),
+            url_valid?(url),
+            url_absolute(url),
+          ].all?
+        end
+
+        private
+
+        def collect_urls(urls, things, destination)
+          things.each do |thing|
+            dest = thing.destination(destination)
+            if urls[dest]
+              urls[dest] << thing.path
+            else
+              urls[dest] = [thing.path]
+            end
+          end
+          urls
+        end
+
+        def case_insensitive_urls(things, destination)
+          things.each_with_object({}) do |thing, memo|
+            dest = thing.destination(destination)
+            (memo[dest.downcase] ||= []) << dest
+          end
+        end
+
+        def url_exists?(url)
+          return true unless url.nil? || url.empty?
+
+          Bridgetown.logger.warn "Warning:", "You didn't set an URL in the config file, "\
+              "you may encounter problems with some plugins."
+          false
+        end
+
+        def url_valid?(url)
+          Addressable::URI.parse(url)
+          true
+        # Addressable::URI#parse only raises a TypeError
+        # https://git.io/vFfbx
+        rescue TypeError
+          Bridgetown.logger.warn "Warning:", "The site URL does not seem to be valid, "\
+              "check the value of `url` in your config file."
+          false
+        end
+
+        def url_absolute(url)
+          return true if url.is_a?(String) && Addressable::URI.parse(url).absolute?
+
+          Bridgetown.logger.warn "Warning:", "Your site URL does not seem to be absolute, "\
+              "check the value of `url` in your config file."
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Commands
+    class Help < Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:help) do |c|
+            c.syntax "help [subcommand]"
+            c.description "Show the help message, optionally for a given subcommand."
+
+            c.action do |args, _|
+              cmd = (args.first || "").to_sym
+              if args.empty?
+                Bridgetown.logger.info prog.to_s
+              elsif prog.has_command? cmd
+                Bridgetown.logger.info prog.commands[cmd].to_s
+              else
+                invalid_command(prog, cmd)
+                abort
+              end
+            end
+          end
+        end
+
+        def invalid_command(prog, cmd)
+          Bridgetown.logger.error "Error:",
+                                  "Hmm... we don't know what the '#{cmd}' command is."
+          Bridgetown.logger.info  "Valid commands:", prog.commands.keys.join(", ")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Bridgetown
+  module Commands
+    class New < Command
+      class << self
+        DOCSURL = "https://bridgetownrb.com/docs"
+
+        def init_with_program(prog)
+          prog.command(:new) do |c|
+            c.syntax "new PATH"
+            c.description "Creates a new Bridgetown site scaffold in PATH"
+
+            c.option "force", "--force", "Force creation even if PATH already exists"
+            c.option "skip-bundle", "--skip-bundle", "Skip 'bundle install'"
+
+            c.action do |args, options|
+              Bridgetown::Commands::New.process(args, options)
+            end
+          end
+        end
+
+        def process(args, options = {})
+          raise ArgumentError, "You must specify a path." if args.empty?
+
+          new_site_path = File.expand_path(args.join(" "), Dir.pwd)
+          FileUtils.mkdir_p new_site_path
+          if preserve_source_location?(new_site_path, options)
+            Bridgetown.logger.error "Conflict:", "#{new_site_path} exists and is not empty."
+            Bridgetown.logger.abort_with "", "Ensure #{new_site_path} is empty or else " \
+                      "try again with `--force` to proceed and overwrite any files."
+          end
+
+          create_site new_site_path
+
+          after_install(new_site_path, args.join(" "), options)
+        end
+
+        def scaffold_post_content
+          ERB.new(File.read(File.expand_path(scaffold_path, site_template))).result
+        end
+
+        # Internal: Gets the filename of the sample post to be created
+        #
+        # Returns the filename of the sample post, as a String
+        def initialized_post_name
+          "src/_posts/#{Time.now.strftime("%Y-%m-%d")}-welcome-to-bridgetown.md"
+        end
+
+        private
+
+        def gemfile_contents
+          <<~RUBY
+            source "https://rubygems.org"
+            # Hello! This is where you manage which Bridgetown version is used to run.
+            # When you want to use a different version, change it below, save the
+            # file and run `bundle install`. Run Bridgetown with `bundle exec`, like so:
+            #
+            #   bundle exec bridgetown serve
+            #
+            # This will help ensure the proper Bridgetown version is running.
+            #
+            # To install a plugin, simply run bundle add and specify the group
+            # "bridgetown_plugins". For example:
+            #
+            #   bundle add some-new-plugin -g bridgetown_plugins
+            #
+            # Happy Bridgetowning!
+
+            gem "bridgetown", "~> #{Bridgetown::VERSION}"
+
+          RUBY
+        end
+
+        def create_site(new_site_path)
+          create_sample_files new_site_path
+
+          File.open(File.expand_path(initialized_post_name, new_site_path), "w") do |f|
+            f.write(scaffold_post_content)
+          end
+
+          File.open(File.expand_path("Gemfile", new_site_path), "w") do |f|
+            f.write(gemfile_contents)
+          end
+        end
+
+        def preserve_source_location?(path, options)
+          !options["force"] && !Dir["#{path}/**/*"].empty?
+        end
+
+        def create_sample_files(path)
+          FileUtils.cp_r site_template + "/.", path
+          FileUtils.chmod_R "u+w", path
+          FileUtils.rm File.expand_path(scaffold_path, path)
+        end
+
+        def site_template
+          File.expand_path("../../site_template", __dir__)
+        end
+
+        def scaffold_path
+          "src/_posts/0000-00-00-welcome-to-bridgetown.md.erb"
+        end
+
+        # After a new blog has been created, print a success notification and
+        # then automatically execute bundle install from within the new blog dir
+        # unless the user opts to generate a blank blog or skip 'bundle install'.
+        # rubocop:disable Metrics/AbcSize #
+        def after_install(path, cli_path, options = {})
+          unless options["blank"] || options["skip-bundle"]
+            begin
+              require "bundler"
+              bundle_install path
+            rescue LoadError
+              Bridgetown.logger.info "Could not load Bundler. Bundle install skipped."
+            end
+          end
+
+          Bridgetown.logger.info "Success! 🎉 Your new Bridgetown site was" \
+                                  " generated in #{cli_path.cyan}."
+          Bridgetown.logger.info "Execute cd #{cli_path.cyan} to get started."
+          Bridgetown.logger.info "You'll probably also want to #{"yarn install".cyan}" \
+                                  " to load in your frontend assets."
+          Bridgetown.logger.info "Check out our online documentation for" \
+                                  " next steps: #{DOCSURL.cyan}"
+          Bridgetown.logger.info "Bundle install skipped." if options["skip-bundle"]
+        end
+        # rubocop:enable Metrics/AbcSize #
+
+        def bundle_install(path)
+          Bridgetown.logger.info "Running bundle install in #{path.cyan}..."
+          Dir.chdir(path) do
+            exe = Gem.bin_path("bundler", "bundle")
+            process, output = Bridgetown::Utils::Exec.run("ruby", exe, "install")
+
+            output.to_s.each_line do |line|
+              Bridgetown.logger.info("Bundler:".green, line.strip) unless line.to_s.empty?
+            end
+
+            raise SystemExit unless process.success?
+          end
+        end
+      end
+    end
+  end
+end