launchy 2.5.0 → 3.0.1

data/lib/launchy/detect/runner.rb

@@ -1,152 +0,0 @@
-require 'shellwords'
-require 'stringio'
-
-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
-        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.to_s.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 )
-      raise Launchy::CommandNotFoundError, "No command found to run with args '#{args.join(' ')}'. If this is unexpected, #{Launchy.bug_report_message}" unless cmd
-      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
-      #
-      # Also make sure that the item after 'start' is guaranteed to be quoted.
-      # https://github.com/copiousfreetime/launchy/issues/62
-      def shell_commands( cmd, *args )
-        parts = cmd.shellsplit
-
-        if start_idx = parts.index('start') then
-          title_idx = start_idx + 1
-          title     = parts[title_idx]
-          title     = title.sub(/^/,'"') unless title[0] == '"'
-          title     = title.sub(/$/,'"') unless title[-1] == '"'
-          parts[title_idx] = title
-        end
-
-        cmdline = [ parts ]
-        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 )
-        child_pid = spawn( *shell_commands( cmd, *args ) )
-        Process.detach( child_pid )
-      end
-    end
-
-    class Forkable < Runner
-      attr_reader   :child_pid
-
-      def wet_run( cmd, *args )
-        @child_pid = fork do
-          close_file_descriptors unless Launchy.debug?
-          Launchy.log("wet_run: before exec in child process")
-          exec_or_raise( cmd, *args )
-          exit!
-        end
-        Process.detach( @child_pid )
-      end
-
-      private
-
-      # attaching to a StringIO instead of reopening so we don't loose the
-      # STDERR, needed for exec_or_raise.
-      def close_file_descriptors
-        $stdin.reopen( "/dev/null")
-
-        @saved_stdout = $stdout
-        @saved_stderr = $stderr
-
-        $stdout       = StringIO.new
-        $stderr       = StringIO.new
-      end
-
-      def exec_or_raise( cmd, *args )
-        exec( *shell_commands( cmd, *args ))
-      rescue Exception => e
-        $stderr = @saved_stderr
-        $stdout = @saved_stdout
-        raise e
-      end
-    end
-  end
-end

data/spec/application_spec.rb

@@ -1,43 +0,0 @@
-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 or xdg-open" do
-    found = %w[ open curl xdg-open ].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_be_nil
-  end
-end

data/spec/applications/browser_spec.rb

@@ -1,78 +0,0 @@
-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' )
-    ENV.delete( 'BROWSER' )
-  end
-
-  { 'windows' => 'start "launchy" /b' ,
-    'darwin'  => [ '/usr/bin/open', '/bin/open' ], # because running tests on linux
-    'cygwin'  => 'cmd /C start "launchy" /b',
-    'linux'   => [nil, "xdg-open"], # because running tests on linux
-  }.each  do |host_os, expected|
-    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
-
-      item = browser.app_list.first
-      item = item.to_s if item.kind_of?(::Launchy::Argv)
-      case expected
-      when Array
-        _(expected).must_include item
-      when String
-        _(item).must_equal expected
-      end
-    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
-
-  # NOTE: Unable to figure out how capture the stderr from the child which has
-  # moved it at least once. This test just serves the purpose of noting why
-  # something happens, and the problem we are attempting to fix.
-  #it "When BROWSER is set to something that is not executable, error still appears on stderr" do
-  #  ENV['BROWSER'] = "not-an-app"
-  #  url = "http://example.com/"
-
-  #  _, err = capture_subprocess_io do 
-  #    begin
-  #      Launchy.open( url )
-  #    rescue => nil
-  #    end
-  #  end
-  #  #_(err).must_match( /wibble/m )
-  #  err # something
-  #end
-end
-

data/spec/cli_spec.rb

@@ -1,75 +0,0 @@
-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 ]
-   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

@@ -1,42 +0,0 @@
-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
-      os_family = Launchy::Detect::HostOsFamily.detect( os )
-      _(os_family).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
-      r = Launchy::Detect::HostOsFamily.detect( os ).send( method )
-      _(r).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

@@ -1,19 +0,0 @@
-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

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Launchy::Detect::NixDesktopEnvironment do
-
-  before do
-    Launchy.reset_global_options
-  end
-
-  after do
-    Launchy.reset_global_options
-  end
-
-  it "returns false for XFCE if xprop is not found" do
-    Launchy.host_os = "linux"
-    _(Launchy::Detect::NixDesktopEnvironment::Xfce.is_current_desktop_environment?).must_equal( false )
-  end
-
-  it "returns NotFound 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.path = %w[ / /tmp ].join(File::PATH_SEPARATOR)
-    not_found = Launchy::Detect::NixDesktopEnvironment.detect
-    _(not_found).must_equal( Launchy::Detect::NixDesktopEnvironment::NotFound )
-    _(not_found.browser).must_equal( Launchy::Argv.new )
-  end
-end

