guard 1.4.0 → 2.18.0

data/lib/guard.rb

@@ -1,437 +1,169 @@
-require 'thread'
-require 'listen'
+require "thread"
+require "listen"
+
+require "guard/config"
+require "guard/deprecated/guard" unless Guard::Config.new.strict?
+require "guard/internals/helpers"
+
+require "guard/internals/debugging"
+require "guard/internals/traps"
+require "guard/internals/queue"
+
+# TODO: remove this class altogether
+require "guard/interactor"
 
 # Guard is the main module for all Guard related modules and classes.
 # Also Guard plugins should use this namespace.
-#
 module Guard
+  Deprecated::Guard.add_deprecated(self) unless Config.new.strict?
 
-  require 'guard/dsl'
-  require 'guard/guardfile'
-  require 'guard/group'
-  require 'guard/interactor'
-  require 'guard/notifier'
-  require 'guard/runner'
-  require 'guard/ui'
-  require 'guard/watcher'
-
-  # The Guardfile template for `guard init`
-  GUARDFILE_TEMPLATE = File.expand_path('../guard/templates/Guardfile', __FILE__)
+  class << self
+    attr_reader :state
+    attr_reader :queue
+    attr_reader :listener
+    attr_reader :interactor
 
-  # The location of user defined templates
-  HOME_TEMPLATES = File.expand_path('~/.guard/templates')
+    # @private api
 
-  class << self
-    attr_accessor :options, :interactor, :runner, :listener, :lock
+    include Internals::Helpers
 
-    # Initialize the Guard singleton:
+    # Initializes the Guard singleton:
     #
-    # - Initialize the internal Guard state.
-    # - Create the interactor when necessary for user interaction.
-    # - Select and initialize the file change listener.
+    # * Initialize the internal Guard state;
+    # * Create the interactor
+    # * Select and initialize the file change listener.
     #
     # @option options [Boolean] clear if auto clear the UI should be done
     # @option options [Boolean] notify if system notifications should be shown
     # @option options [Boolean] debug if debug output should be shown
     # @option options [Array<String>] group the list of groups to start
-    # @option options [String] watchdir the director to watch
+    # @option options [Array<String>] watchdir the directories to watch
     # @option options [String] guardfile the path to the Guardfile
-    # @deprecated @option options [Boolean] watch_all_modifications watches all file modifications if true
-    # @deprecated @option options [Boolean] no_vendor ignore vendored dependencies
     #
-    def setup(options = {})
-      @lock       = Mutex.new
-      @options    = options
-      @watchdir   = (options[:watchdir] && File.expand_path(options[:watchdir])) || Dir.pwd
-      @runner     = ::Guard::Runner.new
-      @allow_stop = Listen::Turnstile.new
+    # @return [Guard] the Guard singleton
+    def setup(cmdline_options = {})
+      init(cmdline_options)
 
-      ::Guard::UI.clear(:force => true)
-      deprecated_options_warning
+      @queue = Internals::Queue.new(Guard)
 
-      setup_groups
-      setup_guards
-      setup_listener
-      setup_signal_traps
-
-      debug_command_execution if @options[:debug]
-
-      ::Guard::Dsl.evaluate_guardfile(options)
-      ::Guard::UI.error 'No guards found in Guardfile, please add at least one.' if @guards.empty?
-
-      runner.deprecation_warning if @options[:show_deprecations]
-
-      setup_notifier
-      setup_interactor
-
-      self
-    end
+      _evaluate(state.session.evaluator_options)
 
-    # Initialize the groups array with the `:default` group.
-    #
-    # @see Guard.groups
-    #
-    def setup_groups
-      @groups = [Group.new(:default)]
-    end
+      # NOTE: this should be *after* evaluate so :directories can work
+      # TODO: move listener setup to session?
+      @listener = Listen.send(*state.session.listener_args, &_listener_callback)
 
-    # Initialize the guards array to an empty array.
-    #
-    # @see Guard.guards
-    #
-    def setup_guards
-      @guards = []
-    end
+      ignores = state.session.guardfile_ignore
+      @listener.ignore(ignores) unless ignores.empty?
 
