launchy 3.0.0 → 3.0.1

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|msys|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|sunos|dragonfly)/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,8 +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/nix_desktop_environment'
+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

@@ -1,19 +1,27 @@
-require 'childprocess'
+# frozen_string_literal: true
+
+require "childprocess"
 module Launchy
+  # Internal: Run a command in a child process
+  #
   class Runner
-    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 )
+    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 )
+        wet_run(cmd, *args)
       end
     end
 
-    def wet_run( cmd, *args )
-      argv = [ cmd, *args ].flatten
+    def wet_run(cmd, *args)
+      argv = [cmd, *args].flatten
       Launchy.log "ChildProcess: argv => #{argv.inspect}"
-      process = ChildProcess.build( *argv )
+      process = ChildProcess.build(*argv)
 
       process.io.inherit!
       process.leader = true
@@ -21,7 +29,7 @@ module Launchy
       process.start
     end
 
-    def dry_run( cmd, *args )
+    def dry_run(cmd, *args)
       shell_commands(cmd, args).join(" ")
     end
 
@@ -30,17 +38,17 @@ module Launchy
     # 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{ |a| a.to_s }
-      return commandline_normalize( cmdline )
+    def shell_commands(cmd, args)
+      cmdline = [cmd.to_s.shellsplit]
+      cmdline << args.flatten.collect(&:to_s)
+      commandline_normalize(cmdline)
     end
 
-    def commandline_normalize( cmdline )
+    def commandline_normalize(cmdline)
       c = cmdline.flatten!
-      c = c.find_all { |a| (not a.nil?) and ( a.size > 0 ) }
+      c = c.find_all { |a| !a.nil? and a.size.positive? }
       Launchy.log "commandline_normalized => #{c.join(' ')}"
-      return c
+      c
     end
   end
 end

data/lib/launchy/version.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Launchy
-  VERSION = "3.0.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]

data/lib/launchy.rb

@@ -1,6 +1,9 @@
-require 'addressable/uri'
-require 'shellwords'
-require 'stringio'
+# frozen_string_literal: true
+
+require "English"
+require "addressable/uri"
+require "shellwords"
+require "stringio"
 
 #
 # The entry point into Launchy. This is the sole supported public API.
@@ -19,59 +22,62 @@ require 'stringio'
 # application class
 #
 module Launchy
-
   class << self
     #
     # Launch an application for the given uri string
     #
-    def open(uri_s, options = {}, &error_block )
-      leftover = extract_global_options( options )
-      uri = string_to_uri( uri_s )
-      if name = options[:application] then
-        app = app_for_name( name )
+    def open(uri_s, options = {})
+      leftover = extract_global_options(options)
+      uri = string_to_uri(uri_s)
+      if (name = options[:application])
+        app = app_for_name(name)
       end
 
-      if app.nil? then
-        app = app_for_uri( uri )
-      end
+      app = app_for_uri(uri) if app.nil?
 
-      app.new.open( uri, leftover )
-    rescue Launchy::Error => le
-      raise le
-    rescue Exception => e
+      app.new.open(uri, leftover)
+    rescue Launchy::Error => e
+      raise e
+    rescue StandardError => e
       msg = "Failure in opening uri #{uri_s.inspect} with options #{options.inspect}: #{e}"
       raise Launchy::Error, msg
     ensure
-      if $! && block_given? then
-        yield $!
-        return # explicitly swallow the errors
+      if $ERROR_INFO && block_given?
+        yield $ERROR_INFO
+
+        # explicitly return here to swallow the errors if there was an error
+        # and we yielded to the block
+        # rubocop:disable Lint/EnsureReturn
+        return
+        # rubocop:enable Lint/EnsureReturn
       end
     end
 
-    def app_for_uri( uri )
-      Launchy::Application.handling( uri )
+    def app_for_uri(uri)
+      Launchy::Application.handling(uri)
     end
 
-    def app_for_name( name )
-      Launchy::Application.for_name( name )
+    def app_for_name(name)
+      Launchy::Application.for_name(name)
     rescue Launchy::ApplicationNotFoundError
       nil
     end
 
-    def app_for_uri_string( s )
-      app_for_uri( string_to_uri( s ) )
+    def app_for_uri_string(str)
+      app_for_uri(string_to_uri(str))
     end
 
