nanoc 3.2.4 → 3.3.0

data/lib/nanoc/base/store.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+
+module Nanoc
+
+  # An abstract superclass for classes that need to store data to the
+  # filesystem, such as checksums, cached compiled content and dependency
+  # graphs.
+  #
+  # Each store has a version number. When attempting to load data from a store
+  # that has an incompatible version number, no data will be loaded, but
+  # {#version_mismatch_detected} will be called.
+  #
+  # @abstract Subclasses must implement {#data} and {#data=}, and may
+  #   implement {#no_data_found} and {#version_mismatch_detected}.
+  #
+  # @api private
+  class Store
+
+    # @return [String] The name of the file where data will be loaded from and
+    #   stored to.
+    attr_reader :filename
+
+    # @return [Numeric] The version number corresponding to the file format
+    #   the data is in. When the file format changes, the version number
+    #   should be incremented.
+    attr_reader :version
+
+    # Creates a new store for the given filename.
+    #
+    # @param [String] filename The name of the file where data will be loaded
+    #   from and stored to.
+    #
+    # @param [Numeric] version The version number corresponding to the file
+    #   format the data is in. When the file format changes, the version
+    #   number should be incremented.
+    def initialize(filename, version)
+      @filename = filename
+      @version  = version
+    end
+
+    # @group Loading and storing data
+
+    # @return The data that should be written to the disk
+    #
+    # @abstract This method must be implemented by the subclass.
+    def data
+      raise NotImplementedError.new("Nanoc::Store subclasses must implement #data and #data=")
+    end
+
+    # @param new_data The data that has been loaded from the disk
+    #
+    # @abstract This method must be implemented by the subclass.
+    #
+    # @return [void]
+    def data=(new_data)
+      raise NotImplementedError.new("Nanoc::Store subclasses must implement #data and #data=")
+    end
+
+    # Loads the data from the filesystem into memory. This method will set the
+    #   loaded data using the {#data=} method.
+    #
+    # @return [void]
+    def load
+      # Don’t load twice
+      if @loaded
+        return
+      end
+
+      # Check file existance
+      if !File.file?(self.filename)
+        no_data_found
+        @loaded = true
+        return
+      end
+
+      pstore.transaction do
+        # Check version
+        if pstore[:version] != self.version
+          version_mismatch_detected
+          @loaded = true
+          return
+        end
+
+        # Load
+        self.data = pstore[:data]
+        @loaded = true
+      end
+    end
+
+    # Undoes the effects of {#load}. Used when {#load} raises an exception.
+    #
+    # @api private
+    def unload
+    end
+
+    # Stores the data contained in memory to the filesystem. This method will
+    #   use the {#data} method to fetch the data that should be written.
+    #
+    # @return [void]
+    def store
+      FileUtils.mkdir_p(File.dirname(self.filename))
+
+      pstore.transaction do
+        pstore[:data]    = self.data
+        pstore[:version] = self.version
+      end
+    end
+
+    # @group Callback methods
+
+    # Callback method that is called when no data file was found. By default,
+    # this implementation does nothing, but it should probably be overridden
+    # by the subclass.
+    #
+    # @return [void]
+    def no_data_found
+    end
+
+    # Callback method that is called when a version mismatch is detected. By
+    # default, this implementation does nothing, but it should probably be
+    # overridden by the subclass.
+    #
+    # @return [void]
+    def version_mismatch_detected
+    end
+
+  private
+
+    def pstore
+      @pstore ||= PStore.new(self.filename)
+    end
+
+  end
+
+end