-    # Sets up traps to catch signals used to control Guard.
-    #
-    # Currently two signals are caught:
-    # - `USR1` which pauses listening to changes.
-    # - `USR2` which resumes listening to changes.
-    #
-    def setup_signal_traps
-      unless defined?(JRUBY_VERSION)
-        if Signal.list.keys.include?('USR1')
-          Signal.trap('USR1') { ::Guard.pause unless @listener.paused? }
-        end
-
-        if Signal.list.keys.include?('USR2')
-          Signal.trap('USR2') { ::Guard.pause if @listener.paused? }
-        end
-      end
-    end
+      ignores = state.session.guardfile_ignore_bang
+      @listener.ignore!(ignores) unless ignores.empty?
 
-    # Initializes the listener and registers a callback for changes.
-    #
-    def setup_listener
-      listener_callback = lambda do |modified, added, removed|
-        ::Guard::Dsl.reevaluate_guardfile if ::Guard::Watcher.match_guardfile?(modified)
+      Notifier.connect(state.session.notify_options)
 
-        ::Guard.within_preserved_state do
-          runner.run_on_changes(modified, added, removed)
-        end
-      end
+      traps = Internals::Traps
+      traps.handle("USR1") { async_queue_add([:guard_pause, :paused]) }
+      traps.handle("USR2") { async_queue_add([:guard_pause, :unpaused]) }
 
-      listener_options = { :relative_paths => true }
-      %w[latency force_polling].each do |option|
-        listener_options[option.to_sym] = options[option] if options.key?(option)
-      end
+      @interactor = Interactor.new(state.session.interactor_name == :sleep)
+      traps.handle("INT") { @interactor.handle_interrupt }
 
-      @listener = Listen.to(@watchdir, listener_options).change(&listener_callback)
+      self
     end
 
-    # Enables or disables the notifier based on user's configurations.
-    #
-    def setup_notifier
-      options[:notify] && ENV['GUARD_NOTIFY'] != 'false' ? ::Guard::Notifier.turn_on : ::Guard::Notifier.turn_off
+    def init(cmdline_options)
+      @state = Internals::State.new(cmdline_options)
     end
 
-    # Initializes the interactor unless the user has specified not to.
+    # Asynchronously trigger changes
     #
-    def setup_interactor
-      unless options[:no_interactions]
-        @interactor = ::Guard::Interactor.fabricate
-      end
-    end
-
-    # Start Guard by evaluating the `Guardfile`, initializing declared Guard plugins
-    # and starting the available file change listener.
-    # Main method for Guard that is called from the CLI when Guard starts.
+    # Currently supported args:
     #
-    # - Setup Guard internals
-    # - Evaluate the `Guardfile`
-    # - Configure Notifiers
-    # - Initialize the declared Guard plugins
-    # - Start the available file change listener
+    #   @example Old style hash:
+    #     async_queue_add(modified: ['foo'], added: ['bar'], removed: [])
     #
-    # @option options [Boolean] clear if auto clear the UI should be done
-    # @option options [Boolean] notify if system notifications should be shown
-    # @option options [Boolean] debug if debug output should be shown
-    # @option options [Array<String>] group the list of groups to start
-    # @option options [String] watchdir the director to watch
-    # @option options [String] guardfile the path to the Guardfile
+    #   @example New style signals with args:
+    #     async_queue_add([:guard_pause, :unpaused ])
     #
-    def start(options = {})
-      setup(options)
-      ::Guard::UI.info "Guard is now watching at '#{ @watchdir }'"
+    def async_queue_add(changes)
+      @queue << changes
 
-      within_preserved_state do
-        runner.run(:start)
-      end
-
-      listener.start(false)
-
-      @allow_stop.wait if @allow_stop
+      # Putting interactor in background puts guard into foreground
+      # so it can handle change notifications
+      Thread.new { interactor.background }
     end
 
