guard 1.4.0 → 2.18.0

data/lib/guard/guardfile/generator.rb

@@ -0,0 +1,128 @@
+require "guard/ui"
+require "guard/plugin_util"
+
+# Add Pathname#binwrite to 1.9.3
+unless Pathname.instance_methods.include?(:binwrite)
+  class Pathname
+    def binwrite(*args)
+      IO.binwrite(to_s, *args)
+    end
+  end
+end
+
+module Guard
+  module Guardfile
+    # This class is responsible for generating the Guardfile and adding Guard'
+    # plugins' templates into it.
+    #
+    # @see Guard::CLI
+    #
+    class Generator
+      require "guard"
+      require "guard/ui"
+
+      INFO_TEMPLATE_ADDED =
+        "%s template added to Guardfile, feel free to edit it"
+
+      # The Guardfile template for `guard init`
+      GUARDFILE_TEMPLATE = File.expand_path(
+        "../../../guard/templates/Guardfile",
+        __FILE__
+      )
+
+      # The location of user defined templates
+      begin
+        HOME_TEMPLATES = Pathname.new("~/.guard/templates").expand_path
+      rescue ArgumentError
+        # home isn't defined.  Set to the root of the drive.  Trust that there
+        # won't be user defined templates there
+        HOME_TEMPLATES = Pathname.new("/").expand_path
+      end
+
+      class Error < RuntimeError
+      end
+
+      class NoSuchPlugin < Error
+        attr_reader :plugin_name, :class_name
+
+        def initialize(plugin_name)
+          @plugin_name = plugin_name
+          @class_name = plugin_name.delete("-").capitalize
+        end
+
+        def message
+          "Could not load 'guard/#{plugin_name}'"\
+          " or '~/.guard/templates/#{plugin_name}'"\
+          " or find class Guard::#{class_name}\n"
+        end
+      end
+
+      # Creates the initial Guardfile template when it does not
+      # already exist.
+      #
+      # @see Guard::CLI#init
+      #
+      def create_guardfile
+        path = Pathname.new("Guardfile").expand_path
+        if path.exist?
+          _ui(:error, "Guardfile already exists at #{path}")
+          abort
+        end
+
+        _ui(:info, "Writing new Guardfile to #{path}")
+        FileUtils.cp(GUARDFILE_TEMPLATE, path.to_s)
+      end
+
+      # Adds the Guardfile template of a Guard plugin to an existing Guardfile.
+      #
+      # @see Guard::CLI#init
+      #
+      # @param [String] plugin_name the name of the Guard plugin or template to
+      #   initialize
+      #
+      def initialize_template(plugin_name)
+        guardfile = Pathname.new("Guardfile")
+
+        plugin_util = PluginUtil.new(plugin_name)
+        # TODO: change to "valid?" method
+        plugin_class = plugin_util.plugin_class(fail_gracefully: true)
+        if plugin_class
+          begin
+            plugin_util.add_to_guardfile
+          rescue Errno::ENOENT => error
+            # TODO: refactor
+            template = plugin_class.template(plugin_util.plugin_location)
+            _ui(:error, "Found class #{plugin_class} but loading it's template"\
+              "failed: '#{template}'")
+            _ui(:error, "Error is: #{error}")
+            return
+          end
+          return
+        end
+
+        template_code = (HOME_TEMPLATES + plugin_name).read
+        guardfile.binwrite(format("\n%s\n", template_code), open_args: ["a"])
+
+        _ui(:info, format(INFO_TEMPLATE_ADDED, plugin_name))
+
+      rescue Errno::ENOENT
+        fail NoSuchPlugin, plugin_name.downcase
+      end
+
+      # Adds the templates of all installed Guard implementations to an
+      # existing Guardfile.
+      #
+      # @see Guard::CLI#init
+      #
+      def initialize_all_templates
+        PluginUtil.plugin_names.each { |g| initialize_template(g) }
+      end
+
+      private
+
+      def _ui(*args)
+        UI.send(*args)
+      end
+    end
+  end
+end

