launchy 2.5.0 → 3.0.1

data/lib/launchy/cli.rb

@@ -1,9 +1,13 @@
-require 'optparse'
+# frozen_string_literal: true
+
+require "optparse"
 
 module Launchy
+  # Internal: Command line interface for Launchy
+  #
   class Cli
-
     attr_reader :options
+
     def initialize
       @options = {}
     end
@@ -15,75 +19,66 @@ module Launchy
         op.separator ""
         op.separator "Launch Options:"
 
-        op.on( "-a", "--application APPLICATION", 
-               "Explicitly specify the application class to use in the launch") do |app|
+        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|
+        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|
+        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|
+        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|
+        op.on("-h", "--help", "Print this message.") do |_h|
           $stdout.puts op.to_s
           exit 0
         end
 
-        op.on( "-v", "--version", "Output the version of Launchy") do |v|
+        op.on("-v", "--version", "Output the version of Launchy") do |_v|
           $stdout.puts "Launchy version #{Launchy::VERSION}"
           exit 0
         end
-
       end
     end
 
-    def parse( argv, env )
-      parser.parse!( argv )
-      return true
-    rescue ::OptionParser::ParseError => pe
-      error_output( pe )
+    def parse(argv, _env)
+      parser.parse!(argv)
+      true
+    rescue ::OptionParser::ParseError => e
+      error_output(e)
     end
 
-    def good_run( argv, env )
-      if parse( argv, env ) then
-        Launchy.open( argv.shift, options ) { |e| error_output( e ) }
-        return true
-      else
-        return false
-      end
+    def good_run(argv, env)
+      return false unless parse(argv, env)
+
+      Launchy.open(argv.shift, options) { |e| error_output(e) }
+      true
     end
 
-    def error_output( error )
+    def error_output(error)
       $stderr.puts "ERROR: #{error}"
       Launchy.log "ERROR: #{error}"
       error.backtrace.each do |bt|
         Launchy.log bt
       end
       $stderr.puts "Try `#{parser.program_name} --help' for more information."
-      return false
+      false
     end
 
-    def run( argv = ARGV, env = ENV )
-      exit 1 unless good_run( argv, env )
+    def run(argv = ARGV, env = ENV)
+      exit 1 unless good_run(argv, env)
     end
   end
 end

data/lib/launchy/descendant_tracker.rb

@@ -1,4 +1,6 @@
-require 'set'
+# frozen_string_literal: true
+
+require "set"
 
 module Launchy
   #
@@ -9,7 +11,7 @@ module Launchy
   #   end
   #
   # or
-  #   
+  #
   #   class Foo
   #     class << self
   #       include DescendantTracker
@@ -20,29 +22,29 @@ module Launchy
   # 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
+    def inherited(klass)
+      super
+      return unless klass.instance_of?(Class)
+
+      children << klass
     end
 
     #
     # The list of children that are registered
     #
     def children
-      unless defined? @children
-        @children = Array.new
-      end
-      return @children
+      @children = [] unless defined? @children
+      @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 
+    # and passing all the rest of the parameters to that method in
     # each child
-    def find_child( method, *args )
+    def find_child(method, *args)
       children.find do |child|
         Launchy.log "Checking if class #{child} is the one for #{method}(#{args.join(', ')})}"
-        child.send( method, *args )
+        child.send(method, *args)
       end
     end
   end

data/lib/launchy/detect/host_os.rb

@@ -1,32 +1,35 @@
-require 'rbconfig'
+# frozen_string_literal: true
 
-module Launchy::Detect
-  class HostOs
+require "rbconfig"
 
-    attr_reader :host_os
-    alias to_s host_os
-    alias to_str host_os
+module Launchy
+  module Detect
+    # Internal: Determine the host operating system that Launchy is running on
+    #
+    class HostOs
+      attr_reader :host_os
+      alias to_s host_os
+      alias to_str host_os
 
-    def initialize( host_os = nil )
-      @host_os = host_os
+      def initialize(host_os = nil)
+        @host_os = host_os
 
-      if not @host_os then
-        if @host_os = override_host_os then
+        return if @host_os
+
+        if (@host_os = override_host_os)
           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 default_host_os
+        ::RbConfig::CONFIG["host_os"].downcase
+      end
 
-    def override_host_os
-      Launchy.host_os
+      def override_host_os
+        Launchy.host_os
+      end
     end
-
   end
-
 end

data/lib/launchy/detect/host_os_family.rb

@@ -1,71 +1,112 @@
-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}"
+# frozen_string_literal: true
+
+module Launchy
+  module 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
 
-      def matches?( host_os )
-        matching_regex.match( host_os.to_s )
+      attr_reader :host_os
+
+      def initialize(host_os = HostOs.new)
+        @host_os = host_os
       end
 