-    # Stop Guard listening to file changes
-    #
-    def stop
-      listener.stop
-      interactor.stop if interactor
-      runner.run(:stop)
-      ::Guard::UI.info 'Bye bye...', :reset => true
+    private
 
-      @allow_stop.signal if @allow_stop
+    # Check if any of the changes are actually watched for
+    # TODO: why iterate twice? reuse this info when running tasks
+    def _relevant_changes?(changes)
+      # TODO: no coverage!
+      files = changes.values.flatten(1)
+      scope = Guard.state.scope
+      watchers = scope.grouped_plugins.map do |_group, plugins|
+        plugins.map(&:watchers).flatten
+      end.flatten
+      watchers.any? { |watcher| files.any? { |file| watcher.match(file) } }
     end
 
-    # Reload Guardfile and all Guard plugins currently enabled.
-    #
-    # @param [Hash] scopes hash with a Guard plugin or a group scope
-    #
-    def reload(scopes = {})
-      within_preserved_state do
-        ::Guard::UI.clear(:force => true)
-        ::Guard::UI.action_with_scopes('Reload', scopes)
-        ::Guard::Dsl.reevaluate_guardfile if scopes.empty?
-        runner.run(:reload, scopes)
-      end
+    def _relative_pathnames(paths)
+      paths.map { |path| _relative_pathname(path) }
     end
 
-    # Trigger `run_all` on all Guard plugins currently enabled.
-    #
-    # @param [Hash] scopes hash with a Guard plugin or a group scope
-    #
-    def run_all(scopes = {})
-      within_preserved_state do
-        ::Guard::UI.clear(:force => true)
-        ::Guard::UI.action_with_scopes('Run', scopes)
-        runner.run(:run_all, scopes)
-      end
-    end
+    def _listener_callback
+      lambda do |modified, added, removed|
+        relative_paths = {
+          modified: _relative_pathnames(modified),
+          added: _relative_pathnames(added),
+          removed: _relative_pathnames(removed)
+        }
 
-    # Pause Guard listening to file changes.
-    #
-    def pause
-      if listener.paused?
-        ::Guard::UI.info 'Un-paused files modification listening', :reset => true
-        listener.unpause
-      else
-        ::Guard::UI.info 'Paused files modification listening', :reset => true
-        listener.pause
-      end
-    end
+        _guardfile_deprecated_check(relative_paths[:modified])
 
-    # Smart accessor for retrieving a specific Guard plugin or several Guard plugins at once.
-    #
-    # @see Guard.groups
-    #
-    # @example Filter Guard plugins by String or Symbol
-    #   Guard.guards('rspec')
-    #   Guard.guards(:rspec)
-    #
-    # @example Filter Guard plugins by Regexp
-    #   Guard.guards(/rsp.+/)
-    #
-    # @example Filter Guard plugins by Hash
-    #   Guard.guards({ :name => 'rspec', :group => 'backend' })
-    #
-    # @param [String, Symbol, Regexp, Hash] filter the filter to apply to the Guard plugins
-    # @return [Array<Guard>] the filtered Guard plugins
-    #
-    def guards(filter = nil)
-      @guards ||= []
-
-      case filter
-      when String, Symbol
-        @guards.find { |guard| guard.class.to_s.downcase.sub('guard::', '') == filter.to_s.downcase.gsub('-', '') }
-      when Regexp
-        @guards.find_all { |guard| guard.class.to_s.downcase.sub('guard::', '') =~ filter }
-      when Hash
-        filter.inject(@guards) do |matches, (k, v)|
-          if k.to_sym == :name
-            matches.find_all { |guard| guard.class.to_s.downcase.sub('guard::', '') == v.to_s.downcase.gsub('-', '') }
-          else
-            matches.find_all { |guard| guard.send(k).to_sym == v.to_sym }
-          end
-        end
-      else
-        @guards
+        async_queue_add(relative_paths) if _relevant_changes?(relative_paths)
       end
     end
 
