libnotify 0.5.1-universal-rubinius-1.2

data/.gitignore

@@ -0,0 +1,8 @@
+doc
+pkg
+coverage
+tags
+.yardoc
+.bundle
+Gemfile.lock
+*.rbc

data/.rvmrc

@@ -0,0 +1 @@
+rvm @libnotify --create

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+ - ree
+ - 1.9.2
+ - jruby

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.rdoc

@@ -0,0 +1,61 @@
+= Libnotify
+
+Ruby bindings for libnotify using FFI.
+
+Source[http://github.com/splattael/libnotify] |
+RDoc[http://rdoc.info/github/splattael/libnotify/master/file/README.rdoc]
+
+http://github.com/splattael/libnotify/raw/master/libnotify.png
+
+== Usage
+
+  require 'libnotify'
+
+  # Block syntax
+  n = Libnotify.new do |notify|
+    notify.summary    = "hello"
+    notify.body       = "world"
+    notify.timeout    = 1.5         # 1.5 (s), 1000 (ms), "2", nil, false
+    notify.urgency    = :critical   # :low, :normal, :critical
+    notify.append     = false       # default true - append onto existing notification
+    notify.icon_path  = "/usr/share/icons/gnome/scalable/emblems/emblem-default.svg"
+  end
+  n.show!
+
+  # Hash syntax
+  Libnotify.show(:body => "hello", :summary => "world", :timeout => 2.5)
+
+  # Mixed syntax
+  Libnotify.show(options) do |n|
+    n.timeout = 1.5     # overrides :timeout in options
+  end
+
+  # Icon path auto-detection
+  Libnotify.icon_dirs << "/usr/share/icons/gnome/*/"
+  Libnotify.show(:icon_path => "emblem-default.png")
+  Libnotify.show(:icon_path => :"emblem-default")
+
+== Installation
+
+  gem install libnotify
+
+You'll need libnotify. On Debian just type:
+
+  apt-get install libnotify1
+
+== Testing
+
+  git clone git://github.com/splattael/libnotify.git
+  cd libnotify
+  (gem install bundler)
+  bundle install
+  rake
+
+== Authors
+
+* Peter Suschlik (http://github.com/splattael)
+* Dennis Collective (http://github.com/denniscollective)
+
+== TODO
+
+* Mock FFI calls with rrriot. (test/test_libnotify.rb:61)

data/Rakefile

@@ -0,0 +1,66 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+SUPPORTED_RUBIES = %w[ree 1.9.2 jruby rbx]
+
+require 'rake'
+require 'rake/rdoctask'
+require 'rubygems'
+
+# Test
+require 'rake/testtask'
+desc 'Default: run unit tests.'
+task :default => :test
+
+Rake::TestTask.new(:test) do |test|
+  test.test_files = FileList.new('test/test_*.rb')
+  test.libs << 'test'
+  test.verbose = true
+end
+
+desc "Test with several ruby versions"
+task :"test:rubies" do
+  command = "bundle check || bundle install && rake"
+  SUPPORTED_RUBIES.each do |ruby|
+    rvm = "#{ruby}@libnotify"
+    puts "\n" * 3
+    puts "RVM: #{rvm}"
+    puts "=" * 40
+
+    system %{rvm #{rvm} exec bash -c '#{command}'}
+  end
+end
+
+# Yard
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end
+
+desc "Alias for `rake yard`"
+task :doc => :yard
+
+# Misc
+desc "Tag files for vim"
+task :ctags do
+  dirs = $LOAD_PATH.select {|path| File.directory?(path) }
+  system "ctags -R #{dirs.join(" ")}"
+end
+
+desc "Find whitespace at line ends"
+task :eol do
+  system "grep -nrE ' +$' *"
+end
+
+desc "Display TODOs"
+task :todo do
+  `grep -Inr TODO lib test`.each do |line|
+    line.scan(/^(.*?:.*?):\s*#\s*TODO\s*(.*)$/) do |(file, todo)|
+      puts "* #{todo} (#{file})"
+    end
+  end
+end

data/lib/libnotify/api.rb

@@ -0,0 +1,119 @@
+module Libnotify
+  # API for Libnotify
+  #
+  # @see Libnotify
+  class API
+    include FFI
+
+    attr_reader :timeout, :icon_path
+    attr_accessor :summary, :body, :urgency, :append
+
+    class << self
+      # List of globs to icons
+      attr_accessor :icon_dirs
+    end
+
+    self.icon_dirs = [
+      "/usr/share/icons/gnome/*/emblems",
+      "/usr/share/icons/gnome/*/emotes"
+    ]
+
+    # TODO refactor & test!
+    ICON_REGEX = /(\d+)x\d/
+    ICON_SORTER = proc do |a, b|
+      ma = a.scan ICON_REGEX
+      mb = b.scan ICON_REGEX
+
+      if ma.first && mb.first
+        mb.first.first.to_i <=> ma.first.first.to_i
+      elsif ma.first && !mb.first
+        1
+      elsif !ma.first && ma.first
+        -1
+      else
+        a <=> b
+      end
+    end
+
+    # Creates a notification object.
+    #
+    # @see Libnotify.new
+    def initialize(options={}, &block)
+      set_defaults
+      options.each { |key, value| send("#{key}=", value) if respond_to?(key) }
+      yield(self) if block_given?
+    end
+
+    def set_defaults
+      self.summary = self.body = ' '
+      self.urgency = :normal
+      self.timeout = nil
+      self.append = true
+    end
+    private :set_defaults
+
+    # Shows a notification.
+    #
+    # @see Libnotify.show
+    def show!
+      notify_init(self.class.to_s) or raise "notify_init failed"
+      notify = notify_notification_new(summary, body, icon_path, nil)
+      notify_notification_set_urgency(notify, lookup_urgency(urgency))
+      notify_notification_set_timeout(notify, timeout || -1)
+      if append
+        notify_notification_set_hint_string(notify, "x-canonical-append", "")
+        notify_notification_set_hint_string(notify, "append", "")
+      end
+      notify_notification_show(notify, nil)
+    ensure
+      notify_notification_clear_hints(notify) if append
+    end
+
+    # @todo Simplify timeout=
+    def timeout=(timeout)
+      @timeout = case timeout
+      when Float
+        timeout /= 10 if RUBY_VERSION == "1.8.6" # Strange workaround?
+        (timeout * 1000).to_i
+      when Fixnum
+        if timeout >= 100 # assume miliseconds
+          timeout
+        else
+          timeout * 1000
+        end
+      when NilClass, FalseClass
+        nil
+      else
+        timeout.to_s.to_i
+      end
+    end
+
+    # Sets icon path.
+    #
+    # Path can be absolute, relative (will be resolved) or an symbol.
+    #
+    # @todo document and refactor
+    def icon_path=(path)
+      case path
+      when /^\// # absolute
+        @icon_path = path
+      when String
+        list = self.class.icon_dirs.map { |d| Dir[File.join(d, path)] }.flatten.sort(&ICON_SORTER)
+        @icon_path = list.detect { |full_path| File.exist?(full_path) } || path
+      when Symbol
+        self.icon_path = "#{path}.png"
+      else
+        @icon_path = nil
+      end
+    end
+
+    # Creates and shows a notification. It's a shortcut for +Libnotify.new(options).show!+.
+    #
+    # @see Libnotify.show
+    # @see Libnotify.new
+    def self.show(options={}, &block)
+      new(options, &block).show!
+    end
+
+  end
+end

data/lib/libnotify/ffi.rb

@@ -0,0 +1,39 @@
+module Libnotify
+  # Raw FFI bindings.
+  module FFI
+    require 'ffi'
+    extend ::FFI::Library
+
+    def self.included(base)
+      ffi_lib %w[libnotify libnotify.so libnotify.so.1]
+      attach_functions!
+    rescue LoadError => e
+      warn e.message
+    end
+
+    URGENCY = [ :low, :normal, :critical ]
+
+    def self.attach_functions!
+      attach_function :notify_init,                         [:string],                              :bool
+      attach_function :notify_uninit,                       [],                                     :void
+      attach_function :notify_notification_new,             [:string, :string, :string, :pointer],  :pointer
+      attach_function :notify_notification_set_urgency,     [:pointer, :int],                       :void
+      attach_function :notify_notification_set_timeout,     [:pointer, :long],                      :void
+      attach_function :notify_notification_set_hint_string, [:pointer, :string, :string],           :void
+      attach_function :notify_notification_clear_hints,     [:pointer],                             :void
+      attach_function :notify_notification_show,            [:pointer, :pointer],                   :bool
+    end
+
+    def lookup_urgency(urgency)
+      URGENCY.index(urgency)
+    end
+
+    def method_missing(method, *args, &block)
+      if method.to_s =~ /^notify_/
+        warn "libnotify.so not found!"
+      end
+
+      super
+    end
+  end
+end

data/lib/libnotify/version.rb

@@ -0,0 +1,3 @@
+module Libnotify
+  VERSION = "0.5.1"
+end

data/lib/libnotify.rb

@@ -0,0 +1,58 @@
+# Ruby bindings for libnotify using FFI.
+#
+# See README.rdoc for usage examples.
+#
+# @see README.rdoc
+# @see Libnotify.new
+# @author Peter Suschlik
+module Libnotify
+  # Creates a notification.
+  #
+  # @example Block syntax
+  #   n = Libnotify.new do |notify|
+  #     notify.summary    = "hello"
+  #     notify.body       = "world"
+  #     notify.timeout    = 1.5         # 1.5 (s), 1000 (ms), "2", nil, false
+  #     notify.urgency    = :critical   # :low, :normal, :critical
+  #     notify.append     = false       # default true - append onto existing notification
+  #     notify.icon_path  = "/usr/share/icons/gnome/scalable/emblems/emblem-default.svg"
+  #   end
+  #   n.show!
+  #
+  # @example Hash syntax
+  #   Libnotify.show(:body => "hello", :summary => "world", :timeout => 2.5)
+  #
+  # @example Mixed syntax
+  #   Libnotify.new(options) do |n|
+  #     n.timeout = 1.5     # overrides :timeout in options
+  #     n.show!
+  #   end
+  #
+  # @param [Hash] options  options creating a notification
+  # @option options [String] :summary (' ') summary/title of the notification
+  # @option options [String] :body (' ') the body
+  # @option options [Fixnum, Float, nil, FalseClass, String] :timeout (nil) display duration of the notification.
+  #   Use +false+ or +nil+ for no timeout.
+  # @option options [Symbol] :urgency (:normal) the urgency of the notification.
+  #   Possible values are: +:low+, +:normal+ and +:critical+
+  # @option options [String] :icon_path path the an icon displayed.
+  #
+  # @yield [notify]   passes the notification object
+  # @yieldparam [API] notify the notification object
+  #
+  # @return [API] the notification object
+  def self.new(options={}, &block)
+    API.new(options, &block)
+  end
+
+  # Shows a notification. It takes the same +options+ as Libnotify.new.
+  #
+  # @see Libnotify.new
+  def self.show(options={}, &block)
+    API.show(options, &block)
+  end
+
+  autoload  :VERSION, 'libnotify/version'
+  autoload  :API,     'libnotify/api'
+  autoload  :FFI,     'libnotify/ffi'
+end

data/libnotify.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "libnotify"
+
+platform = Gem::Platform::CURRENT
+needs_ffi = true
+
+if RUBY_PLATFORM =~ /java/
+  needs_ffi = false
+elsif defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/
+  needs_ffi = false
+  platform = Gem::Platform::new ['universal', 'rubinius', '1.2']
+end
+
+Gem::Specification.new do |s|
+  s.name        = "libnotify"
+  s.version     = Libnotify::VERSION
+  s.platform    = platform
+  s.authors     = ["Peter Suschlik"]
+  s.email       = ["peter-libnotify@suschlik.de"]
+  s.homepage    = "http://rubygems.org/gems/libnotify"
+  s.summary     = %q{Ruby bindings for libnotify using FFI}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  if needs_ffi
+    s.add_runtime_dependency      'ffi',          '~> 1.0'
+  end
+
+  s.add_development_dependency  'minitest'
+  s.add_development_dependency  'yard',           '~> 0.7.0'
+end

data/test/helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'minitest/autorun'
+
+require 'libnotify'
+require 'libnotify_io'

data/test/libnotify_io.rb

@@ -0,0 +1,36 @@
+class LibnotifyIO
+  attr_reader :io, :libnotify
+
+  def initialize io
+    @io = io
+    @libnotify = begin
+      require 'libnotify'
+      Libnotify.new(:timeout => 2.5, :append => false)
+    end
+  end
+
+  def puts *o
+    if o.first =~ /(\d+) failures, (\d+) errors/
+      description = [ RUBY_ENGINE, RUBY_VERSION, RUBY_PLATFORM ].join(" ")
+      libnotify.body = o.first
+      if $1.to_i > 0 || $2.to_i > 0 # fail?
+        libnotify.summary = ":-( #{description}"
+        libnotify.urgency = :critical
+        libnotify.icon_path = "face-angry.*"
+      else
+        libnotify.summary += ":-) #{description}"
+        libnotify.urgency = :normal
+        libnotify.icon_path = "face-laugh.*"
+      end
+      libnotify.show!
+    else
+      io.puts *o
+    end
+  end
+
+  def method_missing msg, *args
+    io.send(msg, *args)
+  end
+end
+
+MiniTest::Unit.output = LibnotifyIO.new(MiniTest::Unit.output)

data/test/test_libnotify.rb

@@ -0,0 +1,109 @@
+require 'helper'
+
+class TestLibnotify < MiniTest::Unit::TestCase
+  def test_respond_to
+    assert_respond_to Libnotify, :new
+    assert_respond_to Libnotify, :show
+  end
+
+  def test_delegation
+    skip "test delegation using mock"
+
+    # old code
+    asserts("#new calls API#new") do
+      mock(Libnotify::API).new(hash_including(:body => "test")) { true }
+      Libnotify.new(:body => "test")
+    end
+    asserts("#show calls API#show") do
+      mock(Libnotify::API).show(hash_including(:body => "test")) { true }
+      Libnotify.show(:body => "test")
+    end
+  end
+
+  def test_version
+    assert defined?(Libnotify::VERSION), "version is defined"
+    assert Libnotify::VERSION
+  end
+end
+
+class TestLibnotifyAPI < MiniTest::Unit::TestCase
+  def test_without_options_and_block
+    assert_equal " ",     libnotify.summary
+    assert_equal " ",     libnotify.body
+    assert_equal :normal, libnotify.urgency
+    assert_nil            libnotify.timeout
+    assert_nil            libnotify.icon_path
+    assert                libnotify.append
+  end
+
+  def test_with_options_and_block
+    libnotify(:summary => "hello", :body => "body", :invalid_option => 23) do |n|
+      n.body      = "overwritten"
+      n.icon_path = "/path/to/icon"
+      n.append    = false
+    end
+
+    assert_equal "hello",         libnotify.summary
+    assert_equal "overwritten",   libnotify.body
+    assert_equal "/path/to/icon", libnotify.icon_path
+    assert                       !libnotify.append
+  end
+
+  def test_timeout_setter
+    assert_timeout 2500,  2.5,    "with float"
+    assert_timeout 100,   100,    "with fixnum ms"
+    assert_timeout 101,   101,    "with fixnum ms"
+    assert_timeout 1000,  1,      "with fixnum seconds"
+    assert_timeout 99000, 99,     "with fixnum seconds"
+    assert_timeout nil,   nil,    "with nil"
+    assert_timeout nil,   false,  "with false"
+    assert_timeout 2,     :"2 s", "with to_s.to_i"
+  end
+
+  def test_icon_path_setter
+    Libnotify::API.icon_dirs << File.expand_path("../..", __FILE__)
+    assert_icon_path "/some/path/image.jpg",  "/some/path/image.jpg",   "with absolute path"
+    assert_icon_path "some-invalid-path.jpg", "some-invalid-path.jpg",  "with non-existant relative path"
+    assert_icon_path %r{^/.*/libnotify.png},  "libnotify.png",          "with relative path"
+    assert_icon_path %r{^/.*/libnotify.png},  :"libnotify",             "with symbol"
+  end
+
+  def test_integration
+    skip "enable integration"
+
+    libnotify = Libnotify::API.new(:timeout => 0.5, :icon_path => :"emblem-favorite", :append => true)
+
+    [ :low, :normal, :critical ].each do |urgency|
+      libnotify.summary = "#{RUBY_VERSION} at #{RUBY_PLATFORM}"
+      libnotify.body    = [ urgency, defined?(RUBY_DESCRIPTION) ? RUBY_DESCRIPTION : '?' ].join(" ")
+      libnotify.urgency = urgency
+      libnotify.show!
+    end
+  end
+
+  private
+
+  def libnotify(options={}, &block)
+    @libnotify ||= Libnotify::API.new(options, &block)
+  end
+
+  def assert_timeout(expected, value, message)
+    assert_value_set :timeout, expected, value, message
+  end
+
+  def assert_icon_path(expected, value, message)
+    assert_value_set :icon_path, expected, value, message
+  end
+
+  def assert_value_set(attribute, expected, value, message)
+    libnotify.send("#{attribute}=", value)
+    got = libnotify.send(attribute)
+    case expected
+    when Regexp
+      assert_match expected, got, message
+    else
+      assert_equal expected, got, message
+    end
+  end
+
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: libnotify
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 5
+  - 1
+  version: 0.5.1
+platform: universal-rubinius-1.2
+authors: 
+- Peter Suschlik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-19 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 7
+        - 0
+        version: 0.7.0
+  type: :development
+  version_requirements: *id002
+description: 
+email: 
+- peter-libnotify@suschlik.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- .travis.yml
+- Gemfile
+- README.rdoc
+- Rakefile
+- lib/libnotify.rb
+- lib/libnotify/api.rb
+- lib/libnotify/ffi.rb
+- lib/libnotify/version.rb
+- libnotify.gemspec
+- libnotify.png
+- test/helper.rb
+- test/libnotify_io.rb
+- test/test_libnotify.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/libnotify
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Ruby bindings for libnotify using FFI
+test_files: []
+