“Який у рубіні”: Перевірка, чи існує програма в $ PATH від ruby

мої сценарії значною мірою покладаються на зовнішні програми та сценарії. Мені потрібно бути впевненим, що існує програма, яку мені потрібно викликати. Вручну я б перевірив це, використовуючи 'which' у командному рядку.

Чи існує еквівалент File.exists?для речей у $PATH?

(так, я думаю, я міг би проаналізувати, %x[which scriptINeedToRun]але це не супер елегантно.

Дякую! янник

ОНОВЛЕННЯ: Ось рішення, яке я зберіг:

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

ОНОВЛЕННЯ 2: з’явилося кілька нових відповідей - принаймні деякі з них пропонують кращі рішення.

Оновлення 3: дорогоцінний камінь ptools додає метод "який" до класу File.

Справжнє крос-платформне рішення, працює належним чином у Windows:

# 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

Це не використовує обнюхування хост-ОС і поважає $ PATHEXT, де перелічені дійсні розширення файлів для виконуваних файлів у Windows.

Обговорення whichпрацює на багатьох системах, але не на всіх.

Використовуйте find_executableметод, з mkmfякого включено stdlib.

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

Спочатку взято з концентратора , який використовувався type -tзамість whichхоч (і який не вдався як для zsh, так і для bash).

Використовуйте MakeMakefile # find_executable0 з вимкненим журналом

Вже є кілька хороших відповідей, але ось що я використовую:

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

Тут використовується недокументований метод # find_executable0, викликаний MakeMakefile # find_executable, щоб повернути шлях без захаращення стандартного виводу. Метод #which також тимчасово перенаправляє файл журналу mkmf на / dev / null, щоб запобігти захаращенню поточного робочого каталогу "mkmf.log" або подібним.

Ви можете отримати доступ до змінних системного середовища за допомогою хешу ENV:

puts ENV['PATH']

Це поверне PATH у вашу систему. Отже, якщо ви хочете знати, чи nmapіснує програма , ви можете зробити це:

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

Це буде надруковано, trueякщо файл знайдено чи falseіншим чином.

Ось що я використовую. Це нейтрально для платформи ( File::PATH_SEPARATORє ":"в Unix та ";"Windows), шукає лише програмні файли, які насправді виконуються ефективним користувачем поточного процесу, і завершується, як тільки програма знайдена:

##
# 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

Існував GEM, який називався which_rubyчистим Ruby, реалізація якого. Це вже недоступно.

Однак я знайшов цю альтернативну реалізацію чистого Ruby .

Я хотів би додати, що whichпрапорець приймає -sтихий режим, який лише встановлює прапор успіху, усуваючи необхідність перенаправляти вихідні дані.

Це вдосконалена версія, заснована на відповіді @ mislav . Це дозволить вводити будь-який тип шляху та суворо слідкує за тим, як cmd.exeобирає файл для виконання у Windows.

# 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

У мене є таке:

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

працює для повних шляхів, а також команд:

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

У Linux я використовую:

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

На жаль, whichце не команда POSIX, тому вона поводиться по-різному на Mac, BSD тощо (тобто видає помилку, якщо команду не знайти). Можливо, ідеальним рішенням буде використання

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

Але це не вдається, оскільки ruby, здається, не може отримати доступ до вбудованих функцій. Але це command -vбув би спосіб POSIX для цього.

Рішення, засноване на rogeriovl, але повноцінна функція з тестом виконання, а не тестом існування.

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

Працюватиме лише для UNIX (Windows не використовує двокрапку як роздільник)

Це твір відповіді rogeriopvl, що робить його крос-платформенним:

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

для jruby - будь-яке рішення, яке залежить від mkmf може не працювати, оскільки воно має розширення C.

для jruby наступний простий спосіб перевірити, чи є щось виконуваним на шляху:

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

якщо виконуваного файлу немає, це спричинить помилку виконання, тому ви можете зробити це в блоці try / catch у своєму фактичному використанні.

#####################################################
# 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

Не настільки елегантно, але це працює :).

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

Попередження : це НЕ рекомендується, небезпечна порада!