-    # Smart accessor for retrieving a specific plugin group or several plugin groups at once.
-    #
-    # @see Guard.guards
-    #
-    # @example Filter groups by String or Symbol
-    #   Guard.groups('backend')
-    #   Guard.groups(:backend)
-    #
-    # @example Filter groups by Regexp
-    #   Guard.groups(/(back|front)end/)
-    #
-    # @param [String, Symbol, Regexp] filter the filter to apply to the Groups
-    # @return [Array<Group>] the filtered groups
-    #
-    def groups(filter = nil)
-      case filter
-      when String, Symbol
-        @groups.find { |group| group.name == filter.to_sym }
-      when Regexp
-        @groups.find_all { |group| group.name.to_s =~ filter }
-      else
-        @groups
-      end
+    # TODO: obsoleted? (move to Dsl?)
+    def _pluginless_guardfile?
+      state.session.plugins.all.empty?
     end
 
-    # Add a Guard plugin to use.
-    #
-    # @param [String] name the Guard name
-    # @param [Array<Watcher>] watchers the list of declared watchers
-    # @param [Array<Hash>] callbacks the list of callbacks
-    # @param [Hash] options the plugin options (see the given Guard documentation)
-    # @return [Guard::Guard] the added Guard plugin
-    #
-    def add_guard(name, watchers = [], callbacks = [], options = {})
-      if name.to_sym == :ego
-        ::Guard::UI.deprecation('Guard::Ego is now part of Guard. You can remove it from your Guardfile.')
-      else
-        guard_class = get_guard_class(name)
-        callbacks.each { |callback| Hook.add_callback(callback[:listener], guard_class, callback[:events]) }
-        guard = guard_class.new(watchers, options)
-        @guards << guard
-        guard
-      end
-    end
+    def _evaluate(options)
+      evaluator = Guardfile::Evaluator.new(options)
+      evaluator.evaluate
 
-    # Add a Guard plugin group.
-    #
-    # @param [String] name the group name
-    # @option options [Boolean] halt_on_fail if a task execution
-    #   should be halted for all Guard plugins in this group if one Guard throws `:task_has_failed`
-    # @return [Guard::Group] the group added (or retrieved from the `@groups` variable if already present)
-    #
-    def add_group(name, options = {})
-      group = groups(name)
-      if group.nil?
-        group = ::Guard::Group.new(name, options)
-        @groups << group
-      end
-      group
-    end
+      UI.reset_and_clear
 
-    # Runs a block where the interactor is
-    # blocked and execution is synchronized
-    # to avoid state inconsistency.
-    #
-    # @yield the block to run
-    #
-    def within_preserved_state
-      lock.synchronize do
-        begin
-          interactor.stop if interactor
-          @result = yield
-        rescue Interrupt
-        end
-
-        interactor.start if interactor
-      end
-      @result
-    end
+      msg = "No plugins found in Guardfile, please add at least one."
+      UI.error msg if _pluginless_guardfile?
 
-    # Tries to load the Guard plugin main class. This transforms the supplied Guard plugin
-    # name into a class name:
-    #
-    # * `guardname` will become `Guard::Guardname`
-    # * `dashed-guard-name` will become `Guard::DashedGuardName`
-    # * `underscore_guard_name` will become `Guard::UnderscoreGuardName`
-    #
-    # When no class is found with the strict case sensitive rules, another
-    # try is made to locate the class without matching case:
-    #
-    # * `rspec` will find a class `Guard::RSpec`
-    #
-    # @param [String] name the name of the Guard
-    # @param [Boolean] fail_gracefully whether error messages should not be printed
-    # @return [Class, nil] the loaded class
-    #
-    def get_guard_class(name, fail_gracefully=false)
-      name        = name.to_s
-      try_require = false
-      const_name  = name.gsub(/\/(.?)/) { "::#{ $1.upcase }" }.gsub(/(?:^|[_-])(.)/) { $1.upcase }
-      begin
-        require "guard/#{ name.downcase }" if try_require
-        self.const_get(self.constants.find { |c| c.to_s == const_name } || self.constants.find { |c| c.to_s.downcase == const_name.downcase })
-      rescue TypeError
-        unless try_require
-          try_require = true
-          retry
-        else
-          ::Guard::UI.error "Could not find class Guard::#{ const_name.capitalize }"
-        end
-      rescue LoadError => loadError
-        unless fail_gracefully
-          ::Guard::UI.error "Could not load 'guard/#{ name.downcase }' or find class Guard::#{ const_name.capitalize }"
-          ::Guard::UI.error loadError.to_s
-        end
+      if evaluator.inline?
+        UI.info("Using inline Guardfile.")
+      elsif evaluator.custom?
+        UI.info("Using Guardfile at #{ evaluator.path }.")
       end