-      def windows?() self == Windows; end
-      def darwin?()  self == Darwin;  end
-      def nix?()     self == Nix;     end
-      def cygwin?()  self == Cygwin;  end
-    end
+      def windows?
+        self.class.windows?
+      end
 
+      def darwin?
+        self.class.darwin?
+      end
 
-    attr_reader :host_os
-    def initialize( host_os = HostOs.new )
-      @host_os = host_os
-    end
+      def nix?
+        self.class.nix?
+      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
+      def cygwin?
+        self.class.cygwin?
+      end
 
-    #---------------------------
-    # All known host os families
-    #---------------------------
-    #
-    class Windows < HostOsFamily
-      def self.matching_regex
-        /(mingw|mswin|windows)/i
+      #---------------------------
+      # All known host os families
+      #---------------------------
+      #
+      class Windows < HostOsFamily
+        def self.matching_regex
+          /(mingw|mswin|msys|windows)/i
+        end
+
+        def app_list(app)
+          app.windows_app_list
+        end
       end
-      def app_list( app ) app.windows_app_list; end
-    end
 
-    class Darwin < HostOsFamily
-      def self.matching_regex
-        /(darwin|mac os)/i
+      # Mac OS X family
+      class Darwin < HostOsFamily
+        def self.matching_regex
+          /(darwin|mac os)/i
+        end
+
+        def app_list(app)
+          app.darwin_app_list
+        end
       end
-      def app_list( app ) app.darwin_app_list; end
-    end
 
-    class Nix < HostOsFamily
-      def self.matching_regex
-        /(linux|bsd|aix|solaris)/i
+      # All the *nix family of operating systems, and BSDs
+      class Nix < HostOsFamily
+        def self.matching_regex
+          /(linux|bsd|aix|solaris|sunos|dragonfly)/i
+        end
+
+        def app_list(app)
+          app.nix_app_list
+        end
       end
-      def app_list( app ) app.nix_app_list; end
-    end
 
-    class Cygwin < HostOsFamily
-      def self.matching_regex
-        /cygwin/i
+      # Cygwin - if anyone is still using that
+      class Cygwin < HostOsFamily
+        def self.matching_regex
+          /cygwin/i
+        end
+
+        def app_list(app)
+          app.cygwin_app_list
+        end
       end
-      def app_list( app ) app.cygwin_app_list; end
     end
   end
 end

data/lib/launchy/detect/nix_desktop_environment.rb

@@ -1,93 +1,98 @@
-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/
-  class NixDesktopEnvironment
-    class NotFoundError < Launchy::Error; end
+# frozen_string_literal: true
 
-    extend ::Launchy::DescendantTracker
-
-    # Detect the current *nix desktop environment
+module Launchy
+  module Detect
     #
-    # If the current dekstop environment be detected, the return
-    # NixDekstopEnvironment::Unknown
-    def self.detect
-      found = find_child( :is_current_desktop_environment? )
-      Launchy.log("Current Desktop environment not found. #{Launchy.bug_report_message}") unless found
-      return found
-    end
+    # 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/
+    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?)
+        Launchy.log("Current Desktop environment not found. #{Launchy.bug_report_message}") unless found
+        found
+      end
 
-    def self.fallback_browsers
-      %w[ firefox iceweasel seamonkey opera mozilla netscape galeon links lynx ].map { |x| ::Launchy::Argv.new( x ) }
-    end
+      def self.fallback_browsers
+        %w[firefox iceweasel seamonkey opera mozilla netscape galeon links lynx].map { |x| ::Launchy::Argv.new(x) }
+      end
 
-    def self.browsers
-      [ browser, fallback_browsers ].flatten
-    end
+      def self.browsers
+        [browser, fallback_browsers].flatten
+      end
 
-    #---------------------------------------
-    # The list of known desktop environments
-    #---------------------------------------
+      #---------------------------------------
+      # The list of known desktop environments
+      #---------------------------------------
 
-    class Kde < NixDesktopEnvironment
-      def self.is_current_desktop_environment?
-        ENV['KDE_FULL_SESSION'] &&
-          Launchy::Application.find_executable( 'kde-open' )
-      end
+      # KDE desktop environment
+      class Kde < NixDesktopEnvironment
+        def self.is_current_desktop_environment?
+          ENV.fetch("KDE_FULL_SESSION", nil) &&
+            Launchy::Application.find_executable("kde-open")
+        end
 
-      def self.browser
-        ::Launchy::Argv.new( 'kde-open' )
+        def self.browser
+          ::Launchy::Argv.new("kde-open")
+        end
       end
-    end
 
