nanoc-cli 4.11.13

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+usage 'shell'
+summary 'open a shell on the Nanoc environment'
+aliases 'console', 'sh'
+description "
+Open an IRB shell on a context that contains @items, @layouts, and @config.
+"
+flag :p, :preprocess, 'run preprocessor'
+no_params
+
+module Nanoc::CLI::Commands
+  class Shell < ::Nanoc::CLI::CommandRunner
+    def run
+      require 'pry'
+
+      # Needed to make pry behave properly sometimes -- see nanoc/nanoc#1309
+      Signal.trap('SIGINT') { raise Interrupt }
+
+      @site = load_site
+      Nanoc::Core::Compiler.new_for(@site).run_until_preprocessed if options[:preprocess]
+
+      Nanoc::Core::Context.new(env).pry
+    end
+
+    def env
+      self.class.env_for_site(@site)
+    end
+
+    def self.reps_for(site)
+      Nanoc::Core::ItemRepRepo.new.tap do |reps|
+        action_provider = Nanoc::Core::ActionProvider.named(site.config.action_provider).for(site)
+        builder = Nanoc::Core::ItemRepBuilder.new(site, action_provider, reps)
+        builder.run
+      end
+    end
+
+    def self.view_context_for(site)
+      Nanoc::Core::ViewContextForShell.new(
+        items: site.items,
+        reps: reps_for(site),
+      )
+    end
+
+    def self.env_for_site(site)
+      view_context = view_context_for(site)
+
+      {
+        items: Nanoc::Core::ItemCollectionWithRepsView.new(site.items, view_context),
+        layouts: Nanoc::Core::LayoutCollectionView.new(site.layouts, view_context),
+        config: Nanoc::Core::ConfigView.new(site.config, view_context),
+      }
+    end
+  end
+end
+
+runner Nanoc::CLI::Commands::Shell

