nanoc 4.11.12 → 4.11.13

data/lib/nanoc/cli/ansi_string_colorizer.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::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

data/lib/nanoc/cli/cleaning_stream.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::CLI
-  # An output stream that passes output through stream cleaners. This can be
-  # used to strip ANSI color sequences, for instance.
-  #
-  # @api private
-  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

data/lib/nanoc/cli/command_runner.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::CLI
-  # A command runner subclass for Nanoc commands that adds Nanoc-specific
-  # convenience methods and error handling.
-  #
-  # @api private
-  class CommandRunner < ::Cri::CommandRunner
-    # @see http://rubydoc.info/gems/cri/Cri/CommandRunner#call-instance_method
-    #
-    # @return [void]
-    def call
-      Nanoc::CLI::ErrorHandler.handle_while do
-        run
-      end
-    end
-
-    # @return [Boolean] true if the current working directory is a Nanoc site
-    #   directory, false otherwise
-    def in_site_dir?
-      Nanoc::Int::SiteLoader.cwd_is_nanoc_site?
-    end
-
-    def self.find_site_dir
-      start_here = Dir.pwd
-
-      here = start_here
-      until Nanoc::Int::SiteLoader.cwd_is_nanoc_site?
-        Dir.chdir('..')
-        return nil if Dir.pwd == here
-
-        here = Dir.pwd
-      end
-      here
-    ensure
-      Dir.chdir(start_here)
-    end
-
-    def self.enter_site_dir
-      dir = find_site_dir
-      if dir.nil?
-        raise ::Nanoc::Int::Errors::GenericTrivial, 'The current working directory, nor any of its parents, seems to be a Nanoc site.'
-      end
-
-      return if Dir.getwd == dir
-
-      $stderr.puts "Using Nanoc site in #{dir}"
-      Dir.chdir(dir)
-    end
-
-    # Asserts that the current working directory contains a site and loads the site into memory.
-    #
-    # @return [void]
-    def load_site
-      self.class.enter_site_dir
-
-      $stderr.print 'Loading site… '
-      $stderr.flush
-      site = Nanoc::Int::SiteLoader.new.new_from_cwd
-
-      $stderr.puts 'done'
-      site
-    end
-
-    # @return [Boolean] true if debug output is enabled, false if not
-    #
-    # @see Nanoc::CLI.debug?
-    def debug?
-      Nanoc::CLI.debug?
-    end
-  end
-end

data/lib/nanoc/cli/commands/compile.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-usage 'compile [options]'
-summary 'compile items of this site'
-description <<~EOS
-  Compile all items of the current site.
-EOS
-no_params
-
-flag nil, :diff, 'generate diff'
-if Nanoc::Feature.enabled?(Nanoc::Feature::LIVE_CMD)
-  flag :w, :watch, 'watch for changes and recompile when needed'
-end
-
-module Nanoc::CLI::Commands
-  class Compile < ::Nanoc::CLI::CommandRunner
-    attr_accessor :listener_classes
-
-    def run
-      self.class.enter_site_dir
-
-      if options[:watch]
-        run_repeat
-      else
-        run_once
-      end
-    end
-
-    def run_repeat
-      require 'nanoc/live'
-      Nanoc::Live::LiveRecompiler.new(command_runner: self).run
-    end
-
-    def run_once
-      time_before = Time.now
-
-      @site = load_site
-
-      puts 'Compiling site…'
-      compiler = Nanoc::Int::Compiler.new_for(@site)
-      listener = Nanoc::CLI::Commands::CompileListeners::Aggregate.new(
-        command_runner: self,
-        site: @site,
-        compiler: compiler,
-      )
-      listener.run_while do
-        compiler.run_until_end
-      end
-
-      time_after = Time.now
-      puts
-      puts "Site compiled in #{format('%.2f', time_after - time_before)}s."
-    end
-  end
-end
-
-runner Nanoc::CLI::Commands::Compile

data/lib/nanoc/cli/commands/compile_listeners/abstract.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::CLI::Commands::CompileListeners
-  class Abstract
-    def initialize(*)
-      super()
-    end
-
-    def self.enable_for?(command_runner, site) # rubocop:disable Lint/UnusedMethodArgument
-      true
-    end
-
-    # @abstract
-    def start
-      raise NotImplementedError, "Subclasses of #{self.class} must implement #start"
-    end
-
-    # @abstract
-    def stop; end
-
-    def wrapped_start
-      @_notification_names = []
-      start
-    end
-
-    def wrapped_stop
-      stop
-
-      Nanoc::Core::NotificationCenter.sync
-
-      @_notification_names.each do |name|
-        Nanoc::Core::NotificationCenter.remove(name, self)
-      end
-    end
-
-    def run_while
-      wrapped_start
-      yield
-    ensure
-      wrapped_stop
-    end
-
-    def start_safely
-      wrapped_start
-      @_started = true
-    end
-
-    def stop_safely
-      wrapped_stop if @_started
-      @_started = false
-    end
-
-    def on(sym)
-      @_notification_names << sym
-      Nanoc::Core::NotificationCenter.on(sym, self) { |*args| yield(*args) }
-    end
-  end
-end