+    rescue Guardfile::Evaluator::NoPluginsError => e
+      UI.error(e.message)
     end
 
-    # Locate a path to a Guard plugin gem.
-    #
-    # @param [String] name the name of the Guard plugin without the prefix `guard-`
-    # @return [String] the full path to the Guard gem
-    #
-    def locate_guard(name)
-      if Gem::Version.create(Gem::VERSION) >= Gem::Version.create('1.8.0')
-        Gem::Specification.find_by_name("guard-#{ name }").full_gem_path
-      else
-        Gem.source_index.find_name("guard-#{ name }").last.full_gem_path
-      end
-    rescue
-      ::Guard::UI.error "Could not find 'guard-#{ name }' gem path."
-    end
+    # TODO: remove at some point
+    # TODO: not tested because collides with ongoing refactoring
+    def _guardfile_deprecated_check(modified)
+      modified.map!(&:to_s)
+      regexp = %r{^(?:.+/)?Guardfile$}
+      guardfiles = modified.select { |path| regexp.match(path) }
+      return if guardfiles.empty?
 
-    # Returns a list of Guard plugin Gem names installed locally.
-    #
-    # @return [Array<String>] a list of Guard plugin gem names
-    #
-    def guard_gem_names
-      if Gem::Version.create(Gem::VERSION) >= Gem::Version.create('1.8.0')
-        Gem::Specification.find_all.select { |x| x.name =~ /^guard-/ }
-      else
-        Gem.source_index.find_name(/^guard-/)
-      end.map { |x| x.name.sub(/^guard-/, '') }
-    end
-
-    # Adds a command logger in debug mode. This wraps common command
-    # execution functions and logs the executed command before execution.
-    #
-    def debug_command_execution
-      Kernel.send(:alias_method, :original_system, :system)
-      Kernel.send(:define_method, :system) do |command, *args|
-        ::Guard::UI.debug "Command execution: #{ command } #{ args.join(' ') }"
-        original_system command, *args
+      guardfile = Pathname("Guardfile").realpath
+      real_guardfiles = guardfiles.detect do |path|
+        /^Guardfile$/.match(path) || Pathname(path).expand_path == guardfile
       end
 
-      Kernel.send(:alias_method, :original_backtick, :'`')
-      Kernel.send(:define_method, :'`') do |command|
-        ::Guard::UI.debug "Command execution: #{ command }"
-        original_backtick command
-      end
-    end
+      return unless real_guardfiles
 