data/lib/guard/guardfile.rb

@@ -1,73 +1,37 @@
-module Guard
+require "guard/config"
 
-  # The Guardfile is responsible for generating the Guardfile
-  # and adding guards' template into it.
-  #
-  # @see Guard::CLI
-  #
-  class Guardfile
+if Guard::Config.new.strict?
+  abort "Error: Deprecated file #{__FILE__} is being used"
+else
+  require "guard/deprecated/guardfile"
 
-    require 'guard'
-    require 'guard/ui'
+  # TODO: remove this file in next major version
 
-    class << self
+  module Guard
+    unless Guard::Config.new.silence_deprecations?
+      UPGRADE_WIKI_URL =
+        "https://github.com/guard/guard/wiki/Upgrading-to-Guard-2.0"
 
-      # Creates the initial Guardfile template when it does not
-      # already exist.
-      #
-      # @see Guard::CLI.init
-      #
-      # @param [Hash] options The options for creating a Guardfile
-      # @option options [Boolean] :abort_on_existence Whether to abort or not when a Guardfile already exists
-      #
-      def create_guardfile(options = {})
-        if !File.exist?('Guardfile')
-          ::Guard::UI.info "Writing new Guardfile to #{ Dir.pwd }/Guardfile"
-          FileUtils.cp(GUARDFILE_TEMPLATE, 'Guardfile')
-        elsif options[:abort_on_existence]
-          ::Guard::UI.error "Guardfile already exists at #{ Dir.pwd }/Guardfile"
-          abort
-        end
-      end
+      STDERR.puts <<-EOS
+        (guard/guardfile.rb message)
 
-      # Adds the Guardfile template of a Guard implementation
-      # to an existing Guardfile.
-      #
-      # @see Guard::CLI.init
-      #
-      # @param [String] guard_name the name of the Guard or template to initialize
-      #
-      def initialize_template(guard_name)
-        guard_class = ::Guard.get_guard_class(guard_name, true)
+        You are including "guard/guardfile.rb", which has been deprecated
+        since 2013 ... and will be removed.
 
-        if guard_class
-          guard_class.init(guard_name)
-        elsif File.exist?(File.join(HOME_TEMPLATES, guard_name))
-          content  = File.read('Guardfile')
-          template = File.read(File.join(HOME_TEMPLATES, guard_name))
+        Migration is easy, see: #{UPGRADE_WIKI_URL}
 
-          File.open('Guardfile', 'wb') do |f|
-            f.puts(content)
-            f.puts('')
-            f.puts(template)
-          end
+        This file was included from:
+          #{caller[0..10] * "\n  >"}
 
-          ::Guard::UI.info "#{ guard_name } template added to Guardfile, feel free to edit it"
-        else
-          const_name = guard_name.downcase.gsub('-', '')
-          UI.error "Could not load 'guard/#{ guard_name.downcase }' or '~/.guard/templates/#{ guard_name.downcase }' or find class Guard::#{ const_name.capitalize }"
-        end
-      end
+        Sorry for the inconvenience and have a nice day!
 
-      # Adds the templates of all installed Guard implementations
-      # to an existing Guardfile.
-      #
-      # @see Guard::CLI.init
-      #
-      def initialize_all_templates
-        ::Guard.guard_gem_names.each { |g| initialize_template(g) }
-      end
+        (end of guard/guardfile.rb message)
 
+
+      EOS
+    end
+    module Guardfile
+      extend Deprecated::Guardfile::ClassMethods
     end
   end
 end

data/lib/guard/interactor.rb

@@ -1,277 +1,53 @@
-module Guard
+require "forwardable"
 
