launchy 0.4.0 → 2.0.0

data/gemspec.rb

@@ -1,46 +0,0 @@
-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")
-
-  spec.add_development_dependency("rake", "~> 0.8.7")
-  spec.add_development_dependency("configuration", "~> 1.2.0")
-  spec.add_development_dependency("rspec-core", "~> 2.5.1")
-
-
-  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/lib/launchy/browser.rb

@@ -1,98 +0,0 @@
-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 =  %w[http https ftp file].include?(uri.scheme)
-        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/lib/launchy/command_line.rb

@@ -1,48 +0,0 @@
-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/lib/launchy/paths.rb

@@ -1,53 +0,0 @@
-#--
-# 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/spec/browser_spec.rb

@@ -1,62 +0,0 @@
-require File.join(File.dirname(__FILE__),"spec_helper.rb")
-require 'stringio'
-describe Launchy::Browser do
-  it "should find a path to a executable" do
-    begin
-      File.executable?(Launchy::Browser.new.browser).should == true
-    rescue => e
-      e.message.should == "Unable to find browser to launch for os family 'nix'."
-    end
-  end
-
-  it "should handle an http url" do
-    Launchy::Browser.handle?("http://www.example.com").should == true
-  end
-
-  it "should handle an https url" do
-    Launchy::Browser.handle?("https://www.example.com").should == true
-  end
-
-  it "should handle an ftp url" do
-    Launchy::Browser.handle?("ftp://download.example.com").should == true
-  end
-
-  it "should handle an file url" do
-    Launchy::Browser.handle?("file:///home/user/index.html").should == true
-  end
-
-  it "should not handle a mailto url" do
-    Launchy::Browser.handle?("mailto:jeremy@example.com").should == false
-  end
-
-  it "creates a default unix application list" do
-    begin
-      Launchy::Browser.new.nix_app_list.class.should == Array
-    rescue => e
-      e.message.should == "Unable to find browser to launch for os family 'nix'."
-    end
-  end
-
-  { "BROWSER" => "/bin/sh",
-    "LAUNCHY_BROWSER" => "/bin/sh"}.each_pair do |e,v|
-    it "can use environmental variable overrides of #{e} for the browser" do
-      ENV[e] = v
-      Launchy::Browser.new.browser.should eql(v)
-      ENV[e] = nil
-    end
-  end
-
-  it "reports when it cannot find an browser" do
-    old_error = $stderr
-    $stderr = StringIO.new
-    ENV["LAUNCHY_HOST_OS"] = "testing"
-    begin
-      browser = Launchy::Browser.new
-    rescue => e
-      e.message.should =~ /Unable to find browser to launch for os family/m
-    end
-    ENV["LAUNCHY_HOST_OS"] = nil
-    $stderr.string.should =~ /Unable to launch. No Browser application found./m
-    $stderr = old_error
-  end
-end

data/spec/paths_spec.rb

@@ -1,15 +0,0 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) ) 
-
-require 'launchy/paths'
-
-describe Launchy::Paths do
-  it "can access the root dir of the project" do
-    Launchy::Paths.root_dir.should == File.expand_path( File.join( File.dirname( __FILE__ ), ".." ) ) + ::File::SEPARATOR
-  end
-
-  %w[ lib ].each do |sub|
-    it "can access the #{sub} path of the project" do
-      Launchy::Paths.send("#{sub}_path" ).should == File.expand_path( File.join( File.dirname( __FILE__ ), "..", sub ) ) + ::File::SEPARATOR
-    end
-  end
-end

data/tasks/announce.rake

@@ -1,39 +0,0 @@
-require 'tasks/config'
-#-------------------------------------------------------------------------------
-# announcement methods
-#-------------------------------------------------------------------------------
-
-proj_config = Configuration.for('project')
-namespace :announce do
-  desc "create email for ruby-talk"
-  task :email do
-    info = Utils.announcement
-
-    File.open("email.txt", "w") do |mail|
-      mail.puts "From: #{proj_config.author} <#{proj_config.email}>"
-      mail.puts "To: ruby-talk@ruby-lang.org"
-      mail.puts "Date: #{Time.now.rfc2822}"
-      mail.puts "Subject: [ANN] #{info[:subject]}"
-      mail.puts
-      mail.puts info[:title]
-      mail.puts 
-      mail.puts "  gem install #{Launchy::GEM_SPEC.name}"
-      mail.puts
-      mail.puts info[:urls]
-      mail.puts 
-      mail.puts info[:description]
-      mail.puts 
-      mail.puts "{{ Release notes for Version #{Launchy::VERSION} }}"
-      mail.puts 
-      mail.puts info[:release_notes]
-      mail.puts
-    end 
-    puts "Created the following as email.txt:"
-    puts "-" * 72
-    puts File.read("email.txt")
-    puts "-" * 72
-  end 
-
-  CLOBBER << "email.txt"
-end
-