-    # Deprecation message for the `watch_all_modifications` start option
-    WATCH_ALL_MODIFICATIONS_DEPRECATION = <<-EOS.gsub(/^\s*/, '')
-      Starting with Guard v1.1 the 'watch_all_modifications' option is removed and is now always on.
-    EOS
-
-    # Deprecation message for the `no_vendor` start option
-    NO_VENDOR_DEPRECATION = <<-EOS.gsub(/^\s*/, '')
-      Starting with Guard v1.1 the 'no_vendor' option is removed because the monitoring
-      gems are now part of a new gem called Listen. (https://github.com/guard/listen)
-
-      You can specify a custom version of any monitoring gem directly in your Gemfile
-      if you want to overwrite Listen's default monitoring gems.
-    EOS
-
-    # Displays a warning for each deprecated options used.
-    #
-    def deprecated_options_warning
-      ::Guard::UI.deprecation(WATCH_ALL_MODIFICATIONS_DEPRECATION) if options[:watch_all_modifications]
-      ::Guard::UI.deprecation(NO_VENDOR_DEPRECATION) if options[:no_vendor]
+      UI.warning "Guardfile changed -- _guard-core will exit.\n"
+      exit 2 # nonzero to break any while loop
     end
-
   end
 end

data/lib/tasks/releaser.rb

@@ -0,0 +1,116 @@
+# TODO: extract to gem?
+
+class Releaser
+  def initialize(options = {})
+    @project_name = options.delete(:project_name) do
+      fail "project_name is needed!"
+    end
+
+    @gem_name = options.delete(:gem_name) do
+      fail "gem_name is needed!"
+    end
+
+    @github_repo = options.delete(:github_repo) do
+      fail "github_repo is needed!"
+    end
+
+    @version = options.delete(:version) do
+      fail "version is needed!"
+    end
+  end
+
+  def full
+    rubygems
+    github
+  end
+
+  def rubygems
+    input = nil
+    loop do
+      STDOUT.puts "Release #{@project_name} #{@version} to RubyGems? (y/n)"
+      input = STDIN.gets.chomp.downcase
+      break if %w(y n).include?(input)
+    end
+
+    exit if input == "n"
+
+    Rake::Task["release"].invoke
+  end
+
+  def github
+    tag_name = "v#{@version}"
+
+    require "gems"
+
+    _verify_released
+    _verify_tag_pushed
+
+    require "octokit"
+    gh_client = Octokit::Client.new(netrc: true)
+
+    gh_release = _detect_gh_release(gh_client, tag_name, true)
+    return unless gh_release
+
+    STDOUT.puts "Draft release for #{tag_name}:\n"
+    STDOUT.puts gh_release.body
+    STDOUT.puts "\n-------------------------\n\n"
+
+    _confirm_publish
+
+    return unless _update_release(gh_client, gh_release, tag_name)
+
+    gh_release = _detect_gh_release(gh_client, tag_name, false)
+
+    _success_summary(gh_release, tag_name)
+  end
+
+  private
+
+  def _verify_released
+    if @version != Gems.info(@gem_name)["version"]
+      STDOUT.puts "#{@project_name} #{@version} is not yet released."
+      STDOUT.puts "Please release it first with: rake release:gem"
+      exit
+    end
+  end
+
+  def _verify_tag_pushed
+    tags = `git ls-remote --tags origin`.split("\n")
+    return if tags.detect { |tag| tag =~ /v#{@version}$/ }
+
+    STDOUT.puts "The tag v#{@version} has not yet been pushed."
+    STDOUT.puts "Please push it first with: rake release:gem"
+    exit
+  end
+
+  def _success_summary(gh_release, tag_name)
+    href = gh_release.rels[:html].href
+    STDOUT.puts "GitHub release #{tag_name} has been published!"
+    STDOUT.puts "\nPlease enjoy and spread the word!"
+    STDOUT.puts "Lack of inspiration? Here's a tweet you could improve:\n\n"
+    STDOUT.puts "Just released #{@project_name} #{@version}! #{href}"
+  end
+
+  def _detect_gh_release(gh_client, tag_name, draft)
+    gh_releases = gh_client.releases(@github_repo)
+    gh_releases.detect { |r| r.tag_name == tag_name && r.draft == draft }
+  end
+
+  def _confirm_publish
+    input = nil
+    loop do
+      STDOUT.puts "Would you like to publish this GitHub release now? (y/n)"
+      input = STDIN.gets.chomp.downcase
+      break if %w(y n).include?(input)
+    end
+
+    exit if input == "n"
+  end
+
+  def _update_release(gh_client, gh_release, tag_name)
+    result = gh_client.update_release(gh_release.rels[:self].href, draft: false)
+    return true if result
+    STDOUT.puts "GitHub release #{tag_name} couldn't be published!"
+    false
+  end
+end