guard 1.4.0 → 2.18.0

data/lib/guard/jobs/pry_wrapper.rb

@@ -0,0 +1,336 @@
+require "guard/commands/all"
+require "guard/commands/change"
+require "guard/commands/notification"
+require "guard/commands/pause"
+require "guard/commands/reload"
+require "guard/commands/scope"
+require "guard/commands/show"
+require "shellany/sheller"
+
+require "guard/jobs/base"
+
+module Guard
+  module Jobs
+    class TerminalSettings
+      def initialize
+        @settings = nil
+        @works = Shellany::Sheller.run("hash", "stty") || false
+      end
+
+      def restore
+        return unless configurable? && @settings
+        Shellany::Sheller.run("stty #{ @setting } 2>#{IO::NULL}")
+      end
+
+      def save
+        return unless configurable?
+        @settings = Shellany::Sheller.stdout("stty -g 2>#{IO::NULL}").chomp
+      end
+
+      def echo
+        return unless configurable?
+        Shellany::Sheller.run("stty echo 2>#{IO::NULL}")
+      end
+
+      def configurable?
+        @works
+      end
+    end
+
+    class PryWrapper < Base
+      # The default Ruby script to configure Guard Pry if the option `:guard_rc`
+      # is not defined.
+
+      GUARD_RC = if ENV["XDG_CONFIG_HOME"] && File.exist?(ENV["XDG_CONFIG_HOME"] + "/guard/guardrc")
+                   ENV["XDG_CONFIG_HOME"] + "/guard/guardrc"
+                 else
+                   "~/.guardrc"
+                 end
+
+      # The default Guard Pry history file if the option `:history_file` is not
+      # defined.
+
+      HISTORY_FILE = if ENV["XDG_DATA_HOME"] && File.exist?(ENV["XDG_DATA_HOME"] + "/guard/history")
+                       ENV["XDG_DATA_HOME"] + "/guard/history"
+                     else
+                       "~/.guard_history"
+                     end
+
+      # List of shortcuts for each interactor command
+      SHORTCUTS = {
+        help: "h",
+        all: "a",
+        reload: "r",
+        change: "c",
+        show: "s",
+        scope: "o",
+        notification: "n",
+        pause: "p",
+        exit: "e",
+        quit: "q"
+      }
+
+      def initialize(options)
+        @mutex = Mutex.new
+        @thread = nil
+        @terminal_settings = TerminalSettings.new
+
+        _setup(options)
+      end
+
+      def foreground
+        UI.debug "Start interactor"
+        @terminal_settings.save
+
+        _switch_to_pry
+        # TODO: rename :stopped to continue
+        _killed? ? :stopped : :exit
+      ensure
+        UI.reset_line
+        UI.debug "Interactor was stopped or killed"
+        @terminal_settings.restore
+      end
+
+      def background
+        _kill_pry
+      end
+
+      def handle_interrupt
+        thread = @thread
+        fail Interrupt unless thread
+        thread.raise Interrupt
+      end
+
+      private
+
+      attr_reader :thread
+
+      def _pry_config
+        Pry.config
+      end
+
+      def _pry_commands
+        Pry.commands
+      end
+
+      def _switch_to_pry
+        th = nil
+        @mutex.synchronize do
+          unless @thread
+            @thread = Thread.new { Pry.start }
+            @thread.join(0.5) # give pry a chance to start
+            th = @thread
+          end
+        end
+        # check for nill, because it might've been killed between the mutex and
+        # now
+        th.join unless th.nil?
+      end
+
+      def _killed?
+        th = nil
+        @mutex.synchronize { th = @thread }
+        th.nil?
+      end
+
+      def _kill_pry
+        @mutex.synchronize do
+          unless @thread.nil?
+            @thread.kill
+            @thread = nil # set to nil so we know we were killed
+          end
+        end
+      end
+
+      def _setup(options)
+        _pry_config.should_load_rc = false
+        _pry_config.should_load_local_rc = false
+
+        _configure_history_file(options[:history_file] || HISTORY_FILE)
+        _add_hooks(options)
+
+        Commands::All.import
+        Commands::Change.import
+        Commands::Notification.import
+        Commands::Pause.import
+        Commands::Reload.import
+        Commands::Show.import
+        Commands::Scope.import
+
+        _setup_commands
+        _configure_prompt
+      end
+
+      def _configure_history_file(history_file)
+        history_file_path = File.expand_path(history_file)
+
+        # Pry >= 0.13
+        if _pry_config.respond_to?(:history_file=)
+          _pry_config.history_file = history_file_path
+        else
+          _pry_config.history.file = history_file_path
+        end
+      end
+
+      # Add Pry hooks:
+      #
+      # * Load `~/.guardrc` within each new Pry session.
+      # * Load project's `.guardrc` within each new Pry session.
+      # * Restore prompt after each evaluation.
+      #
+      def _add_hooks(options)
+        _add_load_guard_rc_hook(Pathname(options[:guard_rc] || GUARD_RC))
+        _add_load_project_guard_rc_hook(Pathname.pwd + ".guardrc")
+        _add_restore_visibility_hook if @terminal_settings.configurable?
+      end
+
+      # Add a `when_started` hook that loads a global .guardrc if it exists.
+      #
+      def _add_load_guard_rc_hook(guard_rc)
+        _pry_config.hooks.add_hook :when_started, :load_guard_rc do
+          guard_rc.expand_path.tap { |p| load p if p.exist? }
+        end
+      end
+
+      # Add a `when_started` hook that loads a project .guardrc if it exists.
+      #
+      def _add_load_project_guard_rc_hook(guard_rc)
+        _pry_config.hooks.add_hook :when_started, :load_project_guard_rc do
+          load guard_rc if guard_rc.exist?
+        end
+      end
+
+      # Add a `after_eval` hook that restores visibility after a command is
+      # eval.
+      def _add_restore_visibility_hook
+        _pry_config.hooks.add_hook :after_eval, :restore_visibility do
+          @terminal_settings.echo
+        end
+      end
+
+      def _setup_commands
+        _replace_reset_command
+        _create_run_all_command
+        _create_command_aliases
+        _create_guard_commands
+        _create_group_commands
+      end
+
+      # Replaces reset defined inside of Pry with a reset that
+      # instead restarts guard.
+      #
+      def _replace_reset_command
+        _pry_commands.command "reset", "Reset the Guard to a clean state." do
+          output.puts "Guard reset."
+          exec "guard"
+        end
+      end
+
+      # Creates a command that triggers the `:run_all` action
+      # when the command is empty (just pressing enter on the
+      # beginning of a line).
+      #
+      def _create_run_all_command
+        _pry_commands.block_command(/^$/, "Hit enter to run all") do
+          Pry.run_command "all"
+        end
+      end
+
+      # Creates command aliases for the commands: `help`, `reload`, `change`,
+      # `scope`, `notification`, `pause`, `exit` and `quit`, which will be the
+      # first letter of the command.
+      #
+      def _create_command_aliases
+        SHORTCUTS.each do |command, shortcut|
+          _pry_commands.alias_command shortcut, command.to_s
+        end
+      end
+
+      # Create a shorthand command to run the `:run_all`
+      # action on a specific Guard plugin. For example,
+      # when guard-rspec is available, then a command
+      # `rspec` is created that runs `all rspec`.
+      #
+      def _create_guard_commands
+        Guard.state.session.plugins.all.each do |guard_plugin|
+          cmd = "Run all #{guard_plugin.title}"
+          _pry_commands.create_command guard_plugin.name, cmd do
+            group "Guard"
+
+            def process
+              Pry.run_command "all #{ match }"
+            end
+          end
+        end
+      end
+
+      # Create a shorthand command to run the `:run_all`
+      # action on a specific Guard group. For example,
+      # when you have a group `frontend`, then a command
+      # `frontend` is created that runs `all frontend`.
+      #
+      def _create_group_commands
+        Guard.state.session.groups.all.each do |group|
+          next if group.name == :default
+
+          cmd = "Run all #{group.title}"
+          _pry_commands.create_command group.name.to_s, cmd do
+            group "Guard"
+
+            def process
+              Pry.run_command "all #{ match }"
+            end
+          end
+        end
+      end
+
+      # Configures the pry prompt to see `guard` instead of
+      # `pry`.
+      #
+      def _configure_prompt
+        prompt_procs = [_prompt(">"), _prompt("*")]
+        prompt =
+          if Pry::Prompt.is_a?(Class)
+            Pry::Prompt.new("Guard", "Guard Pry prompt", prompt_procs)
+          else
+            prompt_procs
+          end
+
+        _pry_config.prompt = prompt
+      end
+
+      # Returns the plugins scope, or the groups scope ready for display in the
+      # prompt.
+      #
+      def _scope_for_prompt
+        titles = Guard.state.scope.titles.join(",")
+        titles == "all" ? "" : titles + " "
+      end
+
+      # Returns a proc that will return itself a string ending with the given
+      # `ending_char` when called.
+      #
+      def _prompt(ending_char)
+        proc do |target_self, nest_level, pry|
+          process = Guard.listener.paused? ? "pause" : "guard"
+          level = ":#{ nest_level }" unless nest_level.zero?
+
+          "[#{ _history(pry) }] #{ _scope_for_prompt }#{ process }"\
+            "(#{ _clip_name(target_self) })#{ level }#{ ending_char } "
+        end
+      end
+
+      def _clip_name(target)
+        Pry.view_clip(target)
+      end
+
+      def _history(pry)
+        if pry.respond_to?(:input_ring)
+          pry.input_ring.size
+        else
+          pry.input_array.size
+        end
+      end
+    end
+  end
+end

