notiffany 0.0.2

data/lib/notiffany/notifier/notifysend.rb

@@ -0,0 +1,84 @@
+require "notiffany/notifier/base"
+
+require "shellany/sheller"
+
+module Notiffany
+  class Notifier
+    # System notifications using notify-send, a binary that ships with
+    # the libnotify-bin package on many Debian-based distributions.
+    #
+    # @example Add the `:notifysend` notifier to your `Guardfile`
+    #   notification :notifysend
+    #
+    class NotifySend < Base
+      # Default options for the notify-send notifications.
+      DEFAULTS = {
+        t: 3000, # Default timeout is 3000ms
+        h: "int:transient:1" # Automatically close the notification
+      }
+
+      # Full list of options supported by notify-send.
+      SUPPORTED = [:u, :t, :i, :c, :h]
+
+      private
+
+      def _supported_hosts
+        %w(linux freebsd openbsd sunos solaris)
+      end
+
+      def _check_available(_opts = {})
+        return true unless Shellany::Sheller.stdout("which notify-send").empty?
+
+        fail UnavailableError, "libnotify-bin package is not installed"
+      end
+
+      # Shows a system notification.
+      #
+      # @param [String] message the notification message body
+      # @param [Hash] opts additional notification library options
+      # @option opts [String] type the notification type. Either 'success',
+      #   'pending', 'failed' or 'notify'
+      # @option opts [String] title the notification title
+      # @option opts [String] image the path to the notification image
+      # @option opts [String] c the notification category
+      # @option opts [Number] t the number of milliseconds to display (1000,
+      #   3000)
+      #
+      def _perform_notify(message, opts = {})
+        command = [opts[:title], message]
+        opts = opts.merge(
+          i: opts[:i] || opts[:image],
+          u: opts[:u] || _notifysend_urgency(opts[:type])
+        )
+
+        Shellany::Sheller.
+          run("notify-send", *_to_arguments(command, SUPPORTED, opts))
+      end
+
+      # Converts Guards notification type to the best matching
+      # notify-send urgency.
+      #
+      # @param [String] type the Guard notification type
+      # @return [String] the notify-send urgency
+      #
+      def _notifysend_urgency(type)
+        { failed: "normal", pending: "low" }.fetch(type, "low")
+      end
+
+      # Builds a shell command out of a command string and option hash.
+      #
+      # @param [String] command the command execute
+      # @param [Array] supported list of supported option flags
+      # @param [Hash] opts additional command options
+      #
+      # @return [Array<String>] the command and its options converted to a
+      # shell command.
+      #
+      def _to_arguments(command, supported, opts = {})
+        opts.inject(command) do |cmd, (flag, value)|
+          supported.include?(flag) ? (cmd << "-#{ flag }" << value.to_s) : cmd
+        end
+      end
+    end
+  end
+end

data/lib/notiffany/notifier/rb_notifu.rb