-  # The interactor triggers specific action from input
-  # read by a interactor implementation.
-  #
-  # Currently the following actions are implemented:
-  #
-  # - h, help          => Show help
-  # - e, exit,
-  #   q. quit          => Exit Guard
-  # - r, reload        => Reload Guard
-  # - p, pause         => Toggle file modification listener
-  # - n, notification  => Toggle notifications
-  # - s, show          => Show Guard plugin configuration
-  # - c, change        => Trigger a file change
-  # - <enter>          => Run all
-  #
-  # It's also possible to scope `reload` and `run all` actions to only a specified group or a guard.
-  #
-  # @example Reload backend group
-  #   backend reload
-  #   reload backend
-  #
-  # @example Reload rspec guard
-  #   spork reload
-  #   reload spork
-  #
-  # @example Run all jasmine specs
-  #   jasmine
-  #
-  # @abstract
-  #
+module Guard
   class Interactor
-
-    require 'guard'
-    require 'guard/ui'
-    require 'guard/dsl_describer'
-    require 'guard/notifier'
-    require 'guard/interactors/readline'
-    require 'guard/interactors/coolline'
-    require 'guard/interactors/simple'
-
-    ACTIONS = {
-      :help         => %w[help h],
-      :reload       => %w[reload r],
-      :stop         => %w[exit e quit q],
-      :pause        => %w[pause p],
-      :notification => %w[notification n],
-      :show         => %w[show s],
-      :change       => %w[change c]
-    }
-
-    # Set the interactor implementation
-    #
-    # @param [Symbol] interactor the name of the interactor
+    # Initializes the interactor. This configures
+    # Pry and creates some custom commands and aliases
+    # for Guard.
     #
-    def self.interactor=(interactor)
-      @interactor = interactor
-    end
+    def initialize(no_interaction = false)
+      @interactive = !no_interaction && self.class.enabled?
 
-    # Get an instance of the currently configured
-    # interactor implementation.
-    #
-    # @return [Interactor] an interactor implementation
-    #
-    def self.fabricate
-      case @interactor
-      when :coolline
-        ::Guard::CoollineInteractor.new if ::Guard::CoollineInteractor.available?
-      when :readline
-        ::Guard::ReadlineInteractor.new if ::Guard::ReadlineInteractor.available?
-      when :simple
-        ::Guard::SimpleInteractor.new
-      when :off
-        nil
-      else
-        auto_detect
-      end
-    end
-
-    # Tries to detect an optimal interactor for the
-    # current environment.
-    #
-    # It returns the Readline implementation when:
-    #
-    # * rb-readline is installed
-    # * The Ruby implementation is JRuby
-    # * The current OS is not Mac OS X
-    #
-    # Otherwise the plain gets interactor is returned.
-    #
-    # @return [Interactor] an interactor implementation
-    #
-    def self.auto_detect
-      [::Guard::CoollineInteractor, ::Guard::ReadlineInteractor, ::Guard::SimpleInteractor].detect do |interactor|
-        interactor.available?(true)
-      end.new
-    end
+      # TODO: only require the one used
+      require "guard/jobs/sleep"
+      require "guard/jobs/pry_wrapper"
 
-    # Template method for checking if the Interactor is
-    # available in the current environment?
-    #
-    # @param [Boolean] silent true if no error messages should be shown
-    # @return [Boolean] the availability status
-    #
-    def self.available?(silent = false)
-      true
+      job_klass = interactive? ? Jobs::PryWrapper : Jobs::Sleep
+      @idle_job = job_klass.new(self.class.options)
     end
 
-    # Start the line reader in its own thread.
-    #
-    def start
-      return if ENV['GUARD_ENV'] == 'test'
-
-      ::Guard::UI.debug 'Start interactor'
-      @thread = Thread.new { read_line } if !@thread || !@thread.alive?
+    def interactive?
+      @interactive
     end
 
