wijet-launchy 2.0.6

data/lib/launchy/detect/runner.rb

@@ -0,0 +1,111 @@
+require 'shellwords'
+
+module Launchy::Detect
+  class Runner
+    class NotFoundError < Launchy::Error; end
+
+    extend ::Launchy::DescendantTracker
+
+    # Detect the current command runner
+    #
+    # This will return an instance of the Runner to be used to do the
+    # application launching.
+    #
+    # If a runner cannot be detected then raise Runner::NotFoundError
+    #
+    # The runner rules are, in order:
+    #
+    # 1) If you are on windows, you use the Windows Runner no matter what
+    # 2) If you are using the jruby engine, use the Jruby Runner. Unless rule
+    #    (1) took effect
+    # 3) Use Forkable (barring rules (1) and (2))
+    def self.detect
+      host_os_family = Launchy::Detect::HostOsFamily.detect
+      ruby_engine    = Launchy::Detect::RubyEngine.detect
+
+      return Windows.new if host_os_family.windows?
+      if ruby_engine.jruby? then
+        require 'spoon'
+        return Jruby.new
+      end
+      return Forkable.new 
+    end
+
+    #
+    # cut it down to just the shell commands that will be passed to exec or
+    # posix_spawn. The cmd argument is split according to shell rules and the
+    # args are not escaped because they whole set is passed to system as *args
+    # and in that case system shell escaping rules are not done.
+    #
+    def shell_commands( cmd, args )
+      cmdline = [ cmd.shellsplit ]
+      cmdline << args.flatten.collect{ |a| a.to_s }
+      return commandline_normalize( cmdline )
+    end
+
+    def commandline_normalize( cmdline )
+      c = cmdline.flatten!
+      c = c.find_all { |a| (not a.nil?) and ( a.size > 0 ) }
+      Launchy.log "commandline_normalized => #{c.join(' ')}"
+      return c
+    end
+
+    def dry_run( cmd, *args )
+      shell_commands(cmd, args).join(" ")
+    end
+
+    def run( cmd, *args )
+      if Launchy.dry_run? then
+        $stdout.puts dry_run( cmd, *args )
+      else
+        wet_run( cmd, *args )
+      end
+    end
+
+
+    #---------------------------------------
+    # The list of known runners
+    #---------------------------------------
+
+    class Windows < Runner
+
+      def all_args( cmd, *args )
+        args = [ 'cmd', '/c', *shell_commands( cmd, *args ) ]
+        Launchy.log "Windows: all_args => #{args.inspect}"
+        return args
+      end
+
+      def dry_run( cmd, *args )
+        all_args( cmd, *args ).join(" ")
+      end
+
+      # escape the reserved shell characters in windows command shell
+      # http://technet.microsoft.com/en-us/library/cc723564.aspx
+      def shell_commands( cmd, *args )
+        cmdline = [ cmd.shellsplit ]
+        cmdline << args.flatten.collect { |a| a.to_s.gsub(/([&|()<>^])/, "^\\1") }
+        return commandline_normalize( cmdline )
+      end
+
+      def wet_run( cmd, *args )
+        system( *all_args( cmd, *args ) )
+      end
+    end
+
+    class Jruby < Runner
+      def wet_run( cmd, *args )
+        Spoon.spawnp( *shell_commands( cmd, *args ) )
+      end
+    end
+
+    class Forkable < Runner
+      def wet_run( cmd, *args )
+        child_pid = fork do
+          exec( *shell_commands( cmd, *args ))
+          exit!
+        end
+        Process.detach( child_pid )
+      end
+    end
+  end
+end

data/lib/launchy/error.rb

@@ -0,0 +1,4 @@
+module Launchy
+  class Error < ::StandardError; end
+  class ApplicationNotFoundError < Error; end
+end

data/lib/launchy/os_family.rb