data/spec/detect/ruby_engine_spec.rb

@@ -1,37 +0,0 @@
-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

data/spec/detect/runner_spec.rb

@@ -1,103 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-
-describe Launchy::Detect::Runner do
-  before do
-    Launchy.reset_global_options
-    @test_url = "http://example.com/?foo=bar&baz=wibble"
-  end
-
-  after do
-    Launchy.reset_global_options
-  end
-
-  it "raises an error when there is an unknown host os" do
-    Launchy.host_os = "foo"
-    _(lambda{ Launchy::Detect::Runner.detect }).must_raise Launchy::Detect::HostOsFamily::NotFoundError
-  end
-
-  it "raises an error when there is an unknown ruby engine" do
-    Launchy.ruby_engine = "wibble"
-    _(lambda{ Launchy::Detect::Runner.detect }).must_raise Launchy::Detect::RubyEngine::NotFoundError
-  end
-
-  it "raises and error when there is no command found" do
-    runner = Launchy::Detect::Runner.detect
-    _(lambda{ runner.run( nil, *%w[ arg1 arg2 arg 3] ) }).must_raise Launchy::CommandNotFoundError
-  end
-
-  # On anything that has fork, use Forkable
-  %w[ linux darwin cygwin ].each do |host_os|
-    %w[ ruby rbx macruby ].each do |engine_name|
-      it "engine '#{engine_name}' on OS '#{host_os}' uses runner Forkable" do
-        Launchy.host_os = host_os
-        Launchy.ruby_engine = engine_name
-        engine = Launchy::Detect::Runner.detect
-        _(engine).must_be_instance_of Launchy::Detect::Runner::Forkable
-      end
-    end
-  end
-
-
-  # Jruby always uses the Jruby runner except on Windows
-  { 'mingw'  => Launchy::Detect::Runner::Windows,
-    'linux'  => Launchy::Detect::Runner::Jruby,
-    'darwin' => Launchy::Detect::Runner::Jruby,
-    'cygwin' => Launchy::Detect::Runner::Jruby, }.each_pair do |host_os, runner|
-    it "engine 'jruby' on OS '#{host_os}' uses runner #{runner.name}" do
-      Launchy.host_os = host_os
-      Launchy.ruby_engine = 'jruby'
-      engine = Launchy::Detect::Runner.detect
-      _(engine).must_be_instance_of runner
-    end
-  end
-
-  # If you are on windows, no matter what engine, you use the windows runner
-  %w[ ruby rbx jruby macruby ].each do |engine_name|
-    it "uses a Windows runner when the engine is '#{engine_name}'" do
-      Launchy.host_os = "mingw"
-      Launchy.ruby_engine = engine_name
-      e = Launchy::Detect::Runner.detect
-      _(e).must_be_instance_of Launchy::Detect::Runner::Windows
-    end
-  end
-
-  it "Windows launches use the 'cmd' command" do
-    win = Launchy::Detect::Runner::Windows.new
-    cmd = win.dry_run( "not-really", [ "http://example.com" ] )
-    _(cmd).must_equal 'cmd /c not-really http://example.com'
-  end
-
-  %w[ & | ( ) < > ^ ].each do |reserved_char|
-    it "Windows escapes '#{reserved_char}' in urls" do
-      win = Launchy::Detect::Runner::Windows.new
-      parts = [ 'http://example.com/?foo=bar', 'baz=wibble' ]
-      url = parts.join( reserved_char )
-      output_url = parts.join( "^#{reserved_char}" )
-
-      _(win.all_args( "not-really", [ url ] )).must_equal [ 'cmd', '/c', 'not-really', output_url ]
-
-      cmd = win.dry_run( "not-really", [ url ] )
-      _(cmd).must_equal "cmd /c not-really #{output_url}"
-    end
-  end
-
-  it "Jruby doesnot escapes '&' in urls" do
-    jruby = Launchy::Detect::Runner::Jruby.new
-    cmd = jruby.dry_run( "not-really", [ @test_url ])
-    _(cmd).must_equal 'not-really http://example.com/?foo=bar&baz=wibble'
-  end
-
-  it "does not escape %38 items in urls" do
-    l = Launchy::Detect::Runner::Forkable.new
-    cmd = l.dry_run( "not-really", [ "http://ja.wikipedia.org/wiki/%E3%81%82" ] )
-    _(cmd).must_equal( 'not-really http://ja.wikipedia.org/wiki/%E3%81%82'  )
-  end
-
-  it "can launch a utf8 url" do
-    url = "http://ja.wikipedia.org/wiki/あ"
-    l = Launchy::Detect::Runner::Forkable.new
-    cmd = l.dry_run( "not-really", [ url ] )
-    _(cmd).must_equal( "not-really #{url}" )
-  end
-end