@@ -0,0 +1,89 @@
+require "notiffany/notifier/base"
+
+module Notiffany
+  class Notifier
+    # System notifications using the
+    # [rb-notifu](https://github.com/stereobooster/rb-notifu) gem.
+    #
+    # This gem is available for Windows and sends system notifications to
+    # [Notifu](http://www.paralint.com/projects/notifu/index.html):
+    #
+    # @example Add the `rb-notifu` gem to your `Gemfile`
+    #   group :development
+    #     gem 'rb-notifu'
+    #   end
+    #
+    class Notifu < Base
+      # Default options for the rb-notifu notifications.
+      DEFAULTS = {
+        time:    3,
+        icon:    false,
+        baloon:  false,
+        nosound: false,
+        noquiet: false,
+        xp:      false
+      }
+
+      private
+
+      def _supported_hosts
+        %w(mswin mingw)
+      end
+
+      def _gem_name
+        "rb-notifu"
+      end
+
+      def _check_available(_opts = {})
+      end
+
+      # Shows a system notification.
+      #
+      # @param [String] message the notification message body
+      # @param [Hash] opts additional notification library options
+      # @option opts [String] type the notification type. Either 'success',
+      #   'pending', 'failed' or 'notify'
+      # @option opts [String] title the notification title
+      # @option opts [String] image the path to the notification image
+      # @option opts [Number] time the number of seconds to display (0 for
+      #   infinit)
+      # @option opts [Boolean] icon specify an icon to use ("parent" uses the
+      #   icon of the parent process)
+      # @option opts [Boolean] baloon enable ballon tips in the registry (for
+      #   this user only)
+      # @option opts [Boolean] nosound do not play a sound when the tooltip is
+      #   displayed
+      # @option opts [Boolean] noquiet show the tooltip even if the user is in
+      #   the quiet period that follows his very first login (Windows 7 and up)
+      # @option opts [Boolean] xp use IUserNotification interface event when
+      #   IUserNotification2 is available
+      #
+      def _perform_notify(message, opts = {})
+        options = opts.dup
+        options[:type] = _notifu_type(opts[:type])
+        options[:message] = message
+
+        # The empty block is needed until
+        # https://github.com/stereobooster/rb-notifu/pull/1 is merged
+        ::Notifu.show(options) {}
+      end
+
+      # Converts generic notification type to the best matching
+      # Notifu type.
+      #
+      # @param [String] type the generic notification type
+      # @return [Symbol] the Notify notification type
+      #
+      def _notifu_type(type)
+        case type.to_sym
+        when :failed
+          :error
+        when :pending
+          :warn
+        else
+          :info
+        end
+      end
+    end
+  end
+end

data/lib/notiffany/notifier/terminal_notifier.rb

@@ -0,0 +1,59 @@
+require "notiffany/notifier/base"
+
+module Notiffany
+  class Notifier
+    # System notifications using the
+    #
+    # [terminal-notifier](https://github.com/Springest/terminal-notifier-guard)
+    #
+    # gem.
+    #
+    # This gem is available for OS X 10.8 Mountain Lion and sends notifications
+    # to the OS X notification center.
+    class TerminalNotifier < Base
+      DEFAULTS = { app_name: "Notiffany" }
+
+      ERROR_ONLY_OSX10 = "The :terminal_notifier only runs"\
+        " on Mac OS X 10.8 and later."
+
+      def _supported_hosts
+        %w(darwin)
+      end
+
+      def _gem_name
+        "terminal-notifier-guard"
+      end
+
+      def _check_available(_opts = {})
+        return if ::TerminalNotifier::Guard.available?
+        fail UnavailableError, ERROR_ONLY_OSX10
+      end
+
+      # Shows a system notification.
+      #
+      # @param [String] message the notification message body
+      # @param [Hash] opts additional notification library options
+      # @option opts [String] type the notification type. Either 'success',
+      #   'pending', 'failed' or 'notify'
+      # @option opts [String] title the notification title
+      # @option opts [String] image the path to the notification image (ignored)
+      # @option opts [String] app_name name of your app
+      # @option opts [String] execute a command
+      # @option opts [String] activate an app bundle
+      # @option opts [String] open some url or file
+      #
+      def _perform_notify(message, opts = {})
+        title = [opts[:app_name], opts[:type].downcase.capitalize].join(" ")
+        opts = {
+          title: title
+        }.merge(opts)
+        opts[:message] = message
+        opts[:title] ||= title
+        opts.delete(:image)
+        opts.delete(:app_name)
+
+        ::TerminalNotifier::Guard.execute(false, opts)
+      end
+    end
+  end
+end

data/lib/notiffany/notifier/terminal_title.rb