@@ -0,0 +1,8 @@
+module Launchy
+  #
+  # Model all the Operating system families that can exist.
+  #
+  class OSFamily
+    extend DescendantTracker
+  end
+end

data/lib/launchy/version.rb

@@ -0,0 +1,18 @@
+module Launchy
+  VERSION = "2.0.6"
+
+  module Version
+
+    MAJOR   = Integer(VERSION.split('.')[0])
+    MINOR   = Integer(VERSION.split('.')[1])
+    PATCH   = Integer(VERSION.split('.')[2])
+
+    def self.to_a
+      [MAJOR, MINOR, PATCH]
+    end
+
+    def self.to_s
+      VERSION
+    end
+  end
+end

data/spec/application_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'mock_application'
+
+class JunkApp < Launchy::Application
+  def self.handles?( uri )
+    uri.scheme == "junk"
+  end
+end
+
+describe Launchy::Application do
+  it 'registers inherited classes' do
+    class Junk2App < Launchy::Application
+      def self.handles?( uri )
+        uri.scheme == "junk2"
+      end
+    end
+    Launchy::Application.children.must_include( Junk2App )
+    Launchy::Application.children.delete( Junk2App )
+  end
+
+  it "can find an app" do
+    Launchy::Application.children.must_include( JunkApp )
+    Launchy::Application.children.size.must_equal 3
+    uri = Addressable::URI.parse( "junk:///foo" )
+    Launchy::Application.handling( uri ).must_equal( JunkApp  )
+  end
+
+  it "raises an error if an application cannot be found for the given scheme" do
+    uri = Addressable::URI.parse( "foo:///bar" )
+    lambda { Launchy::Application.handling( uri ) }.must_raise( Launchy::ApplicationNotFoundError )
+  end
+
+  it "can find open or curl" do
+    found = %w[ open curl ].any? do |app|
+      Launchy::Application.find_executable( app )
+    end
+    found.must_equal true
+  end
+
+  it "does not find xyzzy" do
+    Launchy::Application.find_executable( "xyzzy" ).must_equal  nil
+  end
+end

data/spec/applications/browser_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Launchy::Application::Browser do
+  before do
+    Launchy.reset_global_options
+    ENV['KDE_FULL_SESSION'] = "launchy"
+    @test_url = "http://example.com/"
+  end
+
+  after do
+    Launchy.reset_global_options
+    ENV.delete( 'KDE_FULL_SESSION' )
+  end
+
+  { 'windows' => 'start /b' ,
+    'darwin'  => '/usr/bin/open',
+    'cygwin'  => 'cmd /C start /b',
+
+    # when running these tests on a linux box, this test will fail
+    'linux'   => nil                 }.each  do |host_os, cmdline|
+    it "when host_os is '#{host_os}' the appropriate 'app_list' method is called" do
+      Launchy.host_os = host_os
+      browser = Launchy::Application::Browser.new
+      browser.app_list.first.must_equal cmdline
+    end
+  end
+
+  %w[ linux windows darwin cygwin ].each do |host_os|
+    it "the BROWSER environment variable overrides any host defaults on '#{host_os}'" do
+      ENV['BROWSER'] = "my_special_browser --new-tab '%s'"
+      Launchy.host_os = host_os
+      browser = Launchy::Application::Browser.new
+      cmd, args = browser.cmd_and_args( @test_url )
+      cmd.must_equal "my_special_browser --new-tab 'http://example.com/'"
+      args.must_equal []
+    end
+  end
+
+  it "handles a file on the file system when there is no file:// scheme" do
+    uri = Addressable::URI.parse( __FILE__ )
+    Launchy::Application::Browser.handles?( uri ).must_equal true
+  end
+
+  it "handles the case where $BROWSER is set and no *nix desktop environment is found" do
+    ENV.delete( "KDE_FULL_SESSION" )
+    ENV.delete( "GNOME_DESKTOP_SESSION_ID" )
+    ENV['BROWSER'] = "do-this-instead"
+    Launchy.host_os = 'linux'
+    browser = Launchy::Application::Browser.new
+    browser.browser_cmdline.must_equal "do-this-instead"
+  end
+
+end
+