data/lib/nanoc/cli.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+
+require 'cri'
+
+module Nanoc::CLI
+
+  module Commands
+  end
+
+  autoload 'Logger',             'nanoc/cli/logger'
+  autoload 'CommandRunner',      'nanoc/cli/command_runner'
+  autoload 'ErrorHandler',       'nanoc/cli/error_handler'
+
+  # Deprecated; use CommandRunner instead
+  # TODO [in nanoc 4.0] remove me
+  autoload 'Command',            'nanoc/cli/command_runner'
+
+  # @return [Boolean] true if debug output is enabled, false if not
+  #
+  # @since 3.2.0
+  def self.debug?
+    @debug || false
+  end
+
+  # @param [Boolean] boolean true if debug output should be enabled,
+  #   false if it should not
+  #
+  # @return [void]
+  #
+  # @since 3.2.0
+  def self.debug=(boolean)
+    @debug = boolean
+  end
+
+  # Invokes the nanoc commandline tool with the given arguments.
+  #
+  # @param [Array<String>] args An array of commandline arguments
+  #
+  # @return [void]
+  def self.run(args)
+    Nanoc::CLI::ErrorHandler.handle_while do
+      self.setup
+      self.load_custom_commands
+      self.root_command.run(args)
+    end
+  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)
+    self.root_command.add_command(cmd)
+  end
+
+protected
+
+  # Makes the commandline interface ready for using by loading the commands.
+  #
+  # @return [void]
+  def self.setup
+    # Reinit
+    @root_command = nil
+
+    # Add help command
+    help_cmd = Cri::Command.new_basic_help
+    self.add_command(help_cmd)
+
+    # Add other commands
+    cmd_filenames = Dir[File.dirname(__FILE__) + '/cli/commands/*.rb']
+    cmd_filenames.each do |filename|
+      next if File.basename(filename, '.rb') == 'nanoc'
+      cmd = self.load_command_at(filename)
+      self.add_command(cmd)
+    end
+  end
+
+  # Loads the commands in `commands/`.
+  #
+  # @return [void]
+  def self.load_custom_commands
+    self.recursive_contents_of('commands').each do |filename|
+      # Create command
+      command = Nanoc::CLI.load_command_at(filename)
+
+      # Get supercommand
+      pieces = filename.gsub(/^commands\/|\.rb$/, '').split('/')
+      pieces = pieces[0, pieces.size-1] || []
+      root = Nanoc::CLI.root_command
+      supercommand = pieces.inject(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
+
+  # Loads the command in the file with the given filename.
+  #
+  # @param [String] filename The name of the file that contains the command
+  #
+  # @return [Cri::Command] The loaded command
+  def self.load_command_at(filename, command_name=nil)
+    # Load
+    code = File.read(filename)
+    cmd = Cri::Command.define(code, filename)
+
+    # Set name
+    command_name ||= File.basename(filename, '.rb')
+    cmd.modify { name command_name }
+
+    # Done
+    cmd
+  end
+
+  # @return [Cri::Command] The root command, i.e. the commandline tool itself
+  def self.root_command
+    @root_command ||= begin
+      filename = File.dirname(__FILE__) + "/cli/commands/nanoc.rb"
+      self.load_command_at(filename)
+    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 self.recursive_contents_of(d) }
+    files
+  end
+
+end