-    def string_to_uri( s )
-      s = s.to_s
-      uri = Addressable::URI.parse( s )
-      Launchy.log "URI parsing pass 1 : #{s} -> #{uri.to_hash}"
-      if not uri.scheme then
-        uri = Addressable::URI.heuristic_parse( s )
-        Launchy.log "URI parsing pass 2 : #{s} -> #{uri.to_hash}"
+    def string_to_uri(str)
+      str = str.to_s
+      uri = Addressable::URI.parse(str)
+      Launchy.log "URI parsing pass 1 : #{str} -> #{uri.to_hash}"
+      unless uri.scheme
+        uri = Addressable::URI.heuristic_parse(str)
+        Launchy.log "URI parsing pass 2 : #{str} -> #{uri.to_hash}"
       end
-      raise Launchy::ArgumentError, "Invalid URI given: #{s.inspect}" unless uri
-      return uri
+      raise Launchy::ArgumentError, "Invalid URI given: #{str.inspect}" unless uri
+
+      uri
     end
 
     def reset_global_options
@@ -79,49 +85,49 @@ module Launchy
       Launchy.application = nil
       Launchy.host_os     = nil
       Launchy.dry_run     = false
-      Launchy.path        = ENV['PATH']
+      Launchy.path        = ENV.fetch("PATH", nil)
     end
 
-    def extract_global_options( options )
+    def extract_global_options(options)
       leftover = options.dup
-      Launchy.debug        = leftover.delete( :debug       ) || ENV['LAUNCHY_DEBUG']
-      Launchy.application  = leftover.delete( :application ) || ENV['LAUNCHY_APPLICATION']
-      Launchy.host_os      = leftover.delete( :host_os     ) || ENV['LAUNCHY_HOST_OS']
-      Launchy.dry_run      = leftover.delete( :dry_run     ) || ENV['LAUNCHY_DRY_RUN']
+      Launchy.debug        = leftover.delete(:debug) || ENV.fetch("LAUNCHY_DEBUG", nil)
+      Launchy.application  = leftover.delete(:application) || ENV.fetch("LAUNCHY_APPLICATION", nil)
+      Launchy.host_os      = leftover.delete(:host_os) || ENV.fetch("LAUNCHY_HOST_OS", nil)
+      Launchy.dry_run      = leftover.delete(:dry_run) || ENV.fetch("LAUNCHY_DRY_RUN", nil)
     end
 
-    def debug=( d )
-      @debug = to_bool( d )
+    def debug=(enabled)
+      @debug = to_bool(enabled)
     end
 
     # we may do logging before a call to 'open', hence the need to check
     # LAUNCHY_DEBUG here
     def debug?
-      @debug || to_bool( ENV['LAUNCHY_DEBUG'] )
+      @debug || to_bool(ENV.fetch("LAUNCHY_DEBUG", nil))
     end
 
-    def application=( app )
+    def application=(app)
       @application = app
     end
 
     def application
-      @application || ENV['LAUNCHY_APPLICATION']
+      @application || ENV.fetch("LAUNCHY_APPLICATION", nil)
     end
 
-    def host_os=( host_os )
+    def host_os=(host_os)
       @host_os = host_os
     end
 
     def host_os
-      @host_os || ENV['LAUNCHY_HOST_OS']
+      @host_os || ENV.fetch("LAUNCHY_HOST_OS", nil)
     end
 
-    def dry_run=( dry_run )
-      @dry_run = to_bool( dry_run )
+    def dry_run=(dry_run)
+      @dry_run = to_bool(dry_run)
     end
 
     def dry_run?
-      @dry_run || to_bool( ENV['LAUNCHY_DRY_RUN'] )
+      @dry_run || to_bool(ENV.fetch("LAUNCHY_DRY_RUN", nil))
     end
 
     def bug_report_message
@@ -140,15 +146,13 @@ module Launchy
       @path = path
     end
 
-  private
-    def to_bool( arg )
+    private
+
+    def to_bool(arg)
       if arg.is_a? String
-        arg == 'true'
-      elsif arg.is_a? TrueClass
-        true
+        arg == "true"
       else
-        # All other values mapped to false.
-        false
+        arg.is_a? TrueClass
       end
     end
   end
@@ -157,11 +161,11 @@ module Launchy
   Launchy.reset_global_options
 end
 
-require 'launchy/version'
-require 'launchy/argv'
-require 'launchy/cli'
-require 'launchy/descendant_tracker'
-require 'launchy/error'
-require 'launchy/application'
-require 'launchy/detect'
-require 'launchy/runner'
+require "launchy/version"
+require "launchy/argv"
+require "launchy/cli"
+require "launchy/descendant_tracker"
+require "launchy/error"
+require "launchy/application"
+require "launchy/detect"
+require "launchy/runner"