notiffany 0.0.2

data/lib/notiffany/notifier/detected.rb

@@ -0,0 +1,113 @@
+require "nenv"
+
+require_relative "emacs"
+require_relative "file"
+require_relative "gntp"
+require_relative "growl"
+require_relative "libnotify"
+require_relative "notifysend"
+require_relative "rb_notifu"
+require_relative "terminal_notifier"
+require_relative "terminal_title"
+require_relative "tmux"
+
+module Notiffany
+  class Notifier
+    # @private api
+
+    # TODO: use a socket instead of passing env variables to child processes
+    # (currently probably only used by guard-cucumber anyway)
+    YamlEnvStorage = Nenv::Builder.build do
+      create_method(:notifiers=) { |data| YAML::dump(data) }
+      create_method(:notifiers) { |data| data ? YAML::load(data) : [] }
+    end
+
+    # @private api
+    class Detected
+      NO_SUPPORTED_NOTIFIERS = "Notiffany could not detect any of the"\
+        " supported notification libraries."
+
+      class NoneAvailableError < RuntimeError
+      end
+
+      class UnknownNotifier < RuntimeError
+        def initialize(name)
+          super
+          @name = name
+        end
+
+        def name
+          @name
+        end
+
+        def message
+          "Unknown notifier: #{@name.inspect}"
+        end
+      end
+
+      def initialize(supported, env_namespace, logger)
+        @supported = supported
+        @environment = YamlEnvStorage.new(env_namespace)
+        @logger = logger
+      end
+
+      def reset
+        @environment.notifiers = nil
+      end
+
+      def detect
+        return unless _data.empty?
+        @supported.each do |group|
+          group.detect do |name, _|
+            begin
+              add(name, {})
+              true
+            rescue Notifier::Base::UnavailableError => e
+              @logger.debug "Notiffany: #{name} not available (#{e.message})."
+              false
+            end
+          end
+        end
+
+        fail NoneAvailableError, NO_SUPPORTED_NOTIFIERS if _data.empty?
+      end
+
+      def available
+        @available ||= _data.map do |entry|
+          _to_module(entry[:name]).new(entry[:options])
+        end
+      end
+
+      def add(name, opts)
+        @available = nil
+        all = @environment.notifiers
+
+        # Silently skip if it's already available, because otherwise
+        # we'd have to do :turn_off, then configure, then :turn_on
+        names = all.map(&:first).map(&:last)
+        unless names.include?(name)
+          fail UnknownNotifier, name unless (klass = _to_module(name))
+
+          klass.new(opts) # raises if unavailable
+          @environment.notifiers = all << { name: name, options: opts }
+        end
+
+        # Just overwrite the options (without turning the notifier off or on),
+        # so those options will be passed in next calls to notify()
+        all.each { |item| item[:options] = opts if item[:name] == name }
+      end
+
+      def _to_module(name)
+        @supported.each do |group|
+          next unless (notifier = group.detect { |n, _| n == name })
+          return notifier.last
+        end
+        nil
+      end
+
+      def _data
+        @environment.notifiers || []
+      end
+    end
+  end
+end

data/lib/notiffany/notifier/emacs.rb