data/lib/nanoc/cli/commands/show-data.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+usage 'show-data'
+aliases :debug
+summary 'show data in this site'
+description <<~EOS
+  Show information about all items, item representations and layouts in the
+  current site, along with dependency information.
+EOS
+no_params
+
+module Nanoc::CLI::Commands
+  class ShowData < ::Nanoc::CLI::CommandRunner
+    def run
+      site = load_site
+      res = Nanoc::Core::Compiler.new_for(site).run_until_precompiled
+
+      items                = site.items
+      layouts              = site.layouts
+      reps                 = res.fetch(:reps)
+      dependency_store     = res.fetch(:dependency_store)
+      outdatedness_checker = res.fetch(:outdatedness_checker)
+
+      # Print data
+      print_item_dependencies(items, dependency_store)
+      print_item_rep_paths(items, reps)
+      print_item_rep_outdatedness(items, outdatedness_checker, reps)
+      print_layouts(layouts, outdatedness_checker)
+    end
+
+    protected
+
+    def sorted_with_prev(objects)
+      prev = nil
+      objects.sort_by(&:identifier).each do |object|
+        yield(object, prev)
+        prev = object
+      end
+    end
+
+    def sorted_reps_with_prev(items, reps)
+      prev = nil
+      items.sort_by(&:identifier).each do |item|
+        reps[item].sort_by { |r| r.name.to_s }.each do |rep|
+          yield(rep, prev)
+          prev = rep
+        end
+      end
+    end
+
+    def print_header(title)
+      header = '=' * 78
+      header[3..(title.length + 5)] = " #{title} "
+
+      puts
+      puts header
+      puts
+    end
+
+    def print_item_dependencies(items, dependency_store)
+      print_header('Item dependencies')
+
+      puts 'Legend:'
+      puts '  r = dependency on raw content'
+      puts '  a = dependency on attributes'
+      puts '  c = dependency on compiled content'
+      puts '  p = dependency on the path'
+      puts
+
+      sorter =
+        lambda do |dep|
+          case dep
+          when Nanoc::Core::Document
+            dep.from.identifier.to_s
+          else
+            ''
+          end
+        end
+
+      sorted_with_prev(items) do |item, prev|
+        puts if prev
+        puts "item #{item.identifier} depends on:"
+        dependencies =
+          dependency_store
+          .dependencies_causing_outdatedness_of(item)
+          .sort_by(&sorter)
+        dependencies.each do |dep|
+          pred = dep.from
+
+          type =
+            case pred
+            when Nanoc::Core::Layout
+              'layout'
+            when Nanoc::Core::Item
+              'item'
+            when Nanoc::Core::Configuration
+              'config'
+            when Nanoc::Core::ItemCollection
+              'items'
+            when Nanoc::Core::LayoutCollection
+              'layouts'
+            else
+              raise Nanoc::Core::Errors::InternalInconsistency, "unexpected pred type #{pred}"
+            end
+
+          pred_identifier =
+            case pred
+            when Nanoc::Core::Document
+              pred.identifier.to_s
+            when Nanoc::Core::Configuration
+              nil
+            when Nanoc::Core::IdentifiableCollection
+              case dep.props.raw_content
+              when true
+                'matching any'
+              else
+                "matching any of #{dep.props.raw_content.sort.join(', ')}"
+              end
+            else
+              raise Nanoc::Core::Errors::InternalInconsistency, "unexpected pred type #{pred}"
+            end
+
+          if pred
+            puts "  [ #{format '%6s', type} ] (#{dep.props}) #{pred_identifier}"
+          else
+            puts '  ( removed item )'
+          end
+        end
+        puts '  (nothing)' if dependencies.empty?
+      end
+    end
+
+    def print_item_rep_paths(items, reps)
+      print_header('Item representation paths')
+
+      sorted_reps_with_prev(items, reps) do |rep, prev|
+        puts if prev
+        puts "item #{rep.item.identifier}, rep #{rep.name}:"
+        if rep.raw_paths.empty?
+          puts '  (not written)'
+        end
+        length = rep.raw_paths.keys.map { |s| s.to_s.length }.max
+        rep.raw_paths.each do |snapshot_name, raw_paths|
+          raw_paths.each do |raw_path|
+            puts format("  [ %-#{length}s ] %s", snapshot_name, raw_path)
+          end
+        end
+      end
+    end
+
+    def print_item_rep_outdatedness(items, outdatedness_checker, reps)
+      print_header('Item representation outdatedness')
+
+      sorted_reps_with_prev(items, reps) do |rep, prev|
+        puts if prev
+        puts "item #{rep.item.identifier}, rep #{rep.name}:"
+        print_outdatedness_reasons_for(rep, outdatedness_checker)
+      end
+    end
+
+    def print_layouts(layouts, outdatedness_checker)
+      print_header('Layouts')
+
+      sorted_with_prev(layouts) do |layout, prev|
+        puts if prev
+        puts "layout #{layout.identifier}:"
+        print_outdatedness_reasons_for(layout, outdatedness_checker)
+      end
+    end
+
+    def print_outdatedness_reasons_for(obj, outdatedness_checker)
+      reasons = outdatedness_checker.outdatedness_reasons_for(obj)
+      if reasons.any?
+        puts '  is outdated:'
+        reasons.each do |reason|
+          puts "    - #{reason.message}"
+        end
+      else
+        puts '  is not outdated'
+      end
+    end
+  end
+end
+
+runner Nanoc::CLI::Commands::ShowData

