ngage 0.0.0

data/lib/ngage/jekyll/commands/new.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Jekyll
+  module Commands
+    class New < Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:new) do |c|
+            c.syntax "new PATH"
+            c.description "Creates a new Jekyll site scaffold in PATH"
+
+            c.option "force", "--force", "Force creation even if PATH already exists"
+            c.option "blank", "--blank", "Creates scaffolding but with empty files"
+            c.option "skip-bundle", "--skip-bundle", "Skip 'bundle install'"
+
+            c.action do |args, options|
+              Jekyll::Commands::New.process(args, options)
+            end
+          end
+        end
+
+        def process(args, options = {})
+          raise ArgumentError, "You must specify a path." if args.empty?
+
+          new_blog_path = File.expand_path(args.join(" "), Dir.pwd)
+          FileUtils.mkdir_p new_blog_path
+          if preserve_source_location?(new_blog_path, options)
+            Jekyll.logger.error "Conflict:", "#{new_blog_path} exists and is not empty."
+            Jekyll.logger.abort_with "", "Ensure #{new_blog_path} is empty or else " \
+                      "try again with `--force` to proceed and overwrite any files."
+          end
+
+          if options["blank"]
+            create_blank_site new_blog_path
+          else
+            create_site new_blog_path
+          end
+
+          after_install(new_blog_path, options)
+        end
+
+        def create_blank_site(path)
+          Dir.chdir(path) do
+            FileUtils.mkdir(%w(_layouts _posts _drafts))
+            FileUtils.touch("index.html")
+          end
+        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
+          "_posts/#{Time.now.strftime("%Y-%m-%d")}-welcome-to-jekyll.markdown"
+        end
+
+        private
+
+        def gemfile_contents
+          <<~RUBY
+            source "https://rubygems.org"
+            # Hello! This is where you manage which Jekyll version is used to run.
+            # When you want to use a different version, change it below, save the
+            # file and run `bundle install`. Run Jekyll with `bundle exec`, like so:
+            #
+            #     bundle exec jekyll serve
+            #
+            # This will help ensure the proper Jekyll version is running.
+            # Happy Jekylling!
+            gem "jekyll", "~> #{Jekyll::VERSION}"
+            # This is the default theme for new Jekyll sites. You may change this to anything you like.
+            gem "minima", "~> 2.0"
+            # If you want to use GitHub Pages, remove the "gem "jekyll"" above and
+            # uncomment the line below. To upgrade, run `bundle update github-pages`.
+            # gem "github-pages", group: :jekyll_plugins
+            # If you have any plugins, put them here!
+            group :jekyll_plugins do
+              gem "jekyll-feed", "~> 0.6"
+            end
+            # Windows does not include zoneinfo files, so bundle the tzinfo-data gem
+            gem "tzinfo-data", platforms: [:mingw, :mswin, :x64_mingw, :jruby]
+            # Performance-booster for watching directories on Windows
+            gem "wdm", "~> 0.1.0" if Gem.win_platform?
+
+          RUBY
+        end
+
+        def create_site(new_blog_path)
+          create_sample_files new_blog_path
+
+          File.open(File.expand_path(initialized_post_name, new_blog_path), "w") do |f|
+            f.write(scaffold_post_content)
+          end
+
+          File.open(File.expand_path("Gemfile", new_blog_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
+          "_posts/0000-00-00-welcome-to-jekyll.markdown.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'.
+
+        def after_install(path, options = {})
+          unless options["blank"] || options["skip-bundle"]
+            begin
+              require "bundler"
+              bundle_install path
+            rescue LoadError
+              Jekyll.logger.info "Could not load Bundler. Bundle install skipped."
+            end
+          end
+
+          Jekyll.logger.info "New jekyll site installed in #{path.cyan}."
+          Jekyll.logger.info "Bundle install skipped." if options["skip-bundle"]
+        end
+
+        def bundle_install(path)
+          Jekyll.logger.info "Running bundle install in #{path.cyan}..."
+          Dir.chdir(path) do
+            exe = Gem.bin_path("bundler", "bundle")
+            process, output = Jekyll::Utils::Exec.run("ruby", exe, "install")
+
+            output.to_s.each_line do |line|
+              Jekyll.logger.info("Bundler:".green, line.strip) unless line.to_s.empty?
+            end
+
+            raise SystemExit unless process.success?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ngage/jekyll/commands/new_theme.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Jekyll
+  module Commands
+    class NewTheme < Jekyll::Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:"new-theme") do |c|
+            c.syntax "new-theme NAME"
+            c.description "Creates a new Jekyll theme scaffold"
+            c.option "code_of_conduct", \
+                     "-c", "--code-of-conduct", \
+                     "Include a Code of Conduct. (defaults to false)"
+
+            c.action do |args, opts|
+              Jekyll::Commands::NewTheme.process(args, opts)
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def process(args, opts)
+          if !args || args.empty?
+            raise Jekyll::Errors::InvalidThemeName, "You must specify a theme name."
+          end
+
+          new_theme_name = args.join("_")
+          theme = Jekyll::ThemeBuilder.new(new_theme_name, opts)
+          Jekyll.logger.abort_with "Conflict:", "#{theme.path} already exists." if theme.path.exist?
+
+          theme.create!
+          Jekyll.logger.info "Your new Jekyll theme, #{theme.name.cyan}," \
+                             " is ready for you in #{theme.path.to_s.cyan}!"
+          Jekyll.logger.info "For help getting started, read #{theme.path}/README.md."
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/ngage/jekyll/commands/serve.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+
+module Jekyll
+  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.",],
+          "livereload"           => ["-l", "--livereload",
+                                     "Use LiveReload to automatically refresh browsers",],
+          "livereload_ignore"    => ["--livereload-ignore ignore GLOB1[,GLOB2[,...]]",
+                                     Array,
+                                     "Files for LiveReload to ignore. " \
+                                     "Remember to quote the values so your shell " \
+                                     "won't expand them",],
+          "livereload_min_delay" => ["--livereload-min-delay [SECONDS]",
+                                     "Minimum reload delay",],
+          "livereload_max_delay" => ["--livereload-max-delay [SECONDS]",
+                                     "Maximum reload delay",],
+          "livereload_port"      => ["--livereload-port [PORT]", Integer,
+                                     "Port for LiveReload to listen on",],
+        }.freeze
+
+        DIRECTORY_INDEX = %w(
+          index.htm
+          index.html
+          index.rhtml
+          index.xht
+          index.xhtml
+          index.cgi
+          index.xml
+          index.json
+        ).freeze
+
+        LIVERELOAD_PORT = 35_729
+        LIVERELOAD_DIR = File.join(__dir__, "serve", "livereload_assets")
+
+        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["livereload_port"] ||= LIVERELOAD_PORT
+              opts["serving"] = true
+              opts["watch"]   = true unless opts.key?("watch")
+
+              # Set the reactor to nil so any old reactor will be GCed.
+              # We can't unregister a hook so while running tests we don't want to
+              # inadvertently keep using a reactor created by a previous test.
+              @reload_reactor = nil
+
+              config = configuration_from_options(opts)
+              config["url"] = default_url(config) if Jekyll.env == "development"
+
+              process_with_graceful_fail(cmd, config, Build, Serve)
+            end
+          end
+        end
+
+        #
+
+        def process(opts)
+          opts = configuration_from_options(opts)
+          destination = opts["destination"]
+          if opts["livereload"]
+            validate_options(opts)
+            register_reload_hooks(opts)
+          end
+          setup(destination)
+
+          start_up_webrick(opts, destination)
+        end
+
+        def shutdown
+          @server.shutdown if running?
+        end
+
+        # Perform logical validation of CLI options
+
+        private
+
+        def validate_options(opts)
+          if opts["livereload"]
+            if opts["detach"]
+              Jekyll.logger.warn "Warning:", "--detach and --livereload are mutually exclusive." \
+                                 " Choosing --livereload"
+              opts["detach"] = false
+            end
+            if opts["ssl_cert"] || opts["ssl_key"]
+              # This is not technically true.  LiveReload works fine over SSL, but
+              # EventMachine's SSL support in Windows requires building the gem's
+              # native extensions against OpenSSL and that proved to be a process
+              # so tedious that expecting users to do it is a non-starter.
+              Jekyll.logger.abort_with "Error:", "LiveReload does not support SSL"
+            end
+            unless opts["watch"]
+              # Using livereload logically implies you want to watch the files
+              opts["watch"] = true
+            end
+          elsif %w(livereload_min_delay
+                   livereload_max_delay
+                   livereload_ignore
+                   livereload_port).any? { |o| opts[o] }
+            Jekyll.logger.abort_with "--livereload-min-delay, "\
+               "--livereload-max-delay, --livereload-ignore, and "\
+               "--livereload-port require the --livereload option."
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def register_reload_hooks(opts)
+          require_relative "serve/live_reload_reactor"
+          @reload_reactor = LiveReloadReactor.new
+
+          Jekyll::Hooks.register(:site, :post_render) do |site|
+            regenerator = Jekyll::Regenerator.new(site)
+            @changed_pages = site.pages.select do |p|
+              regenerator.regenerate?(p)
+            end
+          end
+
+          # A note on ignoring files: LiveReload errs on the side of reloading when it
+          # comes to the message it gets.  If, for example, a page is ignored but a CSS
+          # file linked in the page isn't, the page will still be reloaded if the CSS
+          # file is contained in the message sent to LiveReload.  Additionally, the
+          # path matching is very loose so that a message to reload "/" will always
+          # lead the page to reload since every page starts with "/".
+          Jekyll::Hooks.register(:site, :post_write) do
+            if @changed_pages && @reload_reactor && @reload_reactor.running?
+              ignore, @changed_pages = @changed_pages.partition do |p|
+                Array(opts["livereload_ignore"]).any? do |filter|
+                  File.fnmatch(filter, Jekyll.sanitized_path(p.relative_path))
+                end
+              end
+              Jekyll.logger.debug "LiveReload:", "Ignoring #{ignore.map(&:relative_path)}"
+              @reload_reactor.reload(@changed_pages)
+            end
+            @changed_pages = nil
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # 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 = {
+            :JekyllOptions      => 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[:JekyllOptions]["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)
+
+          Jekyll.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?
+
+          Jekyll.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)
+            Jekyll.logger.info "Server detached with pid '#{pid}'.", \
+                               "Run `pkill -f jekyll' 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[:JekyllOptions]["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[:JekyllOptions].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))
+          opts[:SSLPrivateKey]  = OpenSSL::PKey::RSA.new(read_file(src, key))
+          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
+                Jekyll.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(Jekyll.sanitized_path(source_dir, file_path))
+        end
+      end
+    end
+  end
+end