data/lib/nanoc/cli/commands/compile_listeners/aggregate.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::CLI::Commands::CompileListeners
-  class Aggregate < Abstract
-    def initialize(command_runner:, site:, compiler:)
-      @site = site
-      @compiler = compiler
-      @command_runner = command_runner
-
-      @listener_classes = self.class.default_listener_classes
-    end
-
-    def start
-      setup_listeners
-    end
-
-    def stop
-      teardown_listeners
-    end
-
-    def self.default_listener_classes
-      [
-        Nanoc::CLI::Commands::CompileListeners::DiffGenerator,
-        Nanoc::CLI::Commands::CompileListeners::DebugPrinter,
-        Nanoc::CLI::Commands::CompileListeners::TimingRecorder,
-        Nanoc::CLI::Commands::CompileListeners::FileActionPrinter,
-      ]
-    end
-
-    protected
-
-    def setup_listeners
-      res = @compiler.run_until_reps_built
-      reps = res.fetch(:reps)
-
-      @listeners =
-        @listener_classes
-        .select { |klass| klass.enable_for?(@command_runner, @site) }
-        .map    { |klass| klass.new(reps: reps) }
-
-      @listeners.each(&:start_safely)
-    end
-
-    def teardown_listeners
-      return unless @listeners
-
-      @listeners.reverse_each(&:stop_safely)
-    end
-  end
-end

data/lib/nanoc/cli/commands/compile_listeners/debug_printer.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::CLI::Commands::CompileListeners
-  class DebugPrinter < Abstract
-    # @see Listener#enable_for?
-    def self.enable_for?(command_runner, _site)
-      command_runner.debug?
-    end
-
-    COLOR_MAP = {
-      'compilation' => "\e[31m",
-      'content' => "\e[32m",
-      'filtering' => "\e[33m",
-      'dependency_tracking' => "\e[34m",
-      'phase' => "\e[35m",
-      'stage' => "\e[36m",
-    }.freeze
-
-    # @see Listener#start
-    def start
-      on(:compilation_started) do |rep|
-        log('compilation', "Started compilation of #{rep}")
-      end
-
-      on(:compilation_ended) do |rep|
-        log('compilation', "Ended compilation of #{rep}")
-        log('compilation', '')
-      end
-
-      on(:compilation_suspended) do |rep, target_rep, snapshot_name|
-        log('compilation', "Suspended compilation of #{rep}: depends on #{target_rep}, snapshot #{snapshot_name}")
-      end
-
-      on(:cached_content_used) do |rep|
-        log('content', "Used cached compiled content for #{rep} instead of recompiling")
-      end
-
-      on(:snapshot_created) do |rep, snapshot_name|
-        log('content', "Snapshot #{snapshot_name} created for #{rep}")
-      end
-
-      on(:filtering_started) do |rep, filter_name|
-        log('filtering', "Started filtering #{rep} with #{filter_name}")
-      end
-
-      on(:filtering_ended) do |rep, filter_name|
-        log('filtering', "Ended filtering #{rep} with #{filter_name}")
-      end
-
-      on(:dependency_created) do |src, dst|
-        log('dependency_tracking', "Dependency created from #{src.inspect} onto #{dst.inspect}")
-      end
-
-      on(:phase_started) do |phase_name, rep|
-        log('phase', "Phase started: #{phase_name} (rep: #{rep})")
-      end
-
-      on(:phase_yielded) do |phase_name, rep|
-        log('phase', "Phase yielded: #{phase_name} (rep: #{rep})")
-      end
-
-      on(:phase_resumed) do |phase_name, rep|
-        log('phase', "Phase resumed: #{phase_name} (rep: #{rep})")
-      end
-
-      on(:phase_ended) do |phase_name, rep|
-        log('phase', "Phase ended: #{phase_name} (rep: #{rep})")
-      end
-
-      on(:phase_aborted) do |phase_name, rep|
-        log('phase', "Phase aborted: #{phase_name} (rep: #{rep})")
-      end
-
-      on(:stage_started) do |stage_name|
-        log('stage', "Stage started: #{stage_name}")
-      end
-
-      on(:stage_ended) do |stage_name|
-        log('stage', "Stage ended: #{stage_name}")
-      end
-
-      on(:stage_aborted) do |stage_name|
-        log('stage', "Stage aborted: #{stage_name}")
-      end
-    end
-
-    def log(progname, msg)
-      logger.info(progname) { msg }
-    end
-
-    def logger
-      @_logger ||=
-        Logger.new($stdout).tap do |l|
-          l.formatter = proc do |_severity, _datetime, progname, msg|
-            "*** #{COLOR_MAP[progname]}#{msg}\e[0m\n"
-          end
-        end
-    end
-  end
-end