data/lib/guard/jobs/sleep.rb

@@ -0,0 +1,26 @@
+require "guard/jobs/base"
+require "guard/ui"
+
+module Guard
+  module Jobs
+    class Sleep < Base
+      def foreground
+        UI.debug "Guards jobs done. Sleeping..."
+        sleep
+        UI.debug "Sleep interrupted by events."
+        :stopped
+      rescue Interrupt
+        UI.debug "Sleep interrupted by user."
+        :exit
+      end
+
+      def background
+        Thread.main.wakeup
+      end
+
+      def handle_interrupt
+        Thread.main.raise Interrupt
+      end
+    end
+  end
+end

data/lib/guard/notifier.rb

@@ -1,237 +1,71 @@
-require 'yaml'
-require 'rbconfig'
-require 'pathname'
+require "notiffany/notifier"
+require "guard/ui"
 
 module Guard
-
-  # The notifier handles sending messages to different notifiers. Currently the following
-  # libraries are supported:
-  #
-  # * Ruby GNTP
-  # * Growl
-  # * GrowlNotify
-  # * Libnotify
-  # * rb-notifu
-  # * emacs
-  # * Terminal Notifier
-  # * Tmux
-  #
-  # Please see the documentation of each notifier for more information about the requirements
-  # and configuration possibilities.
-  #
-  # Guard knows four different notification types:
-  #
-  # * success
-  # * pending
-  # * failed
-  # * notify
-  #
-  # The notification type selection is based on the image option that is
-  # sent to {#notify}. Each image type has its own notification type, and
-  # notifications with custom images goes all sent as type `notify`. The
-  # `gntp` and `growl_notify` notifiers are able to register these types
-  # at Growl and allows customization of each notification type.
-  #
-  # Guard can be configured to make use of more than one notifier at once, @see Guard::Dsl
-  #
-  module Notifier
-
-    require 'guard'
-    require 'guard/ui'
-    require 'guard/notifiers/gntp'
-    require 'guard/notifiers/growl'
-    require 'guard/notifiers/growl_notify'
-    require 'guard/notifiers/libnotify'
-    require 'guard/notifiers/notifysend'
-    require 'guard/notifiers/rb_notifu'
-    require 'guard/notifiers/emacs'
-    require 'guard/notifiers/terminal_notifier'
-    require 'guard/notifiers/tmux'
-
-    extend self
-
-    # List of available notifiers. It needs to be a nested hash instead of
-    # a simpler Hash, because it maintains its order on Ruby 1.8.7 also.
-    NOTIFIERS = [
-      [:growl,             ::Guard::Notifier::Growl],
-      [:gntp,              ::Guard::Notifier::GNTP],
-      [:growl_notify,      ::Guard::Notifier::GrowlNotify],
-      [:libnotify,         ::Guard::Notifier::Libnotify],
-      [:notifysend,        ::Guard::Notifier::NotifySend],
-      [:notifu,            ::Guard::Notifier::Notifu],
-      [:emacs,             ::Guard::Notifier::Emacs],
-      [:terminal_notifier, ::Guard::Notifier::TerminalNotifier],
-      [:tmux,              ::Guard::Notifier::Tmux]
-    ]
-
-    # Get the available notifications.
-    #
-    # @return [Hash] the notifications
-    #
-    def notifications
-      ENV['GUARD_NOTIFICATIONS'] ? YAML::load(ENV['GUARD_NOTIFICATIONS']) : []
-    end
-
-    # Set the available notifications.
-    #
-    # @param [Array<Hash>] notifications the notifications
-    #
-    def notifications=(notifications)
-      ENV['GUARD_NOTIFICATIONS'] = YAML::dump(notifications)
+  class Notifier
+    def self.connect(options = {})
+      @notifier ||= nil
+      fail "Already connected!" if @notifier
+      begin
+        opts = options.merge(namespace: "guard", logger: UI)
+        @notifier = Notiffany.connect(opts)
+      rescue Notiffany::Notifier::Detected::UnknownNotifier => e
+        UI.error "Failed to setup notification: #{e.message}"
+        fail
+      end
     end
 
