launchy 2.0.0-java

data/lib/launchy/applications/browser.rb

@@ -0,0 +1,68 @@
+class Launchy::Application
+  #
+  # The class handling the browser application and all of its schemes
+  #
+  class Browser < Launchy::Application
+    def self.schemes
+      %w[ http https ftp file ]
+    end
+
+    def windows_app_list
+      [  'start "Launchy" /d']
+    end
+
+    def cygwin_app_list
+      [ "cmd /C start 'launchy' /d" ]
+    end
+
+    def darwin_app_list
+      [ find_executable( "open" ) ]
+    end
+
+    def nix_app_list
+      nix_de = Launchy::Detect::NixDekstopEnvironment.browser
+      app_list = %w[ xdg-open ]
+      app_list << nix_de.browser
+      app_list << nix_de.fallback_browsers
+      app_list.flatten!
+      app_list.delete_if { |b| b.nil? || (b.strip.size == 0) }
+      app_list.collect { |bin| find_executable( bin ) }.find_all { |x| not x.nil? }
+    end
+
+    # use a call back mechanism to get the right app_list that is decided by the 
+    # host_os_family class.
+    def app_list
+      host_os_family.app_list( self )
+    end
+
+    def browser_env
+      return [] unless ENV['BROWSER']
+      browser_env = ENV['BROWSER'].split( File::PATH_SEPARATOR )
+      browser_env.flatten!
+      browser_env.delete_if { |b| b.nil? || (b.strip.size == 0) }
+      return browser_env
+    end
+
+    # Get the full commandline of what we are going to add the uri to
+    def browser
+      possibilities = (browser_env + app_list).flatten
+      possibilities.each do |p|
+        Launchy.log "#{self.class.name} : possibility : #{p}"
+      end
+      b = possibilities.shift
+      Launchy.log "#{self.class.name} : Using browser value '#{b}'"
+      return b
+    end
+
+    # final assembly of the command and do %s substitution 
+    # http://www.catb.org/~esr/BROWSER/index.html
+    def open( uri, options = {} )
+      b = browser
+      args = [ uri.to_s ]
+      if b =~ /%s/ then
+        b.gsub!( /%s/, args.shift )
+      end
+      run( b, args )
+    end
+  end
+end

data/lib/launchy/cli.rb

@@ -0,0 +1,70 @@
+require 'optparse'
+
+module Launchy
+  class Cli
+
+    attr_reader :options
+    def initialize
+      @options = {}
+    end
+  
+    def parser
+      @parser ||= OptionParser.new do |op|
+        op.banner = "Usage: launchy [options] thing-to-launch"
+
+        op.separator ""
+        op.separator "Launch Options:"
+
+        op.on( "-a", "--application APPLICATION", 
+               "Explicitly specify the application class to use in the launch") do |app|
+          options[:application] = app
+        end
+
+        op.on( "-d", "--debug", 
+               "Force debug. Output lots of information.") do |d|
+          options[:debug] = 'true'
+        end
+
+        op.on( "-e", "--engine RUBY_ENGINE",
+               "Force launchy to behave as if it was on a particular ruby engine.") do |e|
+          options[:ruby_engine] = e
+        end
+
+        op.on( "-n", "--dry-run", "Don't launchy, print the command to be executed on stdout" ) do |x|
+          options[:dry_run] = true
+        end
+
+        op.on( "-o", "--host-os HOST_OS", 
+               "Force launchy to behave as if it was on a particular host os.") do |os|
+          options[:host_os] = os
+        end
+
+
+        op.separator ""
+        op.separator "Standard Options:"
+
+        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
+
+      end
+    end
+
+    def run( argv = ARGV, env = ENV )
+      begin
+        parser.parse!( argv )
+        Launchy.open( argv.shift, options )
+      rescue ::OptionParser::ParseError => pe
+        $stderr.puts "#{parser.program_name}: #{pe}"
+        $stderr.puts "Try `#{parser.program_name} --help for more information."
+        exit 1
+      end
+    end
+  end
+end

data/lib/launchy/descendant_tracker.rb

@@ -0,0 +1,49 @@
+require 'set'
+
+module Launchy
+  #
+  # Use by either
+  #
+  #   class Foo
+  #     extend DescendantTracker
+  #   end
+  #
+  # or
+  #   
+  #   class Foo
+  #     class << self
+  #       include DescendantTracker
+  #     end
+  #   end
+  #
+  # It will track all the classes that inherit from the extended class and keep
+  # them in a Set that is available via the 'children' method.
+  #
+  module DescendantTracker
+    def inherited( klass )
+      return unless klass.instance_of?( Class )
+      self.children << klass
+    end
+
+    #
+    # The list of children that are registered
+    #
+    def children
+      unless defined? @children
+        @children = Set.new
+      end
+      return @children
+    end
+
+    #
+    # Find one of the child classes by calling the given method
+    # and passing all the rest of the parameters to that method in 
+    # each child
+    def find_child( method, *args )
+      klass = children.find do |child|
+        Launchy.log "Checking if class #{child} is the one for #{method}(#{args.join(', ')})}"
+        child.send( method, *args )
+      end
+    end
+  end
+end