@@ -0,0 +1,39 @@
+require "notiffany/notifier/base"
+
+module Notiffany
+  class Notifier
+    # Shows system notifications in the terminal title bar.
+    #
+    class TerminalTitle < Base
+      DEFAULTS = {}
+
+      # Clears the terminal title
+      def turn_off
+        STDOUT.puts "\e]2;\a"
+      end
+
+      private
+
+      def _gem_name
+        nil
+      end
+
+      def _check_available(_options)
+      end
+
+      # Shows a system notification.
+      #
+      # @param [Hash] opts additional notification library options
+      # @option opts [String] message the notification message body
+      # @option opts [String] type the notification type. Either 'success',
+      #   'pending', 'failed' or 'notify'
+      # @option opts [String] title the notification title
+      #
+      def _perform_notify(message, opts = {})
+        first_line = message.sub(/^\n/, "").sub(/\n.*/m, "")
+
+        STDOUT.puts "\e]2;[#{ opts[:title] }] #{ first_line }\a"
+      end
+    end
+  end
+end

data/lib/notiffany/notifier/tmux.rb

@@ -0,0 +1,355 @@
+require "notiffany/notifier/base"
+require "shellany/sheller"
+
+# TODO: this probably deserves a gem of it's own
+module Notiffany
+  class Notifier
+    # Changes the color of the Tmux status bar and optionally
+    # shows messages in the status bar.
+    class Tmux < Base
+      @session = nil
+
+      DEFAULTS = {
+        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"
+      }
+
+      class Client
+        CLIENT = "tmux"
+
+        class << self
+          def version
+            Float(_capture("-V")[/\d+\.\d+/])
+          end
+
+          def _capture(*args)
+            Shellany::Sheller.stdout(([CLIENT] + args).join(" "))
+          end
+
+          def _run(*args)
+            Shellany::Sheller.run(([CLIENT] + args).join(" "))
+          end
+        end
+
+        def initialize(client)
+          @client = client
+        end
+
+        def clients
+          return [@client] unless @client == :all
+          ttys = _capture("list-clients", "-F", "'\#{client_tty}'")
+          ttys = ttys.split(/\n/)
+
+          # if user is running 'tmux -C' remove this client from list
+          ttys.delete("(null)")
+          ttys
+        end
+
+        def set(key, value)
+          clients.each do |client|
+            args = client ? ["-t", client.strip] : nil
+            _run("set", "-q", *args, key, value)
+          end
+        end
+
+        def display_message(message)
+          clients.each do |client|
+            args += ["-c", client.strip] if client
+            # TODO: should properly escape message here
+            _run("display", *args, "'#{message}'")
+          end
+        end
+
+        def unset(key, value)
+          clients.each do |client|
+            args = client ? ["-t", client.strip] : []
+            if value
+              _run("set", "-q", *args, key, value)
+            else
+              _run("set", "-q", "-u", *args, key)
+            end
+          end
+        end
+
+        def parse_options
+          output = _capture("show", "-t", @client)
+          Hash[output.lines.map { |line| _parse_option(line) }]
+        end
+
+        def message_fg=(color)
+          set("message-fg", color)
+        end
+
+        def message_bg=(color)
+          set("message-bg", color)
+        end
+
+        def display_time=(time)
+          set("display-time", time)
+        end
+
+        def title=(string)
+          # TODO: properly escape?
+          set("set-titles-string", "'#{string}'")
+        end
+
+        private
+
+        def _run(*args)
+          self.class._run(*args)
+        end
+
+        def _capture(*args)
+          self.class._capture(*args)
+        end
+
+        def _parse_option(line)
+          line.partition(" ").map(&:strip).reject(&:empty?)
+        end
+      end
+
+      class Session
+        def initialize
+          @options_store = {}
+
+          # NOTE: we are reading the settings of all clients
+          # - regardless of the :display_on_all_clients option
+
+          # Ideally, this should be done incrementally (e.g. if we start with
+          # "current" client and then override the :display_on_all_clients to
+          # true, only then the option store should be updated to contain
+          # settings of all clients
+          Client.new(:all).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
+            }.merge(Client.new(client).parse_options)
+          end
+        end
+
+        def close
+          @options_store.each do |client, options|
+            options.each do |key, value|
+              Client.new(client).unset(key, value)
+            end
+          end
+          @options_store = nil
+        end
+      end
+
+      class Error < RuntimeError
+      end
+
+      ERROR_NOT_INSIDE_TMUX = ":tmux notifier is only available inside a "\
+        "TMux session."
+
+      ERROR_ANCIENT_TMUX = "Your tmux version is way too old (%s)!"
+
+      # Notification starting, save the current Tmux settings
+      # and quiet the Tmux output.
+      #
+      def turn_on
+        self.class._start_session
+      end
+
+      # Notification stopping. Restore the previous Tmux state
+      # if available (existing options are restored, new options
+      # are unset) and unquiet the Tmux output.
+      #
+      def turn_off
+        self.class._end_session
+      end
+
+      private
+
+      def _gem_name
+        nil
+      end
+
+      def _check_available(opts = {})
+        @session ||= nil # to avoid unitialized error
+        fail "PREVIOUS TMUX SESSION NOT CLEARED!" if @session
+
+        var_name = opts[:tmux_environment]
+        fail Error, ERROR_NOT_INSIDE_TMUX unless ENV.key?(var_name)
+
+        version = Client.version
+        fail Error, format(ERROR_ANCIENT_TMUX, version) if version < 1.7
+
+        true
+      rescue Error => e
+        fail UnavailableError, e.message
+      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] message the notification message
+      # @param [Hash] options additional notification library options
+      # @option options [String] type the notification type. Either 'success',
+      #   'pending', 'failed' or 'notify'
+      # @option options [String] message the notification message body
+      # @option options [String] image the path to the notification image
+      # @option options [Boolean] change_color whether to show a color
+      #   notification
+      # @option options [String,Array] color_location the location where to draw
+      #   the color notification
+      # @option options [Boolean] display_message whether to display a message
+      #   or not
+      # @option options [Boolean] display_on_all_clients whether to display a
+      #   message on all tmux clients or not
+      #
+      def _perform_notify(message, options = {})
+        change_color = options[:change_color]
+        locations = Array(options[:color_location])
+        display_the_title = options[:display_title]
+        display_message = options[:display_message]
+        type  = options[:type].to_s
+        title = options[:title]
+
+        if change_color
+          color = _tmux_color(type, options)
+          locations.each do |location|
+            Client.new(client(options)).set(location, color)
+          end
+        end
+
+        _display_title(type, title, message, options) if display_the_title
+
+        return unless display_message
+        _display_message(type, title, message, options)
+      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, options = {})
+        format = "#{type}_title_format".to_sym
+        default_title_format = options[:default_title_format]
+        title_format   = options.fetch(format, default_title_format)
+        teaser_message = message.split("\n").first
+        display_title  = title_format % [title, teaser_message]
+
+        Client.new(client(options)).title = 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 = opts[:default_message_format]
+        default_color = opts[:default_message_color]
+        display_time = opts[:timeout]
+        separator = opts[:line_separator]
+
+        format = "#{type}_message_format".to_sym
+        message_format = opts.fetch(format, default_format)
+
+        color = "#{type}_message_color".to_sym
+        message_color = opts.fetch(color, default_color)
+
+        color = _tmux_color(type, opts)
+        formatted_message = message.split("\n").join(separator)
+        msg = message_format % [title, formatted_message]
+
+        cl = Client.new(client(opts))
+        cl.display_time = display_time * 1000
+        cl.message_fg = message_color
+        cl.message_bg = color
+        cl.display_message(msg)
+      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] || opts[:default]
+      end
+
+      def self._start_session
+        fail "Already turned on!" if @session
+        @session = Session.new
+      end
+
+      def self._end_session
+        fail "Already turned off!" unless @session || nil
+        @session.close
+        @session = nil
+      end
+
+      def self._session
+        @session
+      end
+
+      def client(options)
+        options[:display_on_all_clients] ? :all : nil
+      end
+    end
+  end
+end