@@ -0,0 +1,107 @@
+require "notiffany/notifier/base"
+require "shellany/sheller"
+
+module Notiffany
+  class Notifier
+    # Send a notification to Emacs with emacsclient
+    # (http://www.emacswiki.org/emacs/EmacsClient).
+    #
+    class Emacs < Base
+      DEFAULTS = {
+        client:    "emacsclient",
+        success:   "ForestGreen",
+        failed:    "Firebrick",
+        default:   "Black",
+        fontcolor: "White",
+      }
+
+      class Client
+        def initialize(options)
+          @client = options[:client]
+        end
+
+        def available?
+          emacs_eval("'1'")
+        end
+
+        def notify(color, bgcolor)
+          elisp = <<-EOF.gsub(/\s+/, " ").strip
+            (set-face-attribute 'mode-line nil
+                 :background "#{bgcolor}"
+                 :foreground "#{color}")
+          EOF
+          emacs_eval(elisp)
+        end
+
+        private
+
+        def emacs_eval(code)
+          Shellany::Sheller.run(@client, "--eval", code)
+        end
+      end
+
+      private
+
+      def _gem_name
+        nil
+      end
+
+      def _check_available(options)
+        return if Client.new(options).available?
+        fail UnavailableError, "Emacs client failed"
+      end
+
+      # Shows a system notification.
+      #
+      # @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 [String] image the path to the notification image
+      # @param [Hash] opts additional notification library options
+      # @option opts [String] success the color to use for success
+      #   notifications (default is 'ForestGreen')
+      # @option opts [String] failed the color to use for failure
+      #   notifications (default is 'Firebrick')
+      # @option opts [String] pending the color to use for pending
+      #   notifications
+      # @option opts [String] default the default color to use (default is
+      #   'Black')
+      # @option opts [String] client the client to use for notification
+      #   (default is 'emacsclient')
+      # @option opts [String, Integer] priority specify an int or named key
+      #   (default is 0)
+      #
+      def _perform_notify(_message, opts = {})
+        color     = _emacs_color(opts[:type], opts)
+        fontcolor = _emacs_color(:fontcolor, opts)
+        Client.new(opts).notify(fontcolor, color)
+      end
+
+      # Get the Emacs color for the notification type.
+      # You can configure your own color by overwrite the defaults.
+      #
+      # @param [String] type the notification type
+      # @param [Hash] options aditional notification options
+      #
+      # @option options [String] success the color to use for success
+      # notifications (default is 'ForestGreen')
+      #
+      # @option options [String] failed the color to use for failure
+      # notifications (default is 'Firebrick')
+      #
+      # @option options [String] pending the color to use for pending
+      # notifications
+      #
+      # @option options [String] default the default color to use (default is
+      # 'Black')
+      #
+      # @return [String] the name of the emacs color
+      #
+      def _emacs_color(type, options = {})
+        default = options.fetch(:default, DEFAULTS[:default])
+        options.fetch(type.to_sym, default)
+      end
+    end
+  end
+end

data/lib/notiffany/notifier/file.rb

@@ -0,0 +1,44 @@
+require "notiffany/notifier/base"
+
+module Notiffany
+  class Notifier
+    # Writes notifications to a file.
+    #
+    class File < Base
+      DEFAULTS = { format: "%s\n%s\n%s\n" }
+
+      private
+
+      # @param [Hash] opts some options
+      # @option opts [Boolean] path the path to a file where notification
+      #   message will be written
+      #
+      def _check_available(opts = {})
+        fail UnavailableError, "No :path option given" unless opts[:path]
+      end
+
+      # Writes the notification to a file. By default it writes type, title,
+      # and message separated by newlines.
+      #
+      # @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] format printf style format for file contents
+      # @option opts [String] path the path of where to write the file
+      #
+      def _perform_notify(message, opts = {})
+        fail UnavailableError, "No :path option given" unless opts[:path]
+
+        format = opts[:format]
+        ::File.write(opts[:path], format % [opts[:type], opts[:title], message])
+      end
+
+      def _gem_name
+        nil
+      end
+    end
+  end
+end

data/lib/notiffany/notifier/gntp.rb

@@ -0,0 +1,91 @@
+require "notiffany/notifier/base"
+
+module Notiffany
+  class Notifier
+    # System notifications using the
+    # [ruby_gntp](https://github.com/snaka/ruby_gntp) gem.
+    #
+    # This gem is available for OS X, Linux and Windows and sends system
+    # notifications to the following system notification frameworks through the
+    #
+    # [Growl Network Transport
+    # Protocol](http://www.growlforwindows.com/gfw/help/gntp.aspx):
+    #
+    # * [Growl](http://growl.info)
+    # * [Growl for Windows](http://www.growlforwindows.com)
+    # * [Growl for Linux](http://mattn.github.com/growl-for-linux)
+    # * [Snarl](https://sites.google.com/site/snarlapp)
+    class GNTP < Base
+      DEFAULTS = {
+        sticky: false
+      }
+
+      # Default options for the ruby gtnp client.
+      CLIENT_DEFAULTS = {
+        host:     "127.0.0.1",
+        password: "",
+        port:     23053
+      }
+
+      def _supported_hosts
+        %w(darwin linux freebsd openbsd sunos solaris mswin mingw cygwin)
+      end
+
+      def _gem_name
+        "ruby_gntp"
+      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 [String] host the hostname or IP address to which to send
+      #   a remote notification
+      # @option opts [String] password the password used for remote
+      #   notifications
+      # @option opts [Integer] port the port to send a remote notification
+      # @option opts [Boolean] sticky make the notification sticky
+      #
+      def _perform_notify(message, opts = {})
+        opts = {
+          name: opts[:type].to_s,
+          text: message,
+          icon: opts[:image]
+        }.merge(opts)
+
+        _gntp_client(opts).notify(opts)
+      end
+
+      private
+
+      def _gntp_client(opts = {})
+        @_client ||= begin
+          gntp = ::GNTP.new(
+            "Notiffany",
+            opts.fetch(:host) { CLIENT_DEFAULTS[:host] },
+            opts.fetch(:password) { CLIENT_DEFAULTS[:password] },
+            opts.fetch(:port) { CLIENT_DEFAULTS[:port] }
+          )
+
+          gntp.register(
+            app_icon: _image_path(:guard),
+            notifications: [
+              { name: "notify", enabled: true },
+              { name: "failed", enabled: true },
+              { name: "pending", enabled: true },
+              { name: "success", enabled: true }
+            ]
+          )
+          gntp
+        end
+      end
+    end
+  end
+end

