launchy 2.5.2 → 3.1.1

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,55 @@
+# 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 = shell_commands(cmd, args)
+      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.2"
+  VERSION = "3.1.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]