data/spec/cli_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Launchy::Cli do
+
+  before do
+    @old_stderr = $stderr
+    $stderr = StringIO.new
+
+    @old_stdout = $stdout
+    $stdout = StringIO.new
+    Launchy.reset_global_options
+  end
+
+  after do
+    Launchy.reset_global_options
+    $stderr = @old_stderr
+    $stdout = @old_stdout
+  end
+
+  def cli_test( argv, env, exit_val, stderr_regex, stdout_regex )
+    begin
+      Launchy::Cli.new.run( argv, env )
+    rescue SystemExit => se
+      se.status.must_equal exit_val
+      $stderr.string.must_match stderr_regex if stderr_regex
+      $stdout.string.must_match stdout_regex if stdout_regex
+    end
+  end
+
+  it "exits 1 when invalid options are given" do
+    cli_test( %w[ -z foo ], {}, 1, /invalid option/, nil )
+  end
+
+  %w[ -h --help ].each do |opt|
+    it "output help and exits 0 when using #{opt}" do
+      cli_test( [ opt ], {}, 0, nil, /Print this message/m )
+    end
+  end
+
+  %w[ -v --version ].each do |opt|
+    it "outputs version and exits 0 when using #{opt}" do
+      cli_test( [ opt ], {}, 0, nil, /Launchy version/ )
+    end
+  end
+
+  it "leaves the url on argv after parsing" do
+    l = Launchy::Cli.new
+    argv = %w[ --debug --dry-run http://github.com/copiousfreetime/launchy ]
+    l.parse( argv , {} )
+    argv.size.must_equal 1
+    argv[0].must_equal "http://github.com/copiousfreetime/launchy" 
+  end
+
+  it "prints the command on stdout when using --dry-run" do
+   argv = %w[ --debug --dry-run http://github.com/copiousfreetime/launchy ]
+   rc = Launchy::Cli.new.good_run( argv, {} )
+   $stdout.string.must_match %r[github.com]
+  end
+
+  {
+    '--application' => [ :application, 'Browser'],
+    '--engine'      => [ :ruby_engine, 'rbx'],
+    '--host-os'     => [ :host_os,     'cygwin'] }.each_pair do |opt, val|
+    it "the commandline option #{opt} sets the program option #{val[0]}" do
+      argv = [ opt, val[1], "http://github.com/copiousfreetime/launchy" ]
+      l = Launchy::Cli.new
+      rc = l.parse( argv, {} )
+      rc.must_equal true
+      argv.size.must_equal 1
+      argv[0].must_equal "http://github.com/copiousfreetime/launchy"
+      l.options[val[0]].must_equal val[1]
+    end
+  end
+end
+ 

data/spec/detect/host_os_family_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'yaml'
+
+describe Launchy::Detect::HostOsFamily do
+
+  before do
+    Launchy.reset_global_options
+  end
+
+  after do
+    Launchy.reset_global_options
+  end
+
+  YAML::load( IO.read( File.expand_path( "../../tattle-host-os.yaml", __FILE__ ) ) )['host_os'].keys.sort.each do |os|
+    it "OS family of #{os} is detected" do
+      Launchy::Detect::HostOsFamily.detect( os ).must_be_kind_of Launchy::Detect::HostOsFamily
+    end
+  end
+
+  { 'mswin'  => :windows?,
+    'darwin' => :darwin?,
+    'linux'  => :nix?,
+    'cygwin' => :cygwin? }.each_pair do |os, method|
+    it "#{method} returns true for #{os} " do
+      Launchy::Detect::HostOsFamily.detect( os ).send( method ).must_equal true
+    end
+  end
+
+  it "uses the global host_os overrides" do
+    ENV['LAUNCHY_HOST_OS'] = "fake-os-2"
+    lambda { Launchy::Detect::HostOsFamily.detect }.must_raise Launchy::Detect::HostOsFamily::NotFoundError
+    ENV.delete('LAUNCHY_HOST_OS')
+  end
+
+
+  it "does not find an os of 'dos'" do
+    lambda { Launchy::Detect::HostOsFamily.detect( 'dos' ) }.must_raise Launchy::Detect::HostOsFamily::NotFoundError
+  end
+
+end

data/spec/detect/host_os_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Launchy::Detect::HostOs do
+
+  it "uses the defult host os from ruby's config" do
+    Launchy::Detect::HostOs.new.host_os.must_equal RbConfig::CONFIG['host_os']
+  end
+
+  it "uses the passed in value as the host os" do
+    Launchy::Detect::HostOs.new( "fake-os-1").host_os.must_equal "fake-os-1"
+  end
+
+  it "uses the environment variable LAUNCHY_HOST_OS to override ruby's config" do
+    ENV['LAUNCHY_HOST_OS'] = "fake-os-2"
+    Launchy::Detect::HostOs.new.host_os.must_equal "fake-os-2"
+    ENV.delete('LAUNCHY_HOST_OS')
+  end
+
+end

data/spec/detect/nix_desktop_environment_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Launchy::Detect::NixDesktopEnvironment do
+
+  before do
+    Launchy.reset_global_options
+  end
+
+  after do
+    Launchy.reset_global_options
+  end
+
+
+  { "KDE_FULL_SESSION"         => Launchy::Detect::NixDesktopEnvironment::Kde,
+    "GNOME_DESKTOP_SESSION_ID" => Launchy::Detect::NixDesktopEnvironment::Gnome }.each_pair do |k,v|
+    it "can detect the desktop environment of a *nix machine using ENV[#{k}]" do
+      ENV[k] = "launchy-test"
+      nix_env = Launchy::Detect::NixDesktopEnvironment.detect
+      nix_env.must_equal( v )
+      nix_env.browser.must_equal( v.browser )
+      ENV.delete( k )
+    end
+   end
+
+
+  it "returns nil if it cannot determine the *nix desktop environment" do
+    Launchy.host_os = "linux"
+    ENV.delete( "KDE_FULL_SESSION" )
+    ENV.delete( "GNOME_DESKTOP_SESSION_ID" )
+    Launchy::Detect::NixDesktopEnvironment.detect.must_equal( nil )
+  end
+
+end

data/spec/detect/ruby_engine_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Launchy::Detect::RubyEngine do
+
+  before do
+    Launchy.reset_global_options
+  end
+
+  after do
+    Launchy.reset_global_options
+  end
+
+  %w[ ruby jruby rbx macruby ].each do |ruby|
+    it "detects the #{ruby} RUBY_ENGINE" do
+      Launchy::Detect::RubyEngine.detect( ruby ).ancestors.must_include Launchy::Detect::RubyEngine
+    end
+  end
+
+  it "uses the global ruby_engine overrides" do
+    ENV['LAUNCHY_RUBY_ENGINE'] = "rbx"
+    Launchy::Detect::RubyEngine.detect.must_equal Launchy::Detect::RubyEngine::Rbx
+    ENV.delete('LAUNCHY_RUBY_ENGINE')
+  end
+
+  it "does not find a ruby engine of 'foo'" do
+    lambda { Launchy::Detect::RubyEngine.detect( 'foo' ) }.must_raise Launchy::Detect::RubyEngine::NotFoundError
+  end
+
+  { 'rbx'     => :rbx?,
+    'ruby'    => :mri?,
+    'macruby' => :macruby?,
+    'jruby'   => :jruby? }.each_pair do |engine, method|
+    it "#{method} returns true for #{engine} " do
+      Launchy::Detect::RubyEngine.detect( engine ).send( method ).must_equal true
+    end
+ end
+end