-    # Kill interactor thread if not current
-    #
-    def stop
-      return if !@thread || ENV['GUARD_ENV'] == 'test'
+    extend Forwardable
+    delegate [:foreground, :background, :handle_interrupt] => :idle_job
 
-      ::Guard::UI.debug 'Stop interactor'
-      unless Thread.current == @thread
-        @thread.kill
+    # TODO: everything below is just so the DSL can set options
+    # before setup() is called, which makes it useless for when
+    # Guardfile is reevaluated
+    class << self
+      def options
+        @options ||= {}
       end
-    end
 
-    # Read the user input. This method must be implemented
-    # by each interactor implementation.
-    #
-    # @abstract
-    #
-    def read_line
-      raise NotImplementedError
-    end
-
-    # Process the input from readline.
-    #
-    # @param [String] line the input line
-    #
-    def process_input(line)
-      scopes, action, rest = extract_scopes_and_action(line)
+      # Pass options to interactor's job when it's created
+      attr_writer :options
 
-      case action
-      when :help
-        help
-      when :show
-        ::Guard::DslDescriber.show(::Guard.options)
-      when :stop
-        ::Guard.stop
-        exit
-      when :pause
-        ::Guard.pause
-      when :reload
-        ::Guard.reload(scopes)
-      when :change
-        ::Guard.within_preserved_state do
-          ::Guard.runner.run_on_changes(rest, [], [])
-        end
-      when :run_all
-        ::Guard.run_all(scopes)
-      when :notification
-        toggle_notification
-      else
-        ::Guard::UI.error "Unknown command #{ line }"
+      # TODO: allow custom user idle jobs, e.g. [:pry, :sleep, :exit, ...]
+      def enabled?
+        @enabled || @enabled.nil?
       end
-    end
 
-    # Toggle the system notifications on/off
-    #
-    def toggle_notification
-      if ENV['GUARD_NOTIFY'] == 'true'
-        ::Guard::UI.info 'Turn off notifications'
-        ::Guard::Notifier.turn_off
-      else
-        ::Guard::Notifier.turn_on
-      end
-    end
+      alias_method :enabled, :enabled?
 
-    # Show the help.
-    #
-    def help
-      puts ''
-      puts '[e]xit, [q]uit   Exit Guard'
-      puts '[p]ause          Toggle file modification listener'
-      puts '[r]eload         Reload Guard'
-      puts '[n]otification   Toggle notifications'
-      puts '[s]how           Show available Guard plugins'
-      puts '[c]hange <file>  Trigger a file change'
-      puts '<enter>          Run all Guard plugins'
-      puts ''
-      puts 'You can scope the reload action to a specific guard or group:'
-      puts ''
-      puts 'rspec reload     Reload the RSpec Guard'
-      puts 'backend reload   Reload the backend group'
-      puts ''
-      puts 'You can also run only a specific Guard or all Guard plugins in a specific group:'
-      puts ''
-      puts 'jasmine          Run the jasmine Guard'
-      puts 'frontend         Run all Guard plugins in the frontend group'
-      puts ''
-    end
-
-    # Extract the Guard or group scope and action from the
-    # input line. There's no strict order for scopes and
-    # actions.
-    #
-    # @example `spork reload` will only reload rspec
-    # @example `jasmine` will only run all jasmine specs
-    #
-    # @param [String] line the readline input
-    # @return [Array] the group or guard scope, the action and the rest
-    #
-    def extract_scopes_and_action(line)
-      entries = line.split(' ')
-
-      scopes = extract_scopes(entries)
-      action = extract_action(entries)
-
-      action = :run_all if !action && (!scopes.empty? || entries.empty?)
-
-      [scopes, action, entries]
+      # TODO: handle switching interactors during runtime?
+      attr_writer :enabled
     end
 
     private
 
