gemrage 0.3.2 → 0.4.0

data/vendor/ruby/1.8/gems/launchy-0.3.7/README

@@ -0,0 +1,53 @@
+== launchy
+
+* Homepage[http://copiousfreetime.rubyforge.org/launchy/]
+* {Rubyforge Project}[http://rubyforge.org/projects/copiousfreetime]
+* email jeremy at hinegardner dot org
+
+== DESCRIPTION
+
+Launchy is helper class for launching cross-platform applications in a
+fire and forget manner.
+
+There are application concepts (browser, email client, etc) that are
+common across all platforms, and they may be launched differently on
+each platform.  Launchy is here to make a common approach to launching
+external application from within ruby programs.
+
+== FEATURES
+
+Currently only launching a browser is supported.
+
+== SYNOPSIS
+
+From within your ruby code you can trust launchy to do the right thing:
+
+    Launchy.open("http://www.ruby-lang.org/")
+
+Or, if you want to launch the application yourself:
+
+    Launchy::Browser.run("http://www.ruby-lang.org/")
+
+OR
+
+    Launchy::Browser.new.visit("http://www.ruby-lang.org/")
+
+== ISC LICENSE
+
+http://opensource.org/licenses/isc-license.txt
+
+Copyright (c) 2007-2009 Jeremy Hinegardner
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+

data/vendor/ruby/1.8/gems/launchy-0.3.7/Rakefile

@@ -0,0 +1,62 @@
+#--
+# Copyright (c) 2007 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+#-------------------------------------------------------------------------------
+# make sure our project's top level directory and the lib directory are added to
+# the ruby search path.
+#-------------------------------------------------------------------------------
+$: << File.expand_path(File.join(File.dirname(__FILE__),"lib"))
+$: << File.expand_path(File.dirname(__FILE__))
+
+
+#-------------------------------------------------------------------------------
+# load the global project configuration and add in the top level clean and
+# clobber tasks so that other tasks can utilize those constants if necessary
+# This loads up the defaults for the whole project configuration
+#-------------------------------------------------------------------------------
+require 'rubygems'
+require 'tasks/config.rb'
+require 'rake/clean'
+
+#-------------------------------------------------------------------------------
+# Main configuration for the project, these overwrite the items that are in
+# tasks/config.rb
+#-------------------------------------------------------------------------------
+require 'launchy/version'
+require 'launchy/paths'
+
+Configuration.for("project") {
+  name      "launchy"
+  version   Launchy::VERSION
+  author    "Jeremy Hinegardner"
+  email     "jeremy@copiousfreetime.org"
+  homepage  "http://copiousfreetime.rubyforge.org/launchy/"
+}
+
+#-------------------------------------------------------------------------------
+# load up all the project tasks and setup the default task to be the
+# test:default task.
+#-------------------------------------------------------------------------------
+Configuration.for("packaging").files.tasks.each do |tasklib|
+  import tasklib
+end
+task :default => 'test:default'
+
+#-------------------------------------------------------------------------------
+# Finalize the loading of all pending imports and update the top level clobber
+# task to depend on all possible sub-level tasks that have a name like
+# ':clobber'  in other namespaces.  This allows us to say:
+#
+#   rake clobber
+#
+# and it will get everything.
+#-------------------------------------------------------------------------------
+Rake.application.load_imports
+Rake.application.tasks.each do |t| 
+  if t.name =~ /:clobber/ then
+    task :clobber => [t.name] 
+  end 
+end
+

data/vendor/ruby/1.8/gems/launchy-0.3.7/bin/launchy

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+begin
+    require 'launchy'
+rescue LoadError 
+    path = File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+    raise if $:.include? path
+    $: << path
+    retry
+end
+
+Launchy.command_line.run(ARGV)

data/vendor/ruby/1.8/gems/launchy-0.3.7/gemspec.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'launchy/version'
+require 'tasks/config'
+
+Launchy::GEM_SPEC = Gem::Specification.new do |spec|
+  proj = Configuration.for('project')
+  spec.name         = proj.name
+  spec.version      = Launchy::VERSION
+
+  spec.author       = proj.author
+  spec.email        = proj.email
+  spec.homepage     = proj.homepage
+  spec.summary      = proj.summary
+  spec.description  = proj.description
+  spec.platform     = Gem::Platform::RUBY
+
+
+  pkg = Configuration.for('packaging')
+  spec.files        = pkg.files.all
+  spec.executables  = pkg.files.bin.collect { |b| File.basename(b) }
+
+  # add dependencies here
+  spec.add_dependency("rake", ">= 0.8.1")
+  spec.add_dependency("configuration", ">= 0.0.5")
+
+  if rdoc = Configuration.for_if_exist?('rdoc') then
+    spec.has_rdoc         = true
+    spec.extra_rdoc_files = pkg.files.rdoc
+    spec.rdoc_options     = rdoc.options + [ "--main" , rdoc.main_page ]
+  else
+    spec.has_rdoc         = false
+  end
+
+  if test = Configuration.for_if_exist?('testing') then
+    spec.test_files       = test.files
+  end
+
+  if rf = Configuration.for_if_exist?('rubyforge') then
+    spec.rubyforge_project  = rf.project
+  end
+end

data/vendor/ruby/1.8/gems/launchy-0.3.7/lib/launchy/application.rb

@@ -0,0 +1,178 @@
+require 'rbconfig'
+
+module Launchy
+  class Application
+    class << self
+      def known_os_families
+        @known_os_families ||= [ :windows, :darwin, :nix, :cygwin, :testing ]
+      end
+
+      def inherited(sub_class)
+        application_classes << sub_class
+      end
+      def application_classes
+        @application_classes ||= []
+      end
+
+      def find_application_class_for(*args)
+        Launchy.log "#{self.name} : finding application classes for [#{args.join(' ')}]"
+        application_classes.find do |klass|
+          Launchy.log "#{self.name} : Trying #{klass.name}"
+          if klass.handle?(*args) then
+            true
+          else
+            false
+          end
+        end
+      end
+
+      # find an executable in the available paths
+      # mkrf did such a good job on this I had to borrow it.
+      def find_executable(bin,*paths)
+        paths = ENV['PATH'].split(File::PATH_SEPARATOR) if paths.empty?
+        paths.each do |path|
+          file = File.join(path,bin)
+          if File.executable?(file) then
+            Launchy.log "#{self.name} : found executable #{file}"
+            return file
+          end
+        end
+        Launchy.log "#{self.name} : Unable to find `#{bin}' in #{paths.join(', ')}"
+        return nil
+      end
+
+      # return the current 'host_os' string from ruby's configuration
+      def my_os
+        if ENV['LAUNCHY_HOST_OS'] then
+          Launchy.log "#{self.name} : Using LAUNCHY_HOST_OS override of '#{ENV['LAUNCHY_HOST_OS']}'"
+          return ENV['LAUNCHY_HOST_OS']
+        else
+          ::Config::CONFIG['host_os']
+        end
+      end
+
+      # detect what the current os is and return :windows, :darwin or :nix
+      def my_os_family(test_os = my_os)
+        case test_os
+        when /mingw/i
+          family = :windows
+        when /mswin/i
+          family = :windows
+        when /windows/i
+          family = :windows
+        when /darwin/i
+          family = :darwin
+        when /mac os/i
+          family = :darwin
+        when /solaris/i
+          family = :nix
+        when /bsd/i
+          family = :nix
+        when /linux/i
+          family = :nix
+        when /aix/i
+          family = :nix
+        when /cygwin/i
+          family = :cygwin
+        when /testing/i
+          family = :testing
+        else
+          $stderr.puts "Unknown OS familiy for '#{test_os}'.  Please report this bug to <jeremy at hinegardner dot org>"
+          family = :unknown
+        end
+      end
+    end
+
+
+    # Determine the appropriate desktop environment for *nix machine.  Currently this is
+    # linux centric.  The detection is based upon the detection used by xdg-open from
+    # http://portland.freedesktop.org/wiki/XdgUtils
+    def nix_desktop_environment
+      if not defined? @nix_desktop_environment then
+        @nix_desktop_environment = :generic
+        if ENV["KDE_FULL_SESSION"] || ENV["KDE_SESSION_UID"] then
+          @nix_desktop_environment = :kde
+        elsif ENV["GNOME_DESKTOP_SESSION_ID"] then
+          @nix_desktop_environment = :gnome
+        elsif find_executable("xprop") then
+          if %x[ xprop -root _DT_SAVE_MODE | grep ' = \"xfce\"$' ].strip.size > 0 then
+            @nix_desktop_environment = :xfce
+          end
+        end
+        Launchy.log "#{self.class.name} : nix_desktop_environment => '#{@nix_desktop_environment}'"
+      end
+      return @nix_desktop_environment
+    end
+
+    # find an executable in the available paths
+    def find_executable(bin,*paths)
+      Application.find_executable(bin,*paths)
+    end
+
+    # return the current 'host_os' string from ruby's configuration
+    def my_os
+      Application.my_os
+    end
+
+    # detect what the current os is and return :windows, :darwin, :nix, or :cygwin
+    def my_os_family(test_os = my_os)
+      Application.my_os_family(test_os)
+    end
+
+    # returns the list of command line application names for the current os.  The list
+    # returned should only contain appliations or commands that actually exist on the
+    # system.  The list members should have their full path to the executable.
+    def app_list
+      @app_list ||= self.send("#{my_os_family}_app_list")
+    end
+
+    # On darwin a good general default is the 'open' executable.
+    def darwin_app_list
+      Launchy.log "#{self.class.name} : Using 'open' application on darwin."
+      [ find_executable('open') ]
+    end
+
+    # On windows a good general default is the 'start' Command Shell command
+    def windows_app_list
+      Launchy.log "#{self.class.name} : Using 'start' command on windows."
+            %w[ start ]
+    end
+
+    # Cygwin uses the windows start but through an explicit execution of the cmd shell
+    def cygwin_app_list
+      Launchy.log "#{self.class.name} : Using 'cmd /C start' on windows."
+      [ "cmd /C start" ]
+    end
+
+    # used only for running tests
+    def testing_app_list
+      []
+    end
+
+    # run the command
+    def run(cmd,*args)
+      Launchy.log "#{self.class.name} : Spawning on #{my_os_family} : #{cmd} #{args.inspect}"
+
+      if my_os_family == :windows then
+        # NOTE: the command is purposely omitted here because
+        #       When "cmd /c start filename" is
+        #       run, the shell interprets it as two commands:
+        #       (1) "start" opens a new terminal, and (2)
+        #       "filename" causes the file to be launched.
+        system 'cmd', '/c', cmd, *args
+      else
+        # fork, and the child process should NOT run any exit handlers
+        child_pid = fork do
+          # NOTE: we pass a dummy argument *before*
+          #       the actual command to prevent sh
+          #       from silently consuming our actual
+          #       command and assigning it to $0!
+          dummy = ''
+          system 'sh', '-c', '"$@" >/dev/null 2>&1', dummy, cmd, *args
+          exit!
+        end
+        Process.detach(child_pid)
+      end
+    end
+  end
+end

data/vendor/ruby/1.8/gems/launchy-0.3.7/lib/launchy/browser.rb

@@ -0,0 +1,98 @@
+require 'launchy/application'
+require 'uri'
+
+module Launchy
+  class Browser < Application
+
+
+    class << self
+      def desktop_environment_browser_launchers
+        @desktop_environment_browser_launchers ||= {
+          :kde     => "kfmclient",
+          :gnome   => "gnome-open",
+          :xfce    => "exo-open",
+          :generic => "htmlview"
+        }
+      end
+      def fallback_browsers
+        @fallback_browsers ||=  %w[ firefox seamonkey opera mozilla netscape galeon ]
+      end
+      def run(*args)
+        Browser.new.visit(args[0])
+      end
+
+      # return true if this class can handle the given parameter(s)
+      def handle?(*args)
+        begin
+          Launchy.log "#{self.name} : testing if [#{args[0]}] (#{args[0].class}) is a url."
+          uri = URI.parse(args[0])
+          result =  [URI::HTTP, URI::HTTPS, URI::FTP].include?(uri.class)
+        rescue Exception => e
+          # hmm... why does rcov not see that this is executed ?
+          Launchy.log "#{self.name} : not a url, #{e}"
+          return false
+        end
+      end
+    end
+
+    def initialize
+      @browser = nil
+      @nix_app_list = []
+      raise "Unable to find browser to launch for os family '#{my_os_family}'." unless browser
+    end
+
+    def desktop_environment_browser_launchers
+      self.class.desktop_environment_browser_launchers
+    end
+
+    def fallback_browsers
+      self.class.fallback_browsers
+    end
+
+    # Find a list of potential browser applications to run on *nix machines.
+    # The order is:
+    #     1) What is in ENV['LAUNCHY_BROWSER'] or ENV['BROWSER']
+    #     2) xdg-open
+    #     3) desktop environment launcher program
+    #     4) a list of fallback browsers
+    def nix_app_list
+      if @nix_app_list.empty?
+        browser_cmds = ['xdg-open']
+        browser_cmds << desktop_environment_browser_launchers[nix_desktop_environment]
+        browser_cmds << fallback_browsers
+        browser_cmds.flatten!
+        browser_cmds.delete_if { |b| b.nil? || (b.strip.size == 0) }
+        Launchy.log "#{self.class.name} : Initial *Nix Browser List: #{browser_cmds.join(', ')}"
+        @nix_app_list = browser_cmds.collect { |bin| find_executable(bin) }.find_all { |x| not x.nil? }
+        Launchy.log "#{self.class.name} : Filtered *Nix Browser List: #{@nix_app_list.join(', ')}"
+      end
+      @nix_app_list
+    end
+
+    # return the full command line path to the browser or nil
+    def browser
+      if not @browser then
+        if ENV['LAUNCHY_BROWSER'] and File.exists?(ENV['LAUNCHY_BROWSER']) then
+          Launchy.log "#{self.class.name} : Using LAUNCHY_BROWSER environment variable : #{ENV['LAUNCHY_BROWSER']}"
+          @browser = ENV['LAUNCHY_BROWSER']
+        elsif ENV['BROWSER'] and File.exists?(ENV['BROWSER']) then
+          Launchy.log "#{self.class.name} : Using BROWSER environment variable : #{ENV['BROWSER']}"
+          @browser = ENV['BROWSER']
+        elsif app_list.size > 0 then
+          @browser = app_list.first
+          Launchy.log "#{self.class.name} : Using application list : #{@browser}"
+        else
+          msg = "Unable to launch. No Browser application found."
+          Launchy.log "#{self.class.name} : #{msg}"
+          $stderr.puts msg
+        end
+      end
+      return @browser
+    end
+
+    # launch the browser at the appointed url
+    def visit(url)
+      run(browser,url)
+    end
+  end
+end

data/vendor/ruby/1.8/gems/launchy-0.3.7/lib/launchy/command_line.rb

@@ -0,0 +1,48 @@
+require 'optparse'
+
+module Launchy
+  class CommandLine
+
+    def parser
+      @parser ||= OptionParser.new do |op|
+        op.banner = "Usage: launchy [options] url"
+        op.separator ""
+        op.on("-d", "--debug", "Force debug, output lots of information.",
+                               "This sets the LAUNCHY_DEBUG environment variable to 'true'.") do |d|
+          ENV["LAUNCHY_DEBUG"] = 'true'
+        end
+
+        op.on("-h", "--help", "Print this message") do |h|
+          puts op.to_s
+          exit 0
+        end
+
+        op.on("-v", "--version", "Output the version of Launchy") do |v|
+          puts "Launchy version #{Launchy::VERSION}"
+          exit 0
+        end
+
+        op.on("-o", "--host-os HOST_OS","Force the behavior of a particular host os.",
+                                    "This sets the LAUNCHY_HOST_OS environment variable.") do |os|
+          ENV["LAUNCHY_HOST_OS"] = os
+        end
+
+        op.on("-b", "--browser BROWSER", "Force launchy to use a particular browser.",
+                                   "This sets the LAUNCHY_BROWSER environment variable.") do |browser|
+          ENV["LAUNCHY_BROWSER"] = browser
+        end
+      end
+    end
+
+    def run(argv = ARGV)
+      begin
+        parser.parse!(argv)
+        Launchy.open(*argv)
+      rescue ::OptionParser::ParseError => pe
+        $stderr.puts "#{parser.programn_name}: #{pe}"
+        $stderr.puts "Try `#{parser.program_name} --help' for more information."
+        exit 1
+      end
+    end
+  end
+end

data/vendor/ruby/1.8/gems/launchy-0.3.7/lib/launchy/paths.rb

@@ -0,0 +1,53 @@
+#--
+# Copyright (c) 2007 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+#
+module Launchy
+  #
+  # Access to various paths inside the project programatically
+  #
+  module Paths
+    #
+    # :call-seq:
+    #    Launchy::Paths.root_dir -> String
+    #
+    # Returns The full expanded path of the parent directory of +lib+
+    # going up the path from the current file.  A trailing File::SEPARATOR⋅
+    # is guaranteed
+    #
+    def self.root_dir
+      @root_dir ||=(
+        path_parts = ::File.expand_path( __FILE__ ).split( ::File::SEPARATOR )
+        lib_index  = path_parts.rindex( "lib" )
+        @root_dir  = path_parts[0...lib_index].join( ::File::SEPARATOR ) + ::File::SEPARATOR
+      )
+    end
+
+    #
+    # :call-seq:
+    #   Launchy::Paths.lib_path( *args ) -> String
+    #
+    # Returns The full expanded path of the +lib+ directory below
+    # _root_dir_.  All parameters passed in are joined onto the⋅
+    # result. A trailing File::SEPARATOR is guaranteed if⋅
+    # _args_ are *not* present.
+    #
+    def self.lib_path( *args )
+      self.sub_path( "lib", *args )
+    end
+
+    #
+    # :call-seq:
+    #   Launchy::Paths.sub_path( sub, *args ) -> String
+    #
+    # Returns the full expanded path of the +sub+ directory below _root_dir.  All
+    # _arg_ parameters passed in are joined onto the result.  A trailing
+    # File::SEPARATOR is guaranteed if _args_ are *not* present.
+    #
+    def self.sub_path( sub, *args )
+      sp = ::File.join( root_dir, sub ) + File::SEPARATOR
+      sp = ::File.join( sp, *args ) if args
+    end
+  end
+end

data/vendor/ruby/1.8/gems/launchy-0.3.7/lib/launchy/version.rb

@@ -0,0 +1,17 @@
+module Launchy
+  module Version
+    MAJOR   = 0
+    MINOR   = 3
+    BUILD   = 7
+
+    def self.to_a
+      [MAJOR, MINOR, BUILD]
+    end
+
+    def self.to_s
+      to_a.join(".")
+    end
+    STRING = Version.to_s.freeze
+  end
+  VERSION = Version.to_s.freeze
+end

data/vendor/ruby/1.8/gems/launchy-0.3.7/lib/launchy.rb

@@ -0,0 +1,53 @@
+module Launchy
+  #
+  # Utility method to require all files ending in .rb in the directory
+  # with the same name as this file minus .rb
+  #
+  def self.require_all_libs_relative_to(fname)
+    prepend   = File.basename(fname,".rb")
+    search_me = File.join(File.dirname(fname),prepend)
+
+    Dir.entries(search_me).each do |rb|
+      if File.extname(rb) == ".rb" then
+        require "#{prepend}/#{File.basename(rb,".rb")}"
+      end
+    end
+  end
+
+  class << self
+    #
+    # Convenience method to launch an item
+    #
+    def open(*params)
+      begin
+        klass = Launchy::Application.find_application_class_for(*params)
+        if klass then
+          klass.run(*params)
+        else
+          msg = "Unable to launch #{params.join(' ')}"
+          Launchy.log "#{self.name} : #{msg}"
+          $stderr.puts msg
+        end
+      rescue Exception => e
+        msg = "Failure in opening #{params.join(' ')} : #{e}"
+        Launchy.log "#{self.name} : #{msg}"
+        $stderr.puts msg
+      end
+    end
+
+    # Setting the LAUNCHY_DEBUG environment variable to 'true' will spew
+    # debug information to $stderr
+    def log(msg)
+      if ENV['LAUNCHY_DEBUG'] == 'true' then
+        $stderr.puts "LAUNCHY_DEBUG: #{msg}"
+      end
+    end
+
+    # Create an instance of the commandline application of launchy
+    def command_line
+      Launchy::CommandLine.new
+    end
+  end
+end
+
+Launchy.require_all_libs_relative_to(__FILE__)

data/vendor/ruby/1.8/gems/launchy-0.3.7/spec/application_spec.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__),"spec_helper.rb")
+require 'yaml'
+
+describe Launchy::Application do
+  before(:each) do
+    yml = YAML::load(IO.read(File.join(File.dirname(__FILE__),"tattle-host-os.yml")))
+    @host_os = yml['host_os']
+    @app = Launchy::Application.new
+  end
+
+  YAML::load(IO.read(File.join(File.dirname(__FILE__), "tattle-host-os.yml")))['host_os'].keys.sort.each do |os|
+    it "#{os} should be a found os" do
+      Launchy::Application::known_os_families.should include(@app.my_os_family(os))
+    end
+  end
+
+  it "should not find os of 'dos'" do
+    @app.my_os_family('dos').should eql(:unknown)
+  end
+
+  it "my os should have a value" do
+    @app.my_os.should_not eql('')
+    @app.my_os.should_not eql(nil)
+  end
+
+  it "should find open or curl" do
+    r = "found open or curl"
+    found = %w[ open curl ].collect do |app|
+      @app.find_executable(app).nil?
+    end
+    found.should be_include( false )
+  end
+
+  it "should not find app xyzzy" do
+    @app.find_executable('xyzzy').should eql(nil)
+  end
+
+  it "should find the correct class to launch an ftp url" do
+    Launchy::Application.find_application_class_for("ftp://ftp.ruby-lang.org/pub/ruby/").should == Launchy::Browser
+  end
+
+  it "knows when it cannot find an application class" do
+    Launchy::Application.find_application_class_for("xyzzy:stuff,things").should == nil
+  end
+
+  it "allows for environmental override of host_os" do
+    ENV["LAUNCHY_HOST_OS"] = "hal-9000"
+    Launchy::Application.my_os.should eql("hal-9000")
+    ENV["LAUNCHY_HOST_OS"] = nil
+  end
+
+  { "KDE_FULL_SESSION" => :kde,
+    "KDE_SESSION_UID"  => :kde,
+    "GNOME_DESKTOP_SESSION_ID" => :gnome }.each_pair do |k,v|
+    it "can detect the desktop environment of a *nix machine using #{k}" do
+      @app.nix_desktop_environment.should eql(:generic)
+      ENV[k] = "launchy-test"
+      Launchy::Application.new.nix_desktop_environment.should eql(v)
+      ENV[k] = nil
+    end
+  end
+end