-    # Clear available notifications.
-    #
-    def clear_notifications
-      ENV['GUARD_NOTIFICATIONS'] = nil
+    def self.disconnect
+      @notifier && @notifier.disconnect
+      @notifier = nil
     end
 
-    # Turn notifications on. If no notifications are defined
-    # in the `Guardfile` Guard auto detects the first available
-    # library.
-    #
-    def turn_on
-      auto_detect_notification if notifications.empty? && (!::Guard.options || ::Guard.options[:notify])
-
-      if notifications.empty?
-        ENV['GUARD_NOTIFY'] = 'false'
-      else
-        notifications.each do |notification|
-          ::Guard::UI.info "Guard uses #{ get_notifier_module(notification[:name]).to_s.split('::').last } to send notifications."
-        end
+    DEPRECATED_IMPLICIT_CONNECT = "Calling Notiffany::Notifier.notify()"\
+                                  " without a prior Notifier.connect() is"\
+                                  " deprecated"
 
-        ENV['GUARD_NOTIFY'] = 'true'
+    def self.notify(message, options = {})
+      unless @notifier
+        # TODO: reenable again?
+        # UI.deprecation(DEPRECTED_IMPLICIT_CONNECT)
+        connect(notify: true)
       end
-    end
 
-    # Turn notifications off.
-    #
-    def turn_off
-      ENV['GUARD_NOTIFY'] = 'false'
+      @notifier.notify(message, options)
+    rescue RuntimeError => e
+      UI.error "Notification failed for #{@notifier.class.name}: #{e.message}"
+      UI.debug e.backtrace.join("\n")
     end
 