data/tasks/config.rb

@@ -1,107 +0,0 @@
-require 'configuration'
-
-require 'rake'
-require 'tasks/utils'
-
-#-----------------------------------------------------------------------
-# General project configuration
-#-----------------------------------------------------------------------
-Configuration.for('project') {
-  name          "launchy"
-  version       Launchy::Version.to_s
-  author        "Jeremy Hinegardner"
-  email         "jeremy at copiousfreetime dot org"
-  homepage      "http://copiousfreetime.rubyforge.org/launchy/"
-  description   Utils.section_of("README", "description")
-  summary       description.split(".").first
-  history       "HISTORY"
-  license       FileList["LICENSE"]
-  readme        "README"
-}
-
-#-----------------------------------------------------------------------
-# Packaging 
-#-----------------------------------------------------------------------
-Configuration.for('packaging') {
-  # files in the project 
-  proj_conf = Configuration.for('project')
-  files {
-    bin       FileList["bin/*"]
-    ext       FileList["ext/*.{c,h,rb}"]
-    examples  FileList["examples/*.rb"]
-    lib       FileList["lib/**/*.rb"]
-    test      FileList["spec/**/*.rb", "test/**/*.rb"]
-    data      FileList["data/**/*", "spec/**/*.yml"]
-    tasks     FileList["tasks/**/*.r{ake,b}"]
-    rdoc      FileList[proj_conf.readme, proj_conf.history,
-                       proj_conf.license] + lib + FileList["ext/*.c"]
-    all       bin + examples + ext + lib + test + data + rdoc + tasks  + FileList["Rakefile"]
-  }
-
-  # ways to package the results
-  formats {
-    tgz true
-    zip true
-    rubygem Configuration::Table.has_key?('gem')
-  }
-}
-
-#-----------------------------------------------------------------------
-# Gem packaging
-#-----------------------------------------------------------------------
-Configuration.for("gem") {
-  spec "gemspec.rb"
-  Configuration.for('packaging').files.all << spec
-}
-
-#-----------------------------------------------------------------------
-# Testing
-#   - change mode to 'testunit' to use unit testing
-#-----------------------------------------------------------------------
-Configuration.for('test') {
-  mode      "spec"
-  files     Configuration.for("packaging").files.test
-  options   %w[ --format documentation --color ]
-  ruby_opts %w[ ]
-}
-
-#-----------------------------------------------------------------------
-# Rcov 
-#-----------------------------------------------------------------------
-Configuration.for('rcov') {
-  output_dir  "coverage"
-  libs        %w[ lib ]
-  rcov_opts   %w[ --html -o coverage ]
-  ruby_opts   %w[ ]
-  test_files  Configuration.for('packaging').files.test
-}
-
-#-----------------------------------------------------------------------
-# Rdoc 
-#-----------------------------------------------------------------------
-Configuration.for('rdoc') {
-  files       Configuration.for('packaging').files.rdoc
-  main_page   files.first
-  title       Configuration.for('project').name
-  options     %w[ --line-numbers --inline-source ]#-f darkfish ]
-  output_dir  "doc"
-}
-
-#-----------------------------------------------------------------------
-# Extension
-#-----------------------------------------------------------------------
-Configuration.for('extension') {
-  configs   Configuration.for('packaging').files.ext.find_all { |x| %w[ mkrf_conf.rb extconf.rb ].include?(File.basename(x)) }
-}
-
-#-----------------------------------------------------------------------
-# Rubyforge 
-#-----------------------------------------------------------------------
-Configuration.for('rubyforge') {
-  project       "copiousfreetime"
-  user          "jjh"
-  host          "rubyforge.org"
-  rdoc_location "#{user}@#{host}:/var/www/gforge-projects/#{project}/launchy"
-}
-
-