"Welches in Ruby": Überprüfen, ob ein Programm in $ PATH von Ruby vorhanden ist

Meine Skripte stützen sich stark auf externe Programme und Skripte. Ich muss sicher sein, dass ein Programm vorhanden ist, das ich aufrufen muss. Manuell würde ich dies mit 'which' in der Kommandozeile überprüfen.

Gibt es ein Äquivalent zu File.exists?für Dinge in $PATH?

(Ja, ich denke ich könnte analysieren, %x[which scriptINeedToRun]aber das ist nicht super elegant.

Vielen Dank! Yannick

UPDATE: Hier ist die Lösung, die ich beibehalten habe:

 def command?(command)
       system("which #{ command} > /dev/null 2>&1")
 end

UPDATE 2: Einige neue Antworten sind eingegangen - zumindest einige davon bieten bessere Lösungen.

Update 3: Das Gem ptools hat der File-Klasse eine "which" -Methode hinzugefügt .

Echte plattformübergreifende Lösung, funktioniert unter Windows ordnungsgemäß:

# Cross-platform way of finding an executable in the $PATH.
#
#   which('ruby') #=> /usr/bin/ruby
def which(cmd)
  exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
  ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
    exts.each do |ext|
      exe = File.join(path, "#{cmd}#{ext}")
      return exe if File.executable?(exe) && !File.directory?(exe)
    end
  end
  nil
end

Dies verwendet kein Host-Betriebssystem-Sniffing und respektiert $ PATHEXT, das gültige Dateierweiterungen für ausführbare Dateien unter Windows auflistet.

Shelling out whichfunktioniert auf vielen Systemen, aber nicht auf allen.

Verwenden Sie die find_executableMethode, von mkmfder aus stdlib enthalten ist.

require 'mkmf'

find_executable 'ruby'
#=> "/Users/narkoz/.rvm/rubies/ruby-2.0.0-p0/bin/ruby"

find_executable 'which-ruby'
#=> nil

def command?(name)
  `which #{name}`
  $?.success?
end

Ursprünglich vom Hub genommen , der type -tstattdessen verwendet wurde which(und der für mich sowohl für zsh als auch für bash fehlgeschlagen ist).

Verwenden Sie MakeMakefile # find_executable0 mit deaktivierter Protokollierung

Es gibt bereits eine Reihe guter Antworten, aber ich verwende Folgendes:

require 'mkmf'

def set_mkmf_log(logfile=File::NULL)
  MakeMakefile::Logging.instance_variable_set(:@logfile, logfile)
end

# Return path to cmd as a String, or nil if not found.
def which(cmd)
  old_mkmf_log = MakeMakefile::Logging.instance_variable_get(:@logfile)
  set_mkmf_log(nil)
  path_to_cmd = find_executable0(cmd)
  set_mkmf_log(old_mkmf_log)
  path_to_cmd
end

Dies verwendet die undokumentierte Methode # find_executable0 , die von MakeMakefile # find_executable aufgerufen wird , um den Pfad zurückzugeben, ohne die Standardausgabe zu überladen . Die Methode #which leitet die mkmf-Protokolldatei auch vorübergehend nach / dev / null um, um zu verhindern, dass das aktuelle Arbeitsverzeichnis mit "mkmf.log" oder ähnlichem überfüllt ist.

Sie können mit dem ENV-Hash auf Systemumgebungsvariablen zugreifen:

puts ENV['PATH']

Der PATH wird auf Ihrem System zurückgegeben. Wenn Sie also wissen möchten, ob ein Programm nmapvorhanden ist, können Sie dies tun:

ENV['PATH'].split(':').each {|folder| puts File.exists?(folder+'/nmap')}

Dies wird gedruckt, truewenn eine Datei gefunden wurde oder falsenicht.

Hier ist was ich benutze. Dies ist plattformneutral ( File::PATH_SEPARATORist ":"auf Unix und ";"Windows), sieht nur für Programmdateien , die tatsächlich durch die effektiven Benutzer des aktuellen Prozesses ausgeführt werden kann , und endet, sobald das Programm gefunden wird:

##
# Returns +true+ if the +program+ executable is found in the user's path.
def has_program?(program)
  ENV['PATH'].split(File::PATH_SEPARATOR).any? do |directory|
    File.executable?(File.join(directory, program.to_s))
  end
end

Es wurde ein Juwel gerufen which_ruby Pure-Ruby, dessen Implementierung. Es ist nicht mehr verfügbar.

Ich fand jedoch diese reine Ruby-Alternative .

Ich möchte hinzufügen, dass whichdas Flag -sfür den stillen Modus verwendet wird, wodurch nur das Erfolgsflag gesetzt wird, sodass die Ausgabe nicht mehr umgeleitet werden muss.

Dies ist eine verbesserte Version, die auf der Antwort von @ mislav basiert . Dies würde jede Art von Pfadeingabe ermöglichen und folgt genau der cmd.exeAuswahl der Datei, die in Windows ausgeführt werden soll.

# which(cmd) :: string or nil
#
# Multi-platform implementation of "which".
# It may be used with UNIX-based and DOS-based platforms.
#
# The argument can not only be a simple command name but also a command path
# may it be relative or complete.
#
def which(cmd)
  raise ArgumentError.new("Argument not a string: #{cmd.inspect}") unless cmd.is_a?(String)
  return nil if cmd.empty?
  case RbConfig::CONFIG['host_os']
  when /cygwin/
    exts = nil
  when /dos|mswin|^win|mingw|msys/
    pathext = ENV['PATHEXT']
    exts = pathext ? pathext.split(';').select{ |e| e[0] == '.' } : ['.com', '.exe', '.bat']
  else
    exts = nil
  end
  if cmd[File::SEPARATOR] or (File::ALT_SEPARATOR and cmd[File::ALT_SEPARATOR])
    if exts
      ext = File.extname(cmd)
      if not ext.empty? and exts.any?{ |e| e.casecmp(ext).zero? } \
      and File.file?(cmd) and File.executable?(cmd)
        return File.absolute_path(cmd)
      end
      exts.each do |ext|
        exe = "#{cmd}#{ext}"
        return File.absolute_path(exe) if File.file?(exe) and File.executable?(exe)
      end
    else
      return File.absolute_path(cmd) if File.file?(cmd) and File.executable?(cmd)
    end
  else
    paths = ENV['PATH']
    paths = paths ? paths.split(File::PATH_SEPARATOR).select{ |e| File.directory?(e) } : []
    if exts
      ext = File.extname(cmd)
      has_valid_ext = (not ext.empty? and exts.any?{ |e| e.casecmp(ext).zero? })
      paths.unshift('.').each do |path|
        if has_valid_ext
          exe = File.join(path, "#{cmd}")
          return File.absolute_path(exe) if File.file?(exe) and File.executable?(exe)
        end
        exts.each do |ext|
          exe = File.join(path, "#{cmd}#{ext}")
          return File.absolute_path(exe) if File.file?(exe) and File.executable?(exe)
        end
      end
    else
      paths.each do |path|
        exe = File.join(path, cmd)
        return File.absolute_path(exe) if File.file?(exe) and File.executable?(exe)
      end
    end
  end
  nil
end

Ich habe das:

def command?(name)
  [name,
   *ENV['PATH'].split(File::PATH_SEPARATOR).map {|p| File.join(p, name)}
  ].find {|f| File.executable?(f)}
end

funktioniert für vollständige Pfade sowie Befehle:

irb(main):043:0> command?("/bin/bash")
=> "/bin/bash"
irb(main):044:0> command?("bash")
=> "/bin/bash"
irb(main):006:0> command?("bush")
=> nil

Unter Linux benutze ich:

exists = `which #{command}`.size.>(0)

Leider whichhandelt es sich nicht um einen POSIX-Befehl und verhält sich daher auf Mac, BSD usw. anders (dh es wird ein Fehler ausgegeben, wenn der Befehl nicht gefunden wird). Vielleicht wäre die ideale Lösung zu verwenden

`command -v #{command}`.size.>(0)  # fails!: ruby can't access built-in functions

Dies schlägt jedoch fehl, da Ruby anscheinend nicht in der Lage ist, auf integrierte Funktionen zuzugreifen. Wäre command -vaber der POSIX-Weg, dies zu tun.

Lösung basierend auf Rogeriovl, aber vollständige Funktion mit Ausführungstest statt Existenztest.

def command_exists?(command)
  ENV['PATH'].split(':').each {|folder| File.executable?(File.join(folder, command))}
end

Funktioniert nur unter UNIX (Windows verwendet keinen Doppelpunkt als Trennzeichen)

Dies ist eine Optimierung der Antwort von Rogeriopvl, die es plattformübergreifend macht:

require 'rbconfig'

def is_windows?
  Config::CONFIG["host_os"] =~ /mswin|mingw/
end

def exists_in_path?(file)
  entries = ENV['PATH'].split(is_windows? ? ";" : ":")
  entries.any? {|f| File.exists?("#{f}/#{file}")}
end

für jruby eine der Lösungen, die davon abhängen mkmf funktioniert möglicherweise keine , da sie eine C-Erweiterung hat.

Für jruby ist Folgendes eine einfache Möglichkeit, um zu überprüfen, ob auf dem Pfad etwas ausführbar ist:

main » unix_process = java.lang.Runtime.getRuntime().exec("git status")
=> #<Java::JavaLang::UNIXProcess:0x64fa1a79>
main » unix_process.exitValue()
=> 0
main »

Wenn die ausführbare Datei nicht vorhanden ist, wird ein Laufzeitfehler ausgelöst. Daher möchten Sie dies möglicherweise in einem Try / Catch-Block in Ihrer tatsächlichen Verwendung tun.

#####################################################
# add methods to see if there's an executable that's executable
#####################################################
class File
  class << self
    ###########################################
    # exists and executable
    ###########################################
    def cmd_executable?(cmd)
      !ENV['PATH'].split(':').select { |f| executable?(join(f, cmd[/^[^ \n\r]*/])) }.empty?
    end
  end
end

Nicht so elegant, aber es funktioniert :).

def cmdExists?(c)
  system(c + " > /dev/null")
  return false if $?.exitstatus == 127
  true
end

Warnung : Dies wird NICHT empfohlen, gefährlicher Rat!