notiffany 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc2bea88badfaf2002b0a1b2ee78fe244f4761b5
+  data.tar.gz: df4e2e90efa30cd30c509d9bbce6f1f8b2165f37
+SHA512:
+  metadata.gz: afe03258470e5aeee7109879499a0831ad58d1309f9cf2649a03ac53465c83605b67205dbd7ac2d348ade5f05fa640bfa6bde3117cd785e052eea050ded1c973
+  data.tar.gz: 82bc83271bb750d27220ae3a73e3102292fe5659f3c8fee165343a697de1a3084dc545ad3eecf066b4287198a9a3f55e138caec29714e2f1f90d32323a0fe1c0

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+bundler_args: --without development
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.5
+  - ruby-head
+  - jruby
+  - rbx-2
+matrix:
+  allow_failures:
+    - rvm: rbx
+    - rvm: jruby

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in notiffany.gemspec
+gemspec development_group: :gem_build_tools
+
+gem "rake", "~> 10.0"
+gem 'nenv', "~> 0.1"
+
+group :test do
+  gem "rspec", "~> 3.1"
+end
+
+group :development do
+  gem 'guard-rspec', "~> 4.5", require: false
+end

data/Guardfile

@@ -0,0 +1,56 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec feature)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Make Guard exit when config is changed so it can be restarted
+#
+## Note: if you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+#
+#  $ while bundle exec guard; do echo "Restarting Guard..."; done
+#
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), the you will want to move the Guardfile
+## to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+#
+watch ("Guardfile") do
+  UI.info "Exiting because Guard must be restarted for changes to take effect"
+  exit 0
+end
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Cezary Baginski
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# Notiffany
+
+Notification library supporting popular notifiers, such as:
+- Growl
+- libnotify
+- TMux
+- Emacs
+- rb-notifu
+- notifysend
+- gntp
+- TerminalNotifier
+
+## Features
+- most popular notification libraries supported
+- easy to override options at any level (new(), notify())
+- using multiple notifiers simultaneously
+- child processes reuse same configuration
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'notiffany'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install notiffany
+
+## Usage
+
+Basic notification
+
+```ruby
+notifier = Notiffany.connect(title: "A message")
+notifier.notify("Hello there!", image: :success)
+notifier.disconnect # some plugins like TMux and TerminalTitle rely on this
+```
+
+Enabling/disabling and on/off
+
+### disable with option
+
+```ruby
+notifier = Notiffany.connect(notify: false)
+notifier.notify('hello') # does nothing
+```
+
+### switch on/off using methods
+
+```ruby
+notifier = Notiffany.connect
+notifier.turn_off
+notifier.turn_on
+notifier.toggle
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/notiffany/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+require 'nenv'
+
+default_tasks = []
+
+require 'rspec/core/rake_task'
+default_tasks  << RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = Nenv.ci?
+end
+
+task default: default_tasks.map(&:name)
+

data/lib/notiffany.rb

@@ -0,0 +1,6 @@
+require "notiffany/version"
+require "notiffany/notifier"
+
+module Notiffany
+  # Your code goes here...
+end

data/lib/notiffany/notifier.rb

@@ -0,0 +1,205 @@
+require "yaml"
+require "rbconfig"
+require "pathname"
+require "nenv"
+require "logger"
+
+require "notiffany/notifier/detected"
+
+module Notiffany
+  # 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.
+  #
+  # Notiffany 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.
+  #
+  # Notiffany can be configured to make use of more than one notifier at once.
+  #
+  def self.connect(options = {})
+    Notifier.new(options)
+  end
+
+  class Notifier
+    DEFAULTS = { notify: true }
+
+    NOTIFICATIONS_DISABLED = "Notifications disabled by GUARD_NOTIFY" +
+      " environment variable"
+
+    USING_NOTIFIER = "Notiffany is using %s to send notifications."
+
+    ONLY_NOTIFY = "Only notify() is available from a child process"
+
+    # List of available notifiers, grouped by functionality
+    SUPPORTED = [
+      {
+        gntp: GNTP,
+        growl: Growl,
+        terminal_notifier: TerminalNotifier,
+        libnotify: Libnotify,
+        notifysend: NotifySend,
+        notifu: Notifu
+      },
+      { emacs: Emacs },
+      { tmux: Tmux },
+      { terminal_title: TerminalTitle },
+      { file: File }
+    ]
+
+    Env = Nenv::Builder.build do
+      create_method(:notify?) { |data| data != "false" }
+      create_method(:notify_pid) { |data| data && Integer(data) }
+      create_method(:notify_pid=)
+      create_method(:notify_active?)
+      create_method(:notify_active=)
+    end
+
+    class NotServer < RuntimeError
+    end
+
+    def initialize(opts)
+      @env_namespace = opts.fetch(:namespace, "notiffany")
+      @logger = opts.fetch(:logger) do
+        Logger.new($stderr).tap { |l| l.level = Logger::WARN }
+      end
+
+
+      @detected = Detected.new(SUPPORTED, @env_namespace, @logger)
+      return if _client?
+
+      _env.notify_pid = $$
+
+      fail "Already connected" if active?
+
+      options = DEFAULTS.merge(opts)
+      return unless enabled? && options[:notify]
+
+      notifiers = opts.fetch(:notifiers, {})
+      if notifiers.any?
+        notifiers.each do |name, notifier_options|
+          @detected.add(name, notifier_options)
+        end
+      else
+        @detected.detect
+      end
+
+      turn_on
+    rescue Detected::NoneAvailableError => e
+      @logger.info e.to_s
+    end
+
+    def disconnect
+      if _client?
+        @detected = nil
+        return
+      end
+
+      turn_off if active?
+      @detected.reset unless @detected.nil?
+      _env.notify_pid = nil
+      @detected = nil
+    end
+
+    # Turn notifications on.
+    #
+    # @param [Hash] options the turn_on options
+    # @option options [Boolean] silent disable any logging
+    #
+    def turn_on(options = {})
+      _check_server!
+      return unless enabled?
+
+      fail "Already active!" if active?
+
+      silent = options[:silent]
+
+      @detected.available.each do |obj|
+        @logger.debug(format(USING_NOTIFIER, obj.title)) unless silent
+        obj.turn_on if obj.respond_to?(:turn_on)
+      end
+
+      _env.notify_active = true
+    end
+
+    # Turn notifications off.
+    def turn_off
+      _check_server!
+
+      fail "Not active!" unless active?
+
+      @detected.available.each do |obj|
+        obj.turn_off if obj.respond_to?(:turn_off)
+      end
+
+      _env.notify_active = false
+    end
+
+    # Test if the notifications can be enabled based on ENV['GUARD_NOTIFY']
+    def enabled?
+      _env.notify?
+    end
+
+    # Test if notifiers are currently turned on
+    def active?
+      _env.notify_active?
+    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, message_opts = {})
+      if _client?
+        return unless enabled?
+      else
+        return unless active?
+      end
+
+      @detected.available.each do |notifier|
+        notifier.notify(message, message_opts.dup)
+      end
+    end
+
+    def available
+      @detected.available
+    end
+
+    private
+
+    def _env
+      @environment ||= Env.new(@env_namespace)
+    end
+
+    def _check_server!
+      _client? && fail(NotServer, ONLY_NOTIFY)
+    end
+
+    def _client?
+      (pid = _env.notify_pid) && (pid != $$)
+    end
+  end
+end

data/lib/notiffany/notifier/base.rb

@@ -0,0 +1,126 @@
+require "rbconfig"
+
+module Notiffany
+  class Notifier
+    class Base
+      HOSTS = {
+        darwin:  "Mac OS X",
+        linux:   "Linux",
+        freebsd: "FreeBSD",
+        openbsd: "OpenBSD",
+        sunos:   "SunOS",
+        solaris: "Solaris",
+        mswin:   "Windows",
+        mingw:   "Windows",
+        cygwin:  "Windows"
+      }
+
+      ERROR_ADD_GEM_AND_RUN_BUNDLE = "Please add \"gem '%s'\" to your Gemfile "\
+        "and run your app with \"bundle exec\"."
+
+      class UnavailableError < RuntimeError
+        def initialize(reason)
+          super
+          @reason = reason
+        end
+
+        def message
+          @reason
+        end
+      end
+
+      class RequireFailed < UnavailableError
+        def initialize(gem_name)
+          super ERROR_ADD_GEM_AND_RUN_BUNDLE % gem_name
+        end
+      end
+
+      class UnsupportedPlatform < UnavailableError
+        def initialize
+          super "Unsupported platform #{RbConfig::CONFIG["host_os"].inspect}"
+        end
+      end
+
+      attr_reader :options
+
+      def initialize(opts = {})
+        options = opts.dup
+        options.delete(:silent)
+        @options =
+          { title: "Notiffany" }.
+          merge(self.class.const_get(:DEFAULTS)).
+          merge(options).freeze
+
+        @images_path = Pathname.new(__FILE__).dirname + "../../../images"
+
+        _check_host_supported
+        _require_gem
+        _check_available(@options)
+      end
+
+      def title
+        self.class.to_s[/.+::(\w+)$/, 1]
+      end
+
+      def name
+        title.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      end
+
+      def notify(message, opts = {})
+        new_opts = _notify_options(opts).freeze
+        _perform_notify(message, new_opts)
+      end
+
+      def _image_path(image)
+        images = [:failed, :pending, :success, :guard]
+        images.include?(image) ? @images_path.join("#{image}.png").to_s : image
+      end
+
+      private
+
+      # Override if necessary
+      def _gem_name
+        name
+      end
+
+      # Override if necessary
+      def _supported_hosts
+        :all
+      end
+
+      # Override
+      def _check_available(_options)
+        fail NotImplementedError
+      end
+
+      # Override
+      def _perform_notify(_message, _opts)
+        fail NotImplementedError
+      end
+
+      def _notification_type(image)
+        [:failed, :pending, :success].include?(image) ? image : :notify
+      end
+
+      def _notify_options(overrides = {})
+        opts = @options.merge(overrides)
+        img_type = opts.fetch(:image, :success)
+        opts[:type] ||= _notification_type(img_type)
+        opts[:image] = _image_path(img_type)
+        opts
+      end
+
+      def _check_host_supported
+        return if _supported_hosts == :all
+        expr = /#{_supported_hosts * '|'}/
+        fail UnsupportedPlatform unless expr.match(RbConfig::CONFIG["host_os"])
+      end
+
+      def _require_gem
+        Kernel.require _gem_name unless _gem_name.nil?
+      rescue LoadError, NameError
+        fail RequireFailed, _gem_name
+      end
+    end
+  end
+end