data/lib/nanoc/cli/command_runner.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+module Nanoc::CLI
+
+  # A command runner subclass for nanoc commands that adds nanoc-specific
+  # convenience methods and error handling.
+  class CommandRunner < ::Cri::CommandRunner
+
+    # @see http://rubydoc.info/gems/cri/Cri/CommandRunner#call-instance_method
+    #
+    # @return [void]
+    def call
+      Nanoc::CLI::ErrorHandler.handle_while(:command => self) do
+        self.run
+      end
+    end
+
+    # Gets the site ({Nanoc::Site} instance) in the current directory and
+    # loads its data.
+    #
+    # @return [Nanoc::Site] The site in the current working directory
+    def site
+      # Load site if possible
+      @site ||= nil
+      if File.file?('config.yaml') && @site.nil?
+        begin
+          @site = Nanoc::Site.new('.')
+        rescue Nanoc::Errors::UnknownDataSource => e
+          $stderr.puts "Unknown data source: #{e}"
+          exit 1
+        end
+      end
+
+      @site
+    end
+
+    # @deprecated use `Cri::CommandDSL#runner`
+    #
+    # @see http://rubydoc.info/gems/cri/Cri/CommandDSL#runner-instance_method
+    def self.call(opts, args, cmd)
+      self.new(opts, args, cmd).call
+    end
+
+  protected
+
+    # @return [Boolean] true if debug output is enabled, false if not
+    #
+    # @see Nanoc::CLI.debug?
+    def debug?
+      Nanoc::CLI.debug?
+    end
+
+    # Asserts that the current working directory contains a site
+    # ({Nanoc::Site} instance). If no site is present, prints an error
+    # message and exits.
+    #
+    # @return [void]
+    def require_site
+      @site = nil
+      if site.nil?
+        $stderr.puts 'The current working directory does not seem to be a ' +
+                     'valid/complete nanoc site directory; aborting.'
+        exit 1
+      end
+    end
+
+    # Sets the data source's VCS to the VCS with the given name. Does nothing
+    # when the site's data source does not support VCSes (i.e. does not
+    # implement #vcs=).
+    #
+    # @param [String] vcs_name The name of the VCS that should be used
+    #
+    # @return [void]
+    def set_vcs(vcs_name)
+      # Skip if not possible
+      return if vcs_name.nil? || site.nil?
+
+      # Find VCS
+      vcs_class = Nanoc::Extra::VCS.named(vcs_name.to_sym)
+      if vcs_class.nil?
+        $stderr.puts "A VCS named #{vcs_name} was not found; aborting."
+        exit 1
+      end
+
+      site.data_sources.each do |data_source|
+        # Skip if not possible
+        next if !data_source.respond_to?(:vcs=)
+
+        # Set VCS
+        data_source.vcs = vcs_class.new
+      end
+    end
+
+    # @return [Array] The compilation stack.
+    def stack
+      (self.site && self.site.compiler.stack) || []
+    end
+
+  end
+
+  # @deprecated Use {Nanoc::CLI::CommandRunner} instead
+  Command = CommandRunner
+
+end

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+usage       'autocompile [options]'
+summary     'start the autocompiler'
+aliases     :aco
+description <<-EOS
+Start the autocompiler web server. Unless specified, the web server will run
+on port 3000 and listen on all IP addresses. Running the autocompiler requires
+the 'mime/types' and 'rack' gems.
+EOS
+
+required :H, :handler, 'specify the handler to use (webrick/mongrel/...)'
+required :o, :host,    'specify the host to listen on (default: 0.0.0.0)'
+required :p, :port,    'specify the port to listen on (default: 3000)'
+
+module Nanoc::CLI::Commands
+
+  class AutoCompile < ::Nanoc::CLI::CommandRunner
+
+    def run
+      require 'rack'
+
+      # Make sure we are in a nanoc site directory
+      self.require_site
+
+      # Set options
+      options_for_rack = {
+        :Port      => (options[:port] || 3000).to_i,
+        :Host      => (options[:host] || '0.0.0.0')
+      }
+
+      # Guess which handler we should use
+      unless handler = Rack::Handler.get(options[:handler])
+        begin
+          handler = Rack::Handler::Mongrel
+        rescue LoadError => e
+          handler = Rack::Handler::WEBrick
+        end
+      end
+
+      # Build app
+      autocompiler = Nanoc::Extra::AutoCompiler.new('.')
+      app = Rack::Builder.new do
+        use Rack::CommonLogger, $stderr
+        use Rack::ShowExceptions
+        run autocompiler
+      end.to_app
+
+      # Run autocompiler
+      puts "Running on http://#{options_for_rack[:Host]}:#{options_for_rack[:Port]}/"
+      handler.run(app, options_for_rack)
+    end
+
+  end
+
+end
+
+runner Nanoc::CLI::Commands::AutoCompile

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