data/lib/notiffany/notifier/growl.rb

@@ -0,0 +1,81 @@
+require "notiffany/notifier/base"
+
+module Notiffany
+  class Notifier
+    # System notifications using the
+    # [growl](https://github.com/visionmedia/growl) gem.
+    #
+    # This gem is available for OS X and sends system notifications to
+    # [Growl](http://growl.info) through the
+    # [GrowlNotify](http://growl.info/downloads) executable.
+    #
+    # The `growlnotify` executable must be installed manually or by using
+    # [Homebrew](http://mxcl.github.com/homebrew/).
+    #
+    # Sending notifications with this notifier will not show the different
+    # notifications in the Growl preferences. Use the :gntp notifier if you
+    # want to customize each notification type in Growl.
+    #
+    # @example Install `growlnotify` with Homebrew
+    #   brew install growlnotify
+    #
+    # @example Add the `growl` gem to your `Gemfile`
+    #   group :development
+    #     gem 'growl'
+    #   end
+    #
+    # @example Add the `:growl` notifier to your `Guardfile`
+    #   notification :growl
+    #
+    # @example Add the `:growl_notify` notifier with configuration options to
+    # your `Guardfile` notification :growl, sticky: true, host: '192.168.1.5',
+    # password: 'secret'
+    #
+    class Growl < Base
+      INSTALL_GROWLNOTIFY = "Please install the 'growlnotify' executable'\
+    ' (available by installing the 'growl' gem)."
+
+      # Default options for the growl notifications.
+      DEFAULTS = {
+        sticky:   false,
+        priority: 0
+      }
+
+      def _supported_hosts
+        %w(darwin)
+      end
+
+      def _check_available(_opts = {})
+        fail UnavailableError, INSTALL_GROWLNOTIFY unless ::Growl.installed?
+      end
+
+      # Shows a system notification.
+      #
+      # The documented options are for GrowlNotify 1.3, but the older options
+      # are also supported. Please see `growlnotify --help`.
+      #
+      # Priority can be one of the following named keys: `Very Low`,
+      # `Moderate`, `Normal`, `High`, `Emergency`. It can also be an integer
+      # between -2 and 2.
+      #
+      # @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 [Boolean] sticky make the notification sticky
+      # @option opts [String, Integer] priority specify an int or named key
+      #   (default is 0)
+      # @option opts [String] host the hostname or IP address to which to
+      #   send a remote notification
+      # @option opts [String] password the password used for remote
+      #   notifications
+      #
+      def _perform_notify(message, opts = {})
+        opts = { name: "Notiffany" }.merge(opts)
+        ::Growl.notify(message, opts)
+      end
+    end
+  end
+end

data/lib/notiffany/notifier/libnotify.rb

@@ -0,0 +1,54 @@
+require "notiffany/notifier/base"
+
+module Notiffany
+  class Notifier
+    # System notifications using the
+    # [libnotify](https://github.com/splattael/libnotify) gem.
+    #
+    # This gem is available for Linux, FreeBSD, OpenBSD and Solaris and sends
+    # system notifications to
+    # Gnome [libnotify](http://developer.gnome.org/libnotify):
+    #
+    class Libnotify < Base
+      DEFAULTS = {
+        transient: false,
+        append:    true,
+        timeout:   3
+      }
+
+      private
+
+      def _supported_hosts
+        %w(linux freebsd openbsd sunos solaris)
+      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 [Boolean] transient keep the notifications around after
+      #   display
+      # @option opts [Boolean] append append onto existing notification
+      # @option opts [Number, Boolean] timeout the number of seconds to display
+      #   (1.5 (s), 1000 (ms), false)
+      #
+      def _perform_notify(message, opts = {})
+        opts = opts.merge(
+          summary: opts[:title],
+          icon_path: opts[:image],
+          body: message,
+          urgency: opts[:urgency] || (opts[:type] == "failed" ? :normal : :low)
+        )
+
+        ::Libnotify.show(opts)
+      end
+    end
+  end
+end