nanoc-cli 4.11.13

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6614fdc62f969231b662ed63c693f5c2e28185ab2e139cab3fb1e88b46f4707c
+  data.tar.gz: 3e55bbea5197f43f0e09afcb908fc438f283a2cd5fd4a23a52ef8020a31f1d37
+SHA512:
+  metadata.gz: 0f57b9258cc0639792f33863e56785778bc6c1750b86aeab3d1131547e912799304ce8875a1bb0fa6069eab8a1bb80a2ff2377220c780d4f95a7b44f103cd71b
+  data.tar.gz: 6778aefc198872092095f5b9da16454a333f1f516919eb53349671339d84ad280a95e9ee460ed2505f55c6a6d84b6297d6b3fe6d5ffb903de8ae680c8d3c9083

data/NEWS.md

@@ -0,0 +1,3 @@
+# nanoc-cli news
+
+TODO

data/README.md

@@ -0,0 +1,3 @@
+# nanoc-cli
+
+TODO

data/lib/nanoc-cli.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'nanoc/cli'

data/lib/nanoc/cli.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require 'nanoc/core'
+require 'diff/lcs'
+require 'diff/lcs/hunk'
+require 'logger'
+
+begin
+  require 'cri'
+rescue LoadError => e
+  $stderr.puts e
+  $stderr.puts "If you are using a Gemfile, make sure that the Gemfile contains Nanoc ('gem \"nanoc\"')."
+  exit 1
+end
+
+module Nanoc
+  # @api private
+  module CLI
+    # @return [Boolean] true if debug output is enabled, false if not
+    def self.debug?
+      @debug || false
+    end
+
+    # @param [Boolean] boolean true if debug output should be enabled,
+    #   false if it should not
+    #
+    # @return [void]
+    def self.debug=(boolean)
+      @debug = boolean
+    end
+
+    def self.verbosity
+      @verbosity || 0
+    end
+
+    def self.verbosity=(val)
+      @verbosity = val
+    end
+
+    # Wraps `$stdout` and `$stderr` in appropriate cleaning streams.
+    #
+    # @return [void]
+    def self.setup_cleaning_streams
+      $stdout = wrap_in_cleaning_stream($stdout)
+      $stderr = wrap_in_cleaning_stream($stderr)
+    end
+
+    # Wraps the given stream in a cleaning stream. The cleaning streams will
+    # have the proper stream cleaners configured.
+    #
+    # @param [IO] io The stream to wrap
+    #
+    # @return [::Nanoc::CLI::CleaningStream]
+    def self.wrap_in_cleaning_stream(io)
+      cio = ::Nanoc::CLI::CleaningStream.new(io)
+
+      unless enable_utf8?(io)
+        cio.add_stream_cleaner(Nanoc::CLI::StreamCleaners::UTF8)
+      end
+
+      unless enable_ansi_colors?(io)
+        cio.add_stream_cleaner(Nanoc::CLI::StreamCleaners::ANSIColors)
+      end
+
+      cio
+    end
+
+    # @return [Boolean] true if UTF-8 support is present, false if not
+    def self.enable_utf8?(io)
+      return true unless io.tty?
+
+      %w[LC_ALL LC_CTYPE LANG].any? { |e| ENV[e] =~ /UTF/i }
+    end
+
+    # @return [Boolean] true if color support is present, false if not
+    def self.enable_ansi_colors?(io)
+      io.tty? && !ENV.key?('NO_COLOR')
+    end
+
+    # Invokes the Nanoc command-line tool with the given arguments.
+    #
+    # @param [Array<String>] args An array of command-line arguments
+    #
+    # @return [void]
+    def self.run(args)
+      Nanoc::CLI::ErrorHandler.handle_while do
+        setup
+        root_command.run(args)
+      end
+    end
+
+    # @return [Cri::Command] The root command, i.e. the command-line tool itself
+    def self.root_command
+      @root_command
+    end
+
+    # Adds the given command to the collection of available commands.
+    #
+    # @param [Cri::Command] cmd The command to add
+    #
+    # @return [void]
+    def self.add_command(cmd)
+      root_command.add_command(cmd)
+    end
+
+    # Schedules the given block to be executed after the CLI has been set up.
+    #
+    # @return [void]
+    def self.after_setup(&block)
+      # TODO: decide what should happen if the CLI is already set up
+      add_after_setup_proc(block)
+    end
+
+    # Makes the command-line interface ready for use.
+    #
+    # @return [void]
+    def self.setup
+      Nanoc::CLI.setup_cleaning_streams
+      setup_commands
+      load_custom_commands
+      after_setup_procs.each(&:call)
+    end
+
+    # Sets up the root command and base subcommands.
+    #
+    # @return [void]
+    def self.setup_commands
+      # Reinit
+      @root_command = nil
+
+      # Add root command
+      filename = __dir__ + '/cli/commands/nanoc.rb'
+      @root_command = Cri::Command.load_file(filename, infer_name: true)
+
+      # Add help command
+      help_cmd = Cri::Command.new_basic_help
+      add_command(help_cmd)
+
+      # Add other commands
+      cmd_filenames = Dir[__dir__ + '/cli/commands/*.rb']
+      cmd_filenames.each do |cmd_filename|
+        basename = File.basename(cmd_filename, '.rb')
+
+        next if basename == 'nanoc'
+
+        cmd = Cri::Command.load_file(cmd_filename, infer_name: true)
+        add_command(cmd)
+      end
+
+      if defined?(Bundler)
+        # Discover external commands through Bundler
+        begin
+          Bundler.require(:nanoc)
+        rescue Bundler::GemfileNotFound
+          # When running Nanoc with Bundler being defined but
+          # no gemfile being present (rubygems automatically loads
+          # Bundler when executing from command line), don't crash.
+        end
+      end
+    end
+
+    # Loads site-specific commands.
+    #
+    # @return [void]
+    def self.load_custom_commands
+      if Nanoc::Core::SiteLoader.cwd_is_nanoc_site?
+        config = Nanoc::Core::ConfigLoader.new.new_from_cwd
+        config[:commands_dirs].each do |path|
+          load_commands_at(path)
+        end
+      end
+    end
+
+    def self.load_commands_at(path)
+      recursive_contents_of(path).each do |filename|
+        # Create command
+        command = Cri::Command.load_file(filename, infer_name: true)
+
+        # Get supercommand
+        pieces = filename.gsub(/^#{path}\/|\.rb$/, '').split('/')
+        pieces = pieces[0, pieces.size - 1] || []
+        root = Nanoc::CLI.root_command
+        supercommand = pieces.reduce(root) do |cmd, piece|
+          cmd.nil? ? nil : cmd.command_named(piece)
+        end
+
+        # Add to supercommand
+        if supercommand.nil?
+          raise "Cannot load command at #{filename} because its supercommand cannot be found"
+        end
+
+        supercommand.add_command(command)
+      end
+    end
+
+    # @return [Array] The directory contents
+    def self.recursive_contents_of(path)
+      return [] unless File.directory?(path)
+
+      files, dirs = *Dir[path + '/*'].sort.partition { |e| File.file?(e) }
+      dirs.each { |d| files.concat recursive_contents_of(d) }
+      files
+    end
+
+    def self.after_setup_procs
+      @after_setup_procs || []
+    end
+
+    def self.add_after_setup_proc(proc)
+      @after_setup_procs ||= []
+      @after_setup_procs << proc
+    end
+  end
+end
+
+inflector_class = Class.new(Zeitwerk::Inflector) do
+  def camelize(basename, abspath)
+    case basename
+    when 'version', 'cli', 'utf8'
+      basename.upcase
+    when 'ansi_colors'
+      'ANSIColors'
+    when 'ansi_string_colorizer'
+      'ANSIStringColorizer'
+    else
+      super
+    end
+  end
+end
+
+loader = Zeitwerk::Loader.new
+loader.inflector = inflector_class.new
+loader.push_dir(__dir__ + '/..')
+loader.ignore(__dir__ + '/../nanoc-cli.rb')
+loader.ignore(__dir__ + '/cli/commands')
+loader.setup
+loader.eager_load

data/lib/nanoc/cli/ansi_string_colorizer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module CLI
+    # A simple ANSI colorizer for strings. When given a string and a list of
+    # attributes, it returns a colorized string.
+    #
+    # @api private
+    module ANSIStringColorizer
+      # TODO: complete mapping
+      MAPPING = {
+        bold: "\e[1m",
+        red: "\e[31m",
+        green: "\e[32m",
+        yellow: "\e[33m",
+        blue: "\e[34m",
+      }.freeze
+
+      # @param [String] str The string to colorize
+      #
+      # @param [Array] attrs An array of attributes from `MAPPING` to colorize the
+      #   string with
+      #
+      # @return [String] A string colorized using the given attributes
+      def self.c(str, *attrs)
+        attrs.map { |a| MAPPING[a] }.join('') + str + "\e[0m"
+      end
+    end
+  end
+end

data/lib/nanoc/cli/cleaning_stream.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module CLI
+    # An output stream that passes output through stream cleaners. This can be
+    # used to strip ANSI color sequences, for instance.
+    class CleaningStream
+      # @param [IO, StringIO] stream The stream to wrap
+      def initialize(stream)
+        @stream = stream
+        @stream_cleaners = []
+      end
+
+      # Adds a stream cleaner for the given class to this cleaning stream. If the
+      # cleaning stream already has the given stream cleaner, nothing happens.
+      #
+      # @param [Nanoc::CLI::StreamCleaners::Abstract] klass The class of the
+      #   stream cleaner to add
+      #
+      # @return [void]
+      def add_stream_cleaner(klass)
+        unless @stream_cleaners.map(&:class).include?(klass)
+          @stream_cleaners << klass.new
+        end
+      end
+
+      # Removes the stream cleaner for the given class from this cleaning stream.
+      # If the cleaning stream does not have the given stream cleaner, nothing
+      # happens.
+      #
+      # @param [Nanoc::CLI::StreamCleaners::Abstract] klass The class of the
+      #   stream cleaner to add
+      #
+      # @return [void]
+      def remove_stream_cleaner(klass)
+        @stream_cleaners.delete_if { |c| c.class == klass }
+      end
+
+      # @group IO proxy methods
+
+      # @see IO#write
+      def write(str)
+        _nanoc_swallow_broken_pipe_errors_while do
+          @stream.write(_nanoc_clean(str))
+        end
+      end
+
+      # @see IO#<<
+      def <<(str)
+        _nanoc_swallow_broken_pipe_errors_while do
+          @stream.<<(_nanoc_clean(str))
+        end
+      end
+
+      # @see IO#tty?
+      def tty?
+        @cached_is_tty ||= @stream.tty?
+      end
+
+      # @see IO#isatty
+      def isatty
+        tty?
+      end
+
+      # @see IO#flush
+      def flush
+        _nanoc_swallow_broken_pipe_errors_while do
+          @stream.flush
+        end
+      end
+
+      # @see IO#tell
+      def tell
+        @stream.tell
+      end
+
+      # @see IO#print
+      def print(str)
+        _nanoc_swallow_broken_pipe_errors_while do
+          @stream.print(_nanoc_clean(str))
+        end
+      end
+
+      # @see IO#puts
+      def puts(*str)
+        _nanoc_swallow_broken_pipe_errors_while do
+          @stream.puts(*str.map { |ss| _nanoc_clean(ss) })
+        end
+      end
+
+      # @see StringIO#string
+      def string
+        @stream.string
+      end
+
+      # @see IO#reopen
+      def reopen(*args)
+        @stream.reopen(*args)
+      end
+
+      # @see IO#close
+      def close
+        @stream.close
+      end
+
+      # @see File#exist?
+      def exist?
+        @stream.exist?
+      end
+
+      # @see File.exists?
+      def exists?
+        @stream.exists?
+      end
+
+      # @see IO.winsize
+      def winsize
+        @stream.winsize
+      end
+
+      # @see IO.winsize=
+      def winsize=(arg)
+        @stream.winsize = arg
+      end
+
+      # @see IO.sync
+      def sync
+        @stream.sync
+      end
+
+      # @see IO.sync=
+      def sync=(arg)
+        @stream.sync = arg
+      end
+
+      # @see IO.sync=
+      def external_encoding
+        @stream.external_encoding
+      end
+
+      # @see ARGF.set_encoding
+      # rubocop:disable Naming/AccessorMethodName
+      def set_encoding(*args)
+        @stream.set_encoding(*args)
+      end
+      # rubocop:enable Naming/AccessorMethodName
+
+      protected
+
+      def _nanoc_clean(str)
+        @stream_cleaners.reduce(str.to_s.scrub) { |acc, elem| elem.clean(acc) }
+      end
+
+      def _nanoc_swallow_broken_pipe_errors_while
+        yield
+      rescue Errno::EPIPE
+      end
+    end
+  end
+end