-    class Gnome < NixDesktopEnvironment
-      def self.is_current_desktop_environment?
-        ENV['GNOME_DESKTOP_SESSION_ID'] &&
-          Launchy::Application.find_executable( 'gnome-open' )
-      end
+      # Gnome desktop environment
+      class Gnome < NixDesktopEnvironment
+        def self.is_current_desktop_environment?
+          ENV.fetch("GNOME_DESKTOP_SESSION_ID", nil) &&
+            Launchy::Application.find_executable("gnome-open")
+        end
 
-      def self.browser
-        ::Launchy::Argv.new( 'gnome-open' )
+        def self.browser
+          ::Launchy::Argv.new("gnome-open")
+        end
       end
-    end
 
-    class Xfce < NixDesktopEnvironment
-      def self.is_current_desktop_environment?
-        if Launchy::Application.find_executable( 'xprop' ) then
-          %x[ xprop -root _DT_SAVE_MODE].include?("xfce")
-        else
-          false
+      # Xfce desktop environment
+      class Xfce < NixDesktopEnvironment
+        def self.is_current_desktop_environment?
+          if Launchy::Application.find_executable("xprop")
+            `xprop -root _DT_SAVE_MODE`.include?("xfce")
+          else
+            false
+          end
         end
-      end
 
-      def self.browser
-        ::Launchy::Argv.new( %w[ exo-open --launch WebBrowser ] )
+        def self.browser
+          ::Launchy::Argv.new(%w[exo-open --launch WebBrowser])
+        end
       end
-    end
 
-    # Fall back environment as the last case
-    class Xdg < NixDesktopEnvironment
-      def self.is_current_desktop_environment?
-        Launchy::Application.find_executable( browser )
-      end
+      # Fall back environment as the last case
+      class Xdg < NixDesktopEnvironment
+        def self.is_current_desktop_environment?
+          Launchy::Application.find_executable(browser)
+        end
 
-      def self.browser
-        ::Launchy::Argv.new( 'xdg-open' )
+        def self.browser
+          ::Launchy::Argv.new("xdg-open")
+        end
       end
-    end
 
-    # The one that is found when all else fails. And this must be declared last
-    class NotFound < NixDesktopEnvironment
-      def self.is_current_desktop_environment?
-        true
-      end
+      # The one that is found when all else fails. And this must be declared last
+      class NotFound < NixDesktopEnvironment
+        def self.is_current_desktop_environment?
+          true
+        end
 
-      def self.browser
-        ::Launchy::Argv.new
+        def self.browser
+          ::Launchy::Argv.new
+        end
       end
     end
-
   end
 end
-

data/lib/launchy/detect.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Launchy
+  # Internal: Namespace for detecting the environment that Launchy is running in
+  #
   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'
+require "launchy/detect/host_os"
+require "launchy/detect/host_os_family"
+require "launchy/detect/nix_desktop_environment"

data/lib/launchy/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Launchy
   class Error < ::StandardError; end
   class ApplicationNotFoundError < Error; end

data/lib/launchy/os_family.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Launchy
   #
   # Model all the Operating system families that can exist.

data/lib/launchy/runner.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "childprocess"
+module Launchy
+  # Internal: Run a command in a child process
+  #
+  class Runner
+    def run(cmd, *args)
+      unless cmd
+        raise Launchy::CommandNotFoundError,
+              "No command found to run with args '#{args.join(' ')}'. If this is unexpected, #{Launchy.bug_report_message}"
+      end
+
+      if Launchy.dry_run?
+        $stdout.puts dry_run(cmd, *args)
+      else
+        wet_run(cmd, *args)
+      end
+    end
+
+    def wet_run(cmd, *args)
+      argv = [cmd, *args].flatten
+      Launchy.log "ChildProcess: argv => #{argv.inspect}"
+      process = ChildProcess.build(*argv)
+
+      process.io.inherit!
+      process.leader = true
+      process.detach = true
+      process.start
+    end
+
+    def dry_run(cmd, *args)
+      shell_commands(cmd, args).join(" ")
+    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 the 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(&:to_s)
+      commandline_normalize(cmdline)
+    end
+
+    def commandline_normalize(cmdline)
+      c = cmdline.flatten!
+      c = c.find_all { |a| !a.nil? and a.size.positive? }
+      Launchy.log "commandline_normalized => #{c.join(' ')}"
+      c
+    end
+  end
+end

data/lib/launchy/version.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Launchy
-  VERSION = "2.5.0"
+  VERSION = "3.0.1"
 
+  # Internal: Version number of Launchy
   module Version
-
-    MAJOR   = Integer(VERSION.split('.')[0])
-    MINOR   = Integer(VERSION.split('.')[1])
-    PATCH   = Integer(VERSION.split('.')[2])
+    MAJOR   = Integer(VERSION.split(".")[0])
+    MINOR   = Integer(VERSION.split(".")[1])
+    PATCH   = Integer(VERSION.split(".")[2])
 
     def self.to_a
       [MAJOR, MINOR, PATCH]