-    # Test if the notifications are on.
-    #
-    # @return [Boolean] whether the notifications are on
-    #
-    def enabled?
-      ENV['GUARD_NOTIFY'] == 'true'
+    def self.turn_on
+      @notifier.turn_on
     end
 
-    # Add a notification library to be used.
-    #
-    # @param [Symbol] name the name of the notifier to use
-    # @param [Boolean] silent disable any error message
-    # @param [Hash] options the notifier options
-    # @return [Boolean] if the notification could be added
-    #
-    def add_notification(name, options = { }, silent = false)
-      return turn_off if name == :off
-
-      notifier = get_notifier_module(name)
-
-      if notifier && notifier.available?(silent)
-        self.notifications = notifications << { :name => name, :options => options }
-        true
-      else
-        false
+    def self.toggle
+      unless @notifier.enabled?
+        UI.error NOTIFICATIONS_DISABLED
+        return
       end
-    end
-
-    # Show a system notification with all configured notifiers.
-    #
-    # @param [String] message the message to show
-    # @option options [Symbol, String] image the image symbol or path to an image
-    # @option options [String] title the notification title
-    #
-    def notify(message, options = { })
-      if enabled?
-        type  = notification_type(options[:image] || :success)
-        image = image_path(options.delete(:image) || :success)
-        title = options.delete(:title) || 'Guard'
 
-        notifications.each do |notification|
-          begin
-            get_notifier_module(notification[:name]).notify(type, title, message, image, options.merge(notification[:options]))
-          rescue Exception => e
-            ::Guard::UI.error "Error sending notification with #{ notification[:name] }: #{ e.message }"
-          end
-        end
+      if @notifier.active?
+        UI.info "Turn off notifications"
+        @notifier.turn_off
+        return
       end
-    end
-
-    private
 
-    # Get the notifier module for the given name.
-    #
-    # @param [Symbol] the notifier name
-    # @return [Module] the notifier module
-    #
-    def get_notifier_module(name)
-      notifier = NOTIFIERS.detect { |n| n.first == name }
-      notifier ? notifier.last : notifier
+      @notifier.turn_on
     end
 
-    # Auto detect the available notification library. This goes through
-    # the list of supported notification gems and picks the first that
-    # is available.
-    #
-    def auto_detect_notification
-      available = NOTIFIERS.map { |n| n.first }.any? { |notifier| add_notification(notifier, { }, true) }
-      ::Guard::UI.info('Guard could not detect any of the supported notification libraries.') unless available
+    # Used by dsl describer
+    def self.supported
+      Notiffany::Notifier::SUPPORTED.inject(:merge)
     end
 
-    # Get the image path for an image symbol for the following
-    # known image types:
-    #
-    # - failed
-    # - pending
-    # - success
-    #
-    # If the image is not a known symbol, it will be returned unmodified.
-    #
-    # @param [Symbol, String] image the image symbol or path to an image
-    # @return [String] the image path
-    #
-    def image_path(image)
-      case image
-        when :failed
-          images_path.join('failed.png').to_s
-        when :pending
-          images_path.join('pending.png').to_s
-        when :success
-          images_path.join('success.png').to_s
-        else
-          image
-      end
-    end
-
-    # Paths where all Guard images are located
-    #
-    # @return [Pathname] the path to the images directory
-    #
-    def images_path
-      @images_path ||= Pathname.new(File.dirname(__FILE__)).join('../../images')
-    end
-
-    # Get the notification type depending on the
-    # image that has been selected for the notification.
-    #
-    # @param [Symbol, String] image the image symbol or path to an image
-    # @return [String] the notification type
-    #
-    def notification_type(image)
-      case image
-        when :failed
-          'failed'
-        when :pending
-          'pending'
-        when :success
-          'success'
-        else
-          'notify'
+    # Used by dsl describer
+    def self.detected
+      @notifier.available.map do |mod|
+        { name: mod.name.to_sym, options: mod.options }
       end
     end
   end
-
 end

data/lib/guard/options.rb

@@ -0,0 +1,22 @@
+require "thor/core_ext/hash_with_indifferent_access"
+
+module Guard
+  # A class that holds options. Can be instantiated with default options.
+  #
+  class Options < Thor::CoreExt::HashWithIndifferentAccess
+    # Initializes an Guard::Options object. `default_opts` is merged into
+    # `opts`.
+    #
+    # @param [Hash] opts the options
+    # @param [Hash] default_opts the default options
+    #
+    def initialize(opts = {}, default_opts = {})
+      super(default_opts.merge(opts || {}))
+    end
+
+    # workaround for: https://github.com/erikhuda/thor/issues/504
+    def fetch(name)
+      super(name.to_s)
+    end
+  end
+end