-    # Extract a guard or group scope from entry if valid.
-    # Any entry found will be removed from the entries.
-    #
-    # @param [Array<String>] entries the user entries
-    # @return [Hash] a hash with a Guard or a group scope
-    #
-    def extract_scopes(entries)
-      scopes = { }
-
-      entries.delete_if do |entry|
-        if guard = ::Guard.guards(entry)
-          scopes[:guard] ||= guard
-          true
-
-        elsif group = ::Guard.groups(entry)
-          scopes[:group] ||= group
-          true
-
-        else
-          false
-        end
-      end
-
-      scopes
-    end
-
-    # Find the action for the given input entry.
-    # Any action found will be removed from the entries.
-    #
-    # @param [Array<String>] entries the user entries
-    # @return [Symbol] a Guard action
-    #
-    def extract_action(entries)
-      action = nil
-
-      entries.delete_if do |entry|
-        if command = ACTIONS.detect { |k, list| list.include?(entry) }
-          action ||= command.first
-          true
-        else
-          false
-        end
-      end
-
-      action
-    end
-
+    attr_reader :idle_job
   end
 end

data/lib/guard/internals/debugging.rb

@@ -0,0 +1,68 @@
+# Because it's used by Sheller
+require "open3"
+require "logger"
+
+require "guard/ui"
+
+require "guard/internals/tracing"
+
+module Guard
+  # @private api
+  module Internals
+    class Debugging
+      class << self
+        TRACES = [
+          [Kernel, :system],
+          [Kernel, :spawn],
+          [Kernel, :`],
+          [Open3, :popen3]
+        ]
+
+        # Sets up debugging:
+        #
+        # * aborts on thread exceptions
+        # * Set the logging level to `:debug`
+        # * traces execution of Kernel.system and backtick calls
+        def start
+          return if @started ||= false
+          @started = true
+
+          Thread.abort_on_exception = true
+
+          UI.level = Logger::DEBUG
+
+          TRACES.each { |mod, meth| _trace(mod, meth, &method(:_notify)) }
+          @traced = true
+        end
+
+        def stop
+          return unless @started ||= false
+          UI.level = Logger::INFO
+          _reset
+        end
+
+        private
+
+        def _notify(*args)
+          UI.debug "Command execution: #{args.join(' ')}"
+        end
+
+        # reset singleton - called by tests
+        def _reset
+          @started = false
+          return unless @traced
+          TRACES.each { |mod, meth| _untrace(mod, meth) }
+          @traced = false
+        end
+
+        def _trace(mod, meth, &block)
+          Tracing.trace(mod, meth, &block)
+        end
+
+        def _untrace(mod, meth)
+          Tracing.untrace(mod, meth)
+        end
+      end
+    end
+  end
+end

data/lib/guard/internals/groups.rb

@@ -0,0 +1,40 @@
+require "guard/group"
+
+module Guard
+  # @private api
+  module Internals
+    class Groups
+      DEFAULT_GROUPS = [:common, :default]
+
+      def initialize
+        @groups = DEFAULT_GROUPS.map { |name| Group.new(name) }
+      end
+
+      def all(filter = nil)
+        return @groups if filter.nil?
+        matcher = matcher_for(filter)
+        @groups.select { |group| matcher.call(group) }
+      end
+
+      def add(name, options = {})
+        all(name).first || Group.new(name, options).tap do |group|
+          fail if name == :specs && options.empty?
+          @groups << group
+        end
+      end
+
+      private
+
+      def matcher_for(filter)
+        case filter
+        when String, Symbol
+          ->(group) { group.name == filter.to_sym }
+        when Regexp
+          ->(group) { group.name.to_s =~ filter }
+        else
+          fail "Invalid filter: #{filter.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/guard/internals/helpers.rb

@@ -0,0 +1,13 @@
+module Guard
+  # @private api
+  module Internals
+    module Helpers
+      def _relative_pathname(path)
+        full_path = Pathname(path)
+        full_path.relative_path_from(Pathname.pwd)
+      rescue ArgumentError
+        full_path
+      end
+    end
+  end
+end