data/lib/nanoc/cli/commands/show-plugins.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+summary 'show all available plugins'
+aliases :info
+usage 'show-plugins [options]'
+description <<~EOS
+  Show a list of available plugins, including filters and data sources.
+  If the current directory contains a Nanoc web site, the plugins defined in this site will be shown as well.
+EOS
+no_params
+
+module Nanoc::CLI::Commands
+  class ShowPlugins < ::Nanoc::CLI::CommandRunner
+    # rubocop:disable Style/MutableConstant
+    # These constants are intended to be mutated (through #add_plugin_class)
+
+    PLUGIN_CLASS_ORDER = [
+      Nanoc::Core::Filter,
+      Nanoc::Core::DataSource,
+    ]
+
+    PLUGIN_CLASSES = {
+      Nanoc::Core::Filter => 'Filters',
+      Nanoc::Core::DataSource => 'Data Sources',
+    }
+
+    # rubocop:enable Style/MutableConstant
+
+    def run
+      # Get list of plugins (before and after)
+      plugins_before = PLUGIN_CLASSES.keys.each_with_object({}) { |c, acc| acc[c] = c.all }
+      site = load_site
+      site&.code_snippets
+      plugins_after = PLUGIN_CLASSES.keys.each_with_object({}) { |c, acc| acc[c] = c.all }
+
+      # Divide list of plugins into builtin and custom
+      plugins_builtin = plugins_before
+      plugins_custom  = plugins_after.each_with_object({}) do |(superclass, klasses), acc|
+        acc[superclass] = klasses - plugins_before[superclass]
+      end
+
+      # Find max identifiers length
+      all_identifiers = plugins_after.values.flatten.map(&:identifiers)
+      max_identifiers_length = all_identifiers.map(&:to_s).map(&:size).max
+
+      PLUGIN_CLASS_ORDER.each do |superclass|
+        plugins_with_this_superclass = {
+          builtin: plugins_builtin.fetch(superclass, []),
+          custom: plugins_custom.fetch(superclass, []),
+        }
+
+        # Print kind
+        kind = name_for_plugin_class(superclass)
+        puts "#{kind}:"
+        puts
+
+        # Print plugins organised by subtype
+        %i[builtin custom].each do |type|
+          # Find relevant plugins
+          relevant_plugins = plugins_with_this_superclass[type]
+
+          # Print type
+          puts "  #{type}:"
+          if relevant_plugins.empty?
+            puts '    (none)'
+            next
+          end
+
+          # Print plugins
+          relevant_plugins.sort_by { |k| k.identifiers.join(', ') }.each do |plugin|
+            # Display
+            puts format(
+              "    %-#{max_identifiers_length}s (%s)",
+              plugin.identifiers.join(', '),
+              plugin.to_s.sub(/^::/, ''),
+            )
+          end
+        end
+
+        puts
+      end
+    end
+
+    def self.add_plugin_class(klass, name)
+      PLUGIN_CLASS_ORDER << klass
+      PLUGIN_CLASSES[klass] = name
+    end
+
+    private
+
+    def name_for_plugin_class(klass)
+      PLUGIN_CLASSES[klass.to_s]
+    end
+  end
+end
+
+runner Nanoc::CLI::Commands::ShowPlugins

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+usage 'view [options]'
+summary 'start the web server that serves static files'
+description <<~EOS
+  Start the static web server. Unless specified, the web server will run on port
+  3000 and listen on all IP addresses. Running this static web server requires
+  `adsf` (not `asdf`!).
+EOS
+
+required :H, :handler, 'specify the handler to use (webrick/mongrel/...)'
+required :o, :host,    'specify the host to listen on (default: 127.0.0.1)', default: '127.0.0.1'
+required :p, :port,    'specify the port to listen on (default: 3000)', transform: Nanoc::CLI::Transform::Port, default: 3000
+flag :L, :'live-reload', 'reload on changes'
+no_params
+
+module Nanoc::CLI::Commands
+  class View < ::Nanoc::CLI::CommandRunner
+    DEFAULT_HANDLER_NAME = :thin
+
+    def run
+      load_adsf
+
+      config = Nanoc::Core::ConfigLoader.new.new_from_cwd
+
+      # Create output dir so that viewer/watcher doesn’t explode.
+      FileUtils.mkdir_p(config.output_dir)
+
+      server =
+        Adsf::Server.new(
+          root: File.absolute_path(config.output_dir),
+          live: options[:'live-reload'],
+          index_filenames: config[:index_filenames],
+          host: options[:host],
+          port: options[:port],
+          handler: options[:handler],
+        )
+
+      server.run
+    end
+
+    protected
+
+    def load_adsf
+      # Load adsf
+      begin
+        require 'adsf'
+        return
+      rescue LoadError
+        $stderr.puts "Could not find the required 'adsf' gem, " \
+          'which is necessary for the view command.'
+      end
+
+      # Check asdf
+      begin
+        require 'asdf'
+        $stderr.puts "You appear to have 'asdf' installed, " \
+          "but not 'adsf'. Please install 'adsf' (check the spelling)!"
+      rescue LoadError
+      end
+
+      # Done
+      exit 1
+    end
+  end
+end
+
+runner Nanoc::CLI::Commands::View

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

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