@@ -0,0 +1,297 @@
+# encoding: utf-8
+
+usage       'compile [options]'
+summary     'compile items of this site'
+description <<-EOS
+Compile all items of the current site.
+
+The compile command will show all items of the site as they are processed. The time spent compiling the item will be printed, as well as a status message, which can be one of the following:
+
+CREATED - The compiled item did not yet exist and has been created
+
+UPDATED - The compiled item did already exist and has been modified
+
+IDENTICAL - The item was deemed outdated and has been recompiled, but the compiled version turned out to be identical to the already existing version
+
+SKIP - The item was deemed not outdated and was therefore not recompiled
+
+EOS
+
+option :a, :all,   '(ignored)'
+option :f, :force, '(ignored)'
+
+module Nanoc::CLI::Commands
+
+  class Compile < ::Nanoc::CLI::CommandRunner
+
+    def run
+      # Make sure we are in a nanoc site directory
+      puts "Loading site data..."
+      self.require_site
+
+      # Check presence of --all option
+      if options.has_key?(:all) || options.has_key?(:force)
+        $stderr.puts "Warning: the --force option (and its deprecated --all alias) are, as of nanoc 3.2, no longer supported and have no effect."
+      end
+
+      # Warn if trying to compile a single item
+      if arguments.size == 1
+        $stderr.puts '-' * 80
+        $stderr.puts 'Note: As of nanoc 3.2, it is no longer possible to compile a single item. When invoking the “compile” command, all items in the site will be compiled.'.make_compatible_with_env
+        $stderr.puts '-' * 80
+      end
+
+      # Give feedback
+      puts "Compiling site..."
+
+      # Initialize profiling stuff
+      time_before = Time.now
+      @rep_times     = {}
+      @filter_times  = {}
+      setup_notifications
+
+      # Prepare for generating diffs
+      setup_diffs
+
+      # Compile
+      self.site.compile
+
+      # Find reps
+      reps = self.site.items.map { |i| i.reps }.flatten
+
+      # Show skipped reps
+      reps.select { |r| !r.compiled? }.each do |rep|
+        rep.raw_paths.each do |snapshot_name, filename|
+          next if filename.nil?
+          duration = @rep_times[filename]
+          Nanoc::CLI::Logger.instance.file(:high, :skip, filename, duration)
+        end
+      end
+
+      # Stop diffing
+      teardown_diffs
+
+      # Prune
+      if self.site.config[:auto_prune]
+        Nanoc::Extra::Pruner.new(self.site).run
+      end
+
+      # Give general feedback
+      puts
+      puts "Site compiled in #{format('%.2f', Time.now - time_before)}s."
+
+      # Give detailed feedback
+      if options.has_key?(:verbose)
+        print_profiling_feedback(reps)
+      end
+    end
+
+    def setup_notifications
+      # Diff generation
+      require 'tempfile'
+      old_contents = {}
+      Nanoc::NotificationCenter.on(:will_write_rep) do |rep, snapshot|
+        path = rep.raw_path(:snapshot => snapshot)
+        old_contents[rep] = File.file?(path) ? File.read(path) : nil
+      end
+      Nanoc::NotificationCenter.on(:rep_written) do |rep, path, is_created, is_modified|
+        if !rep.binary? && self.site.config[:enable_output_diff]
+          new_contents = File.file?(path) ? File.read(path) : nil
+          if old_contents[rep] && new_contents
+            generate_diff_for(rep, old_contents[rep], new_contents)
+          end
+        end
+      end
+
+      # File notifications
+      Nanoc::NotificationCenter.on(:rep_written) do |rep, path, is_created, is_modified|
+        action = (is_created ? :create : (is_modified ? :update : :identical))
+        duration = Time.now - @rep_times[rep.raw_path] if @rep_times[rep.raw_path]
+        Nanoc::CLI::Logger.instance.file(:high, action, path, duration)
+      end
+
+      # Debug notifications
+      if self.debug?
+        Nanoc::NotificationCenter.on(:compilation_started) do |rep|
+          puts "*** Started compilation of #{rep.inspect}"
+        end
+        Nanoc::NotificationCenter.on(:compilation_ended) do |rep|
+          puts "*** Ended compilation of #{rep.inspect}"
+          puts
+        end
+        Nanoc::NotificationCenter.on(:compilation_failed) do |rep, e|
+          puts "*** Suspended compilation of #{rep.inspect}: #{e.message}"
+        end
+        Nanoc::NotificationCenter.on(:cached_content_used) do |rep|
+          puts "*** Used cached compiled content for #{rep.inspect} instead of recompiling"
+        end
+        Nanoc::NotificationCenter.on(:filtering_started) do |rep, filter_name|
+          puts "*** Started filtering #{rep.inspect} with #{filter_name}"
+        end
+        Nanoc::NotificationCenter.on(:filtering_ended) do |rep, filter_name|
+          puts "*** Ended filtering #{rep.inspect} with #{filter_name}"
+        end
+        Nanoc::NotificationCenter.on(:visit_started) do |item|
+          puts "*** Started visiting #{item.inspect}"
+        end
+        Nanoc::NotificationCenter.on(:visit_ended) do |item|
+          puts "*** Ended visiting #{item.inspect}"
+        end
+        Nanoc::NotificationCenter.on(:dependency_created) do |src, dst|
+          puts "*** Dependency created from #{src.inspect} onto #{dst.inspect}"
+        end
+      end
+
+      # Timing notifications
+      Nanoc::NotificationCenter.on(:compilation_started) do |rep|
+        @rep_times[rep.raw_path] = Time.now
+      end
+      Nanoc::NotificationCenter.on(:compilation_ended) do |rep|
+        @rep_times[rep.raw_path] = Time.now - @rep_times[rep.raw_path]
+      end
+      Nanoc::NotificationCenter.on(:filtering_started) do |rep, filter_name|
+        @filter_times[filter_name] ||= []
+        @filter_times[filter_name] << Time.now
+        start_filter_progress(rep, filter_name)
+      end
+      Nanoc::NotificationCenter.on(:filtering_ended) do |rep, filter_name|
+        @filter_times[filter_name] << Time.now - @filter_times[filter_name].pop
+        stop_filter_progress(rep, filter_name)
+      end
+    end
+
+    def setup_diffs
+      @diff_lock    = Mutex.new
+      @diff_threads = []
+      FileUtils.rm('output.diff') if File.file?('output.diff')
+    end
+
+    def teardown_diffs
+      @diff_threads.each { |t| t.join }
+    end
+
+    def generate_diff_for(rep, old_content, new_content)
+      return if old_content == new_content
+
+      @diff_threads << Thread.new do
+        # Generate diff
+        diff = diff_strings(old_content, new_content)
+        diff.sub!(/^--- .*/,    '--- ' + rep.raw_path)
+        diff.sub!(/^\+\+\+ .*/, '+++ ' + rep.raw_path)
+
+        # Write diff
+        @diff_lock.synchronize do
+          File.open('output.diff', 'a') { |io| io.write(diff) }
+        end
+      end
+    end
+
+    # TODO move this elsewhere
+    def diff_strings(a, b)
+      require 'open3'
+
+      # Create files
+      Tempfile.open('old') do |old_file|
+        Tempfile.open('new') do |new_file|
+          # Write files
+          old_file.write(a)
+          old_file.flush
+          new_file.write(b)
+          new_file.flush
+
+          # Diff
+          cmd = [ 'diff', '-u', old_file.path, new_file.path ]
+          Open3.popen3(*cmd) do |stdin, stdout, stderr|
+            result = stdout.read
+            return (result == '' ? nil : result)
+          end
+        end
+      end
+    rescue Errno::ENOENT
+      warn 'Failed to run `diff`, so no diff with the previously compiled ' \
+           'content will be available.'
+      nil
+    end
+
+    def start_filter_progress(rep, filter_name)
+      # Only show progress on terminals
+      return if !$stdout.tty?
+
+      @progress_thread = Thread.new do
+        delay = 1.0
+        step  = 0
+
+        text = "Running #{filter_name} filter… ".make_compatible_with_env
+
+        while !Thread.current[:stopped]
+          sleep 0.1
+
+          # Wait for a while before showing text
+          delay -= 0.1
+          next if delay > 0.05
+
+          # Print progress
+          $stdout.print text + %w( | / - \\ )[step] + "\r"
+          step = (step + 1) % 4
+        end
+
+        # Clear text
+        if delay < 0.05
+          $stdout.print ' ' * (text.length + 1 + 1) + "\r"
+        end
+      end
+    end
+
+    def stop_filter_progress(rep, filter_name)
+      # Only show progress on terminals
+      return if !$stdout.tty?
+
+      @progress_thread[:stopped] = true
+    end
+
+    def print_profiling_feedback(reps)
+      # Get max filter length
+      max_filter_name_length = @filter_times.keys.map { |k| k.to_s.size }.max
+      return if max_filter_name_length.nil?
+
+      # Print warning if necessary
+      if reps.any? { |r| !r.compiled? }
+        $stderr.puts
+        $stderr.puts "Warning: profiling information may not be accurate because " +
+                     "some items were not compiled."
+      end
+
+      # Print header
+      puts
+      puts ' ' * max_filter_name_length + ' | count    min    avg    max     tot'
+      puts '-' * max_filter_name_length + '-+-----------------------------------'
+
+      @filter_times.to_a.sort_by { |r| r[1] }.each do |row|
+        # Extract data
+        filter_name, samples = *row
+
+        # Calculate stats
+        count = samples.size
+        min   = samples.min
+        tot   = samples.inject { |memo, i| memo + i}
+        avg   = tot/count
+        max   = samples.max
+
+        # Format stats
+        count = format('%4d',   count)
+        min   = format('%4.2f', min)
+        avg   = format('%4.2f', avg)
+        max   = format('%4.2f', max)
+        tot   = format('%5.2f', tot)
+
+        # Output stats
+        filter_name = format("%#{max_filter_name_length}s", filter_name)
+        puts "#{filter_name} |  #{count}  #{min}s  #{avg}s  #{max}s  #{tot}s"
+      end
+    end
+
+  end
+
+end
+
+runner Nanoc::CLI::Commands::Compile