data/lib/launchy/detect.rb

@@ -0,0 +1,10 @@
+module Launchy
+  module Detect
+  end
+end
+
+require 'launchy/detect/host_os'
+require 'launchy/detect/host_os_family'
+require 'launchy/detect/ruby_engine'
+require 'launchy/detect/nix_desktop_environment'
+require 'launchy/detect/runner'

data/lib/launchy/detect/host_os.rb

@@ -0,0 +1,31 @@
+require 'rbconfig'
+
+module Launchy::Detect
+  class HostOs
+
+    attr_reader :host_os
+    alias to_s host_os
+
+    def initialize( host_os = nil )
+      @host_os = host_os
+
+      if not @host_os then
+        if @host_os = override_host_os then
+          Launchy.log "Using LAUNCHY_HOST_OS override value of '#{Launchy.host_os}'"
+        else
+          @host_os = default_host_os
+        end
+      end
+    end
+
+    def default_host_os
+      ::RbConfig::CONFIG['host_os']
+    end
+
+    def override_host_os
+      Launchy.host_os
+    end
+
+  end
+
+end

data/lib/launchy/detect/host_os_family.rb

@@ -0,0 +1,71 @@
+module Launchy::Detect
+  # Detect the current host os family
+  #
+  # If the current host familiy cannot be detected then return
+  # HostOsFamily::Unknown
+  class HostOsFamily
+    class NotFoundError < Launchy::Error; end
+    extend ::Launchy::DescendantTracker
+
+    class << self
+
+      def detect( host_os = HostOs.new )
+        found = find_child( :matches?, host_os )
+        return found.new( host_os ) if found
+        raise NotFoundError, "Unknown OS family for host os '#{host_os}'. #{Launchy.bug_report_message}"
+      end
+
+      def matches?( host_os )
+        matching_regex.match( host_os.to_s )
+      end
+
+      def windows?() self == Windows; end
+      def darwin?()  self == Darwin;  end
+      def nix?()     self == Nix;     end
+      def cygwin?()  self == Cygwin;  end
+    end
+
+
+    attr_reader :host_os
+    def initialize( host_os = HostOs.new )
+      @host_os = host_os
+    end
+
+    def windows?() self.class.windows?; end
+    def darwin?()  self.class.darwin?;  end
+    def nix?()     self.class.nix?;      end
+    def cygwin?()  self.class.cygwin?;  end
+
+    #---------------------------
+    # All known host os families
+    #---------------------------
+    #
+    class Windows < HostOsFamily
+      def self.matching_regex
+        /(mingw|mswin|windows)/i
+      end
+      def app_list( app ) app.windows_app_list; end
+    end
+
+    class Darwin < HostOsFamily
+      def self.matching_regex
+        /(darwin|mac os)/i
+      end
+      def app_list( app ) app.darwin_app_list; end
+    end
+
+    class Nix < HostOsFamily
+      def self.matching_regex
+        /(linux|bsd|aix|solaris)/i
+      end
+      def app_list( app ) app.nix_app_list; end
+    end
+
+    class Cygwin < HostOsFamily
+      def self.matching_regex
+        /cygwin/i
+      end
+      def app_list( app ) app.cygwin_app_list; end
+    end
+  end
+end

data/lib/launchy/detect/nix_desktop_environment.rb

@@ -0,0 +1,60 @@
+module Launchy::Detect
+  #
+  # Detect the current desktop environment for *nix machines
+  # Currently this is Linux centric. The detection is based upon the detection
+  # used by xdg-open from http://portland.freedesktop.org/wiki/XdgUtils
+  class NixDesktopEnvironment
+    class NotFoundError < Launchy::Error; end
+
+    extend ::Launchy::DescendantTracker
+
+    # Detect the current *nix desktop environment
+    #
+    # If the current dekstop environment be detected, the return
+    # NixDekstopEnvironment::Unknown
+    def self.detect
+      found = find_child( :is_current_desktop_environment? )
+      return found if found
+      raise NotFoundError, "Current Desktop environment not found. #{Launchy.bug_report_message}"
+    end
+
+    def self.fallback_browsers
+      %w[ firefox seamonkey opera mozilla netscape galeon ]
+    end
+
+    #---------------------------------------
+    # The list of known desktop environments
+    #---------------------------------------
+
+    class Kde < NixDesktopEnvironment
+      def self.is_current_desktop_environment?
+        ENV['KDE_FULL_SESSION']
+      end
+
+      def self.browser
+        'kfmclient'
+      end
+    end
+
+    class Gnome < NixDesktopEnvironment
+      def self.is_current_desktop_environment?
+        ENV['GNOME_DESKTOP_SESSION_ID']
+      end
+
+      def self.browser
+        'gnome-open'
+      end
+    end
+
+    class Xfce < NixDesktopEnvironment
+      def self.is_current_desktop_environment?
+        %x[ xprop -root _DT_SAVE_MODE | grep ' = \"xfce\"$' ].strip.size > 0
+      end
+
+      def self.browser
+        'exo-open'
+      end
+    end
+  end
+end
+

data/lib/launchy/detect/ruby_engine.rb

@@ -0,0 +1,78 @@
+module Launchy::Detect
+  class RubyEngine
+    class NotFoundError < Launchy::Error; end
+
+    extend ::Launchy::DescendantTracker
+
+    # Detect the current ruby engine.
+    #
+    # If the current ruby engine cannot be detected, the return
+    # RubyEngine::Unknown
+    def self.detect( ruby_engine = RubyEngine.new )
+      found = find_child( :is_current_engine?, ruby_engine.to_s )
+      return found if found
+      raise NotFoundError, "#{ruby_engine_error_message( ruby_engine )} #{Launchy.bug_report_message}"
+    end
+
+    def self.ruby_engine_error_message( ruby_engine )
+      msg = "Unkonwn RUBY_ENGINE "
+      if ruby_engine then
+        msg += " '#{ruby_engine}'."
+      elsif defined?( RUBY_ENGINE ) then
+        msg += " '#{RUBY_ENGINE}'."
+      else
+        msg = "RUBY_ENGINE not defined for #{RUBY_DESCRIPTION}."
+      end
+      return msg
+    end
+
+    def self.is_current_engine?( ruby_engine )
+      return ruby_engine == self.engine_name
+    end
+
+    def self.mri?()     self == Mri;     end
+    def self.jruby?()   self == Jruby;   end
+    def self.rbx?()     self == Rbx;     end
+    def self.macruby?() self == MacRuby; end
+
+    attr_reader :ruby_engine
+    alias to_s ruby_engine
+    def initialize( ruby_engine = Launchy.ruby_engine )
+      if ruby_engine then
+        @ruby_engine = ruby_engine
+      else
+        @ruby_engine = defined?( RUBY_ENGINE ) ? RUBY_ENGINE : "ruby"
+      end
+    end
+
+
+    #-------------------------------
+    # The list of known ruby engines
+    #-------------------------------
+
+    #
+    # This is the ruby engine if the RUBY_ENGINE constant is not defined
+    class Mri < RubyEngine
+      def self.engine_name() "ruby"; end
+      def self.is_current_engine?( ruby_engine )
+        if ruby_engine then
+          super( ruby_engine )
+        else
+          return true if not Launchy.ruby_engine and not defined?( RUBY_ENGINE )
+        end
+      end
+    end
+
+    class Jruby < RubyEngine
+      def self.engine_name() "jruby"; end
+    end
+
+    class Rbx < RubyEngine
+      def self.engine_name() "rbx"; end
+    end
+
+    class MacRuby < RubyEngine
+      def self.engine_name() "macruby"; end
+    end
+  end
+end

data/lib/launchy/detect/runner.rb

@@ -0,0 +1,96 @@
+require 'shellwords'
+
+module Launchy::Detect
+  class Runner
+    class NotFoundError < Launchy::Error; end
+
+    extend ::Launchy::DescendantTracker
+
+    # Detect the current command runner
+    #
+    # If a runner cannot be detected then raise Runner::NotFoundError
+    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 escaped according to shell rules.
+    #
+    def shell_commands( cmd, args )
+      cmdline = [ cmd.shellsplit ]
+      cmdline << args.collect{ |a| a.to_s.shellescape }
+      return commanddline_normalize( cmdline )
+    end
+
+    def commandline_normalize( cmdline )
+      c = cmdline.flatten!
+      c = c.find_all { |a| (not a.nil?) and ( a.size > 0 ) }
+      Launchy.log "ARGV => #{c.inspect}"
+      return c
+    end
+
+    def run( cmd, *args )
+      if Launchy.dry_run? then
+        puts dry_run( cmd, *args )
+      else
+        wet_run( cmd, *args )
+      end
+    end
+
+
+    #---------------------------------------
+    # The list of known runners
+    #---------------------------------------
+
+    class Windows < Runner
+      def dry_run( cmd, *args )
+        "cmd /c #{shell_commands( cmd, args).join(" " )}"
+      end
+
+      def shell_commands( cmd, args )
+        cmdline = [ cmd ]
+        cmdline << args.collect { |a| a.to_s.gsub("&", "^&") }
+        return commandline_normalize( cmdline )
+      end
+
+      def wet_run( cmd, *args )
+        system( 'cmd', '/c', *shell_commands( cmd, *args ) )
+      end
+    end
+
+    class Jruby < Runner
+
+      def dry_run( cmd, *args )
+        shell_commands(cmd, args).join(" ")
+      end
+
+      def wet_run( cmd, *args )
+        Spoon.spawnp( *shell_commands( cmd, args ) )
+      end
+    end
+
+    class Forkable < Runner
+      def dry_run( cmd, *args )
+        shell_commands(cmd, args).join(" ")
+      end
+
+      def wet_run( cmd, *args )
+        child_pid = fork do
+          exec( *shell_commands( cmd, args ))
+          exit!
+        end
+        Process.detach( child_pid )
+      end
+    end
+  end
+end