guard 2.8.1 → 2.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eba722e0d98149098d042a096e5df4dc7abd495b
-  data.tar.gz: 76421bb7bdc9c176c22ba3207460104d37090439
+  metadata.gz: 5623a43a66b46a5d8137215f562d99c05a3235a4
+  data.tar.gz: 5d49353627874560143c223d57e2d426bc8f8639
 SHA512:
-  metadata.gz: c4f95478bc1293ff711721d8d8ed42b6a81b15daf2d17a3dcffa4f72dca1e6bbdfdbdf881e5f6993b3c5955bf08a5b8d608f3985650ad39248dfd2bf28e59b2c
-  data.tar.gz: 7a8cdcd97b6619ddc3c9ecf219229710107bf5fb58ebccbd457888711af57053f424998a82d5ffe92de72f3c40658535edd396890c64a948ef09390ed785f833
+  metadata.gz: 9364e851605d579463afe517ccbc56c6bde7c7b0353a5a6199f93520e23fc55ac029a923ef679af561510b4c38ddf3c947bd7d8bd2330aaf273f35573065a05a
+  data.tar.gz: c01ce4150b9fd551263893f9ce80e768a1694afc182ded540089781041dce167f9452819768f9f621f54969a9e62d3d7710a491321663eaed2d1ab8eb01a4421

data/lib/guard/commander.rb

@@ -28,7 +28,15 @@ module Guard
       watched = ::Guard.watchdirs.join("', '")
       ::Guard::UI.info "Guard is now watching at '#{ watched }'"
 
-      _interactor_loop
+      # TODO: remove (left to avoid breaking too many specs)
+      begin
+        while interactor.foreground != :exit
+          _process_queue while pending_changes?
+        end
+      rescue Interrupt
+      end
+
+      stop
     end
 
     # TODO: refactor (left to avoid breaking too many specs)
@@ -84,16 +92,5 @@ module Guard
     def show
       ::Guard::DslDescriber.new(::Guard.options).show
     end
-
-    private
-
-    # TODO: remove (left to avoid breaking too many specs)
-    def _interactor_loop
-      while interactor.foreground != :exit
-        _process_queue while pending_changes?
-      end
-    rescue Interrupt
-      stop
-    end
   end
 end

data/lib/guard/notifier.rb.orig

@@ -0,0 +1,222 @@
+require "yaml"
+require "rbconfig"
+require "pathname"
+
+require "guard/ui"
+require "guard/notifiers/emacs"
+require "guard/notifiers/file_notifier"
+require "guard/notifiers/gntp"
+require "guard/notifiers/growl"
+require "guard/notifiers/libnotify"
+require "guard/notifiers/notifysend"
+require "guard/notifiers/rb_notifu"
+require "guard/notifiers/terminal_notifier"
+require "guard/notifiers/terminal_title"
+require "guard/notifiers/tmux"
+
+module Guard
+  # The notifier handles sending messages to different notifiers. Currently the
+  # following
+  # libraries are supported:
+  #
+  # * Ruby GNTP
+  # * Growl
+  # * Libnotify
+  # * rb-notifu
+  # * emacs
+  # * Terminal Notifier
+  # * Terminal Title
+  # * 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` notifier is 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
+    extend self
+
+    # List of available notifiers, grouped by functionality
+    NOTIFIERS = [
+      {
+        gntp: GNTP,
+        growl: Growl,
+        terminal_notifier: TerminalNotifier,
+        libnotify: Libnotify,
+        notifysend: NotifySend,
+        notifu: Notifu
+      },
+      { emacs: Emacs },
+      { tmux: Tmux },
+      { terminal_title: TerminalTitle },
+      { file: FileNotifier }
+    ]
+
+    def notifiers
+      ENV["GUARD_NOTIFIERS"] ? YAML::load(ENV["GUARD_NOTIFIERS"]) : []
+    end
+
+    def notifiers=(notifiers)
+      ENV["GUARD_NOTIFIERS"] = YAML::dump(notifiers)
+    end
+
+    # Clear available notifications.
+    #
+    def clear_notifiers
+      ENV["GUARD_NOTIFIERS"] = nil
+    end
+
+    # Turn notifications on. If no notifications are defined in the `Guardfile`
+    # Guard auto detects the first available library.
+    #
+    # @param [Hash] options the turn_on options
+    # @option options [Boolean] silent disable any logging
+    #
+    def turn_on(opts = {})
+      if notifiers.empty? && (::Guard.options || {})[:notify]
+        _auto_detect_notification
+      end
+
+      if notifiers.empty?
+        turn_off
+      else
+        notifiers.each do |notifier|
+          notifier_class = _get_notifier_module(notifier[:name])
+          unless opts[:silent]
+            ::Guard::UI.info \
+              "Guard is using #{ notifier_class.title } to send notifications."
+          end
+
+          notifier_class.turn_on if notifier_class.respond_to?(:turn_on)
+        end
+
+        ENV["GUARD_NOTIFY"] = "true"
+      end
+    end
+
+    # Turn notifications off.
+    #
+    def turn_off
+      notifiers.each do |notifier|
+        notifier_class = _get_notifier_module(notifier[:name])
+
+        notifier_class.turn_off if notifier_class.respond_to?(:turn_off)
+      end
+
+      ENV["GUARD_NOTIFY"] = "false"
+    end
+
+    # Toggle the system notifications on/off
+    #
+    def toggle
+      if enabled?
+        ::Guard::UI.info "Turn off notifications"
+        turn_off
+      else
+        turn_on
+      end
+    end
+
+    # Test if the notifications are on.
+    #
+    # @return [Boolean] whether the notifications are on
+    #
+    def enabled?
+      ENV["GUARD_NOTIFY"] == "true"
+    end
+
+    # Add a notification library to be used.
+    #
+    # @param [Symbol] name the name of the notifier to use
+    # @param [Hash] options the notifier options
+    # @option options [String] silent disable any error message
+    # @return [Boolean] if the notification could be added
+    #
+    def add_notifier(name, opts = {})
+      return turn_off if name == :off
+
+      notifier_class = _get_notifier_module(name)
+
+      if notifier_class && notifier_class.available?(opts)
+        self.notifiers = notifiers << { name: name, options: opts }
+        true
+      else
+        false
+      end
+    end
+
+    # Show a system notification with all configured notifiers.
+    #
+    # @param [String] message the message to show
+    # @option opts [Symbol, String] image the image symbol or path to an image
+    # @option opts [String] title the notification title
+    #
+    def notify(message, opts = {})
+      return unless enabled?
+
+      notifiers.each do |notifier|
+        notifier = _get_notifier_module(notifier[:name]).new(notifier[:options])
+
+        begin
+          notifier.notify(message, opts.dup)
+        rescue RuntimeError => e
+          ::Guard::UI.error \
+            "Error sending notification with #{ notifier.name }: #{ e.message }"
+
+          ::Guard::UI.debug e.backtrace.join("\n")
+        end
+      end
+    end
+
+    private
+
+    # Get the notifier module for the given name.
+    #
+    # @param [Symbol] name the notifier name
+    # @return [Module] the notifier module
+    #
+    def _get_notifier_module(name)
+      NOTIFIERS.each do |group|
+        next unless (notifier = group.detect { |n, _| n == name })
+        return notifier.last
+      end
+      nil
+    end
+
+    # Auto detect the available notification library. This goes through
+    # the list of supported notification gems and picks the first that
+    # is available in each notification group.
+    #
+    def _auto_detect_notification
+      self.notifiers = []
+      available = nil
+
+      NOTIFIERS.each do |group|
+        notifier_added = group.detect do |name, _|
+          add_notifier(name, silent: true)
+        end
+        available ||= notifier_added
+      end
+
+      return if available
+      ::Guard::UI.info \
+        "Guard could not detect any of the supported notification libraries."
+    end
+  end
+end

data/lib/guard/notifiers/tmux.rb.orig

@@ -0,0 +1,339 @@
+require "guard/notifiers/base"
+
+module Guard
+  module Notifier
+    # Changes the color of the Tmux status bar and optionally
+    # shows messages in the status bar.
+    #
+    # @example Add the `:tmux` notifier to your `Guardfile`
+    #   notification :tmux
+    #
+    # @example Enable text messages
+    #   notification :tmux, display_message: true
+    #
+    # @example Customize the tmux status colored for notifications
+    #   notification :tmux, color_location: 'status-right-bg'
+    #
+    class Tmux < Base
+      # Default options for the tmux notifications.
+      DEFAULTS = {
+        client:                 "tmux",
+        tmux_environment:       "TMUX",
+        success:                "green",
+        failed:                 "red",
+        pending:                "yellow",
+        default:                "green",
+        timeout:                5,
+        display_message:        false,
+        default_message_format: "%s - %s",
+        default_message_color:  "white",
+        display_on_all_clients: false,
+        display_title:          false,
+        default_title_format:   "%s - %s",
+        line_separator:         " - ",
+        change_color:           true,
+        color_location:         "status-left-bg"
+      }
+
+      ERROR_NOT_INSIDE_SESSION = "The :tmux notifier runs only on when Guard"\
+              " is executed inside of a tmux session."
+
+      def self.available?(opts = {})
+        super && _register!(opts)
+      end
+
+      # @private
+      #
+      # @return [Boolean] whether or not a TMUX environment is available
+      #
+      def self._tmux_environment_available?(opts)
+        !ENV[opts.fetch(:tmux_environment, DEFAULTS[:tmux_environment])].nil?
+      end
+
+      # @private
+      #
+      # Detects if a TMUX environment is available and if not,
+      # displays an error message unless `opts[:silent]` is true.
+      #
+      # @return [Boolean] whether or not a TMUX environment is available
+      #
+      def self._register!(opts)
+        @options_stored = false
+        if _tmux_environment_available?(opts)
+          true
+        else
+          unless opts[:silent]
+            ::Guard::UI.error ERROR_NOT_INSIDE_SESSION
+          end
+          false
+        end
+      end
+
+      # Shows a system notification.
+      #
+      # By default, the Tmux notifier only makes
+      # use of a color based notification, changing the background color of the
+      # `color_location` to the color defined in either the `success`,
+      # `failed`, `pending` or `default`, depending on the notification type.
+      #
+      # You may enable an extra explicit message by setting `display_message`
+      # to true, and may further disable the colorization by setting
+      # `change_color` to false.
+      #
+      # @param [String] title the notification title
+      # @param [Hash] opts additional notification library options
+      # @option opts [String] type the notification type. Either 'success',
+      #   'pending', 'failed' or 'notify'
+      # @option opts [String] message the notification message body
+      # @option opts [String] image the path to the notification image
+      # @option opts [Boolean] change_color whether to show a color
+      #   notification
+      # @option opts [String,Array] color_location the location where to draw
+      #   the color notification
+      # @option opts [Boolean] display_message whether to display a message
+      #   or not
+      # @option opts [Boolean] display_on_all_clients whether to display a
+      #   message on all tmux clients or not
+      #
+      def notify(message, opts = {})
+        super
+        opts.delete(:image)
+
+        if opts.fetch(:change_color, DEFAULTS[:change_color])
+          options = opts.fetch(:color_location, DEFAULTS[:color_location])
+          color_locations = Array(options)
+          color = tmux_color(opts[:type], opts)
+
+          color_locations.each do |color_location|
+            _run_client "set", "#{self.class._quiet_option}"\
+              "#{color_location} #{color}"
+          end
+        end
+
+        type  = opts.delete(:type).to_s
+        title = opts.delete(:title)
+
+        if opts.fetch(:display_title, DEFAULTS[:display_title])
+          display_title(type, title, message, opts)
+        end
+
+        return unless opts.fetch(:display_message, DEFAULTS[:display_message])
+        display_message(type, title, message, opts)
+      end
+
+      # Displays a message in the title bar of the terminal.
+      #
+      # @param [String] title the notification title
+      # @param [String] message the notification message body
+      # @param [Hash] options additional notification library options
+      # @option options [String] success_message_format a string to use as
+      #   formatter for the success message.
+      # @option options [String] failed_message_format a string to use as
+      #   formatter for the failed message.
+      # @option options [String] pending_message_format a string to use as
+      #   formatter for the pending message.
+      # @option options [String] default_message_format a string to use as
+      #   formatter when no format per type is defined.
+      #
+      def display_title(type, title, message, opts = {})
+        format = "#{type}_title_format".to_sym
+        defaults = DEFAULTS[:default_title_format]
+        options = opts.fetch(:default_title_format, defaults)
+        title_format   = opts.fetch(format, options)
+        teaser_message = message.split("\n").first
+        display_title  = title_format % [title, teaser_message]
+
+        _run_client "set-option", "#{self.class._quiet_option}"\
+          "set-titles-string '#{display_title}'"
+      end
+
+      # Displays a message in the status bar of tmux.
+      #
+      # @param [String] type the notification type. Either 'success',
+      #   'pending', 'failed' or 'notify'
+      # @param [String] title the notification title
+      # @param [String] message the notification message body
+      # @param [Hash] options additional notification library options
+      # @option options [Integer] timeout the amount of seconds to show the
+      #   message in the status bar
+      # @option options [String] success_message_format a string to use as
+      #   formatter for the success message.
+      # @option options [String] failed_message_format a string to use as
+      #   formatter for the failed message.
+      # @option options [String] pending_message_format a string to use as
+      #   formatter for the pending message.
+      # @option options [String] default_message_format a string to use as
+      #   formatter when no format per type is defined.
+      # @option options [String] success_message_color the success notification
+      #   foreground color name.
+      # @option options [String] failed_message_color the failed notification
+      #   foreground color name.
+      # @option options [String] pending_message_color the pending notification
+      #   foreground color name.
+      # @option options [String] default_message_color a notification
+      #   foreground color to use when no color per type is defined.
+      # @option options [String] line_separator a string to use instead of a
+      #   line-break.
+      #
+      def display_message(type, title, message, opts = {})
+        default_format = DEFAULTS[:default_message_format]
+        default_format = opts.fetch(:default_message_format, default_format)
+        format = "#{type}_message_format".to_sym
+        message_format = opts.fetch(format, default_format)
+
+        default_color = DEFAULTS[:default_message_color]
+        default_color = opts.fetch(:default_message_color, default_color)
+        color = "#{type}_message_color".to_sym
+        message_color = opts.fetch(color, default_color)
+
+        display_time = opts.fetch(:timeout, DEFAULTS[:timeout])
+        separator = opts.fetch(:line_separator, DEFAULTS[:line_separator])
+
+        color = tmux_color type, opts
+        formatted_message = message.split("\n").join(separator)
+        display_message = message_format % [title, formatted_message]
+
+        _run_client(
+          "set",
+          "#{self.class._quiet_option}display-time #{display_time * 1000}")
+
+        _run_client "set", "#{self.class._quiet_option}"\
+          "message-fg #{message_color}"
+        _run_client "set", "#{self.class._quiet_option}"\
+          "message-bg #{color}"
+        _run_client "display-message", "'#{display_message}'"
+      end
+
+      # Get the Tmux color for the notification type.
+      # You can configure your own color by overwriting the defaults.
+      #
+      # @param [String] type the notification type
+      # @return [String] the name of the emacs color
+      #
+      def tmux_color(type, opts = {})
+        type = type.to_sym
+
+        opts[type] || DEFAULTS[type] || opts[:default] || DEFAULTS[:default]
+      end
+
+      # Notification starting, save the current Tmux settings
+      # and quiet the Tmux output.
+      #
+      def self.turn_on
+        unless @options_stored
+          _reset_options_store
+
+          _clients.each do |client|
+            @options_store[client].merge!(_options_for_client(client))
+          end
+
+          @options_stored = true
+        end
+      end
+
+      # Notification stopping. Restore the previous Tmux state
+      # if available (existing options are restored, new options
+      # are unset) and unquiet the Tmux output.
+      #
+      def self.turn_off
+        if @options_stored
+          @options_store.each do |client, options|
+            options.each do |key, value|
+              args = [
+                DEFAULTS[:client], "set", "-t",
+                client, _quiet_option.strip
+              ]
+              args << "-u" unless value
+              args << key
+              args << value if value
+              Sheller.run(args.join(" "))
+            end
+          end
+          _reset_options_store
+        end
+      end
+
+      def self.options_store
+        @options_store ||= {}
+      end
+
+      private
+
+      def self._clients
+        args = [DEFAULTS[:client], "list-clients", "-F", "'\#{client_tty}'"]
+        ttys = Sheller.stdout(args.join(" "))
+        ttys = ttys.split(/\n/)
+
+        # if user is running 'tmux -C' remove this client from list
+        ttys.delete("(null)")
+
+        ttys
+      end
+
+      def self._options_for_client(client)
+        options = {}
+
+        lines = Sheller.stdout("#{DEFAULTS[:client]} show -t #{client}")
+
+        lines.each_line do |line|
+          option, _, setting = line.chomp.partition(" ")
+          options[option] = setting
+        end
+
+        options
+      end
+
+      def _clients
+        self.class._clients
+      end
+
+      def _run_client(cmd, args)
+        default = DEFAULTS[:display_on_all_clients]
+        all_clients = @options.fetch(:display_on_all_clients, default)
+        clients = all_clients ? _clients : [nil]
+        clients.each do |client|
+          cmd_args = if client
+                       "#{_client_cmd_flag(cmd)} #{client.strip} #{args}"
+                     else
+                       args
+                     end
+          Sheller.run("#{DEFAULTS[:client]} #{cmd} #{cmd_args}")
+        end
+      end
+
+      def _client_cmd_flag(cmd)
+        case cmd
+        when "set", "set-option" then "-t"
+        when "display-message" then "-c"
+        end
+      end
+
+      # Reset the internal Tmux options store defaults.
+      #
+      def self._reset_options_store
+        @options_stored = false
+        @options_store = {}
+
+        _clients.each do |client|
+          @options_store[client] = {
+            "status-left-bg"  => nil,
+            "status-right-bg" => nil,
+            "status-left-fg"  => nil,
+            "status-right-fg" => nil,
+            "message-bg"      => nil,
+            "message-fg"      => nil,
+            "display-time"    => nil
+          }
+        end
+      end
+
+      def self._tmux_version
+        @@tmux_version ||= Float(Sheller.stdout("tmux -V")[/\d+\.\d+/])
+      end
+
+      def self._quiet_option
+        "-q " if _tmux_version >= 1.7
+      end
+    end
+  end
+end

data/lib/guard/version.rb

@@ -1,3 +1,3 @@
 module Guard
-  VERSION = "2.8.1"
+  VERSION = "2.8.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: guard
 version: !ruby/object:Gem::Version
-  version: 2.8.1
+  version: 2.8.2
 platform: ruby
 authors:
 - Thibaud Guillaume-Gentil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-05 00:00:00.000000000 Z
+date: 2014-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -131,12 +131,14 @@ files:
 - lib/guard/interactor.rb
 - lib/guard/internals/debugging.rb
 - lib/guard/internals/debugging.rb.orig
+- lib/guard/internals/environment.rb.orig
 - lib/guard/internals/tracing.rb
 - lib/guard/internals/tracing.rb.orig
 - lib/guard/jobs/base.rb
 - lib/guard/jobs/pry_wrapper.rb
 - lib/guard/jobs/sleep.rb
 - lib/guard/notifier.rb
+- lib/guard/notifier.rb.orig
 - lib/guard/notifiers/base.rb
 - lib/guard/notifiers/base.rb.orig
 - lib/guard/notifiers/emacs.rb
@@ -149,6 +151,7 @@ files:
 - lib/guard/notifiers/terminal_notifier.rb
 - lib/guard/notifiers/terminal_title.rb
 - lib/guard/notifiers/tmux.rb
+- lib/guard/notifiers/tmux.rb.orig
 - lib/guard/options.rb
 - lib/guard/plugin.rb
 - lib/guard/plugin/base.rb