Comment utiliser Ruby pour les scripts shell ?

Question

J'ai quelques tâches simples de script shell à effectuer

Par exemple : Sélection d'un fichier dans le répertoire de travail à partir d'une liste de fichiers correspondant à une expression régulière.

Je sais que je peux faire ce genre de choses en utilisant bash et grep, mais j'aimerais pouvoir créer des scripts rapides scripts qui fonctionneraient sous Windows et Linux sans avoir à mémoriser un tas de programmes en ligne de commande, de drapeaux, etc.

J'ai essayé de le faire, mais j'ai fini par ne plus savoir où je devais obtenir des informations telles qu'une référence au répertoire actuel.

La question est donc de savoir quelles parties des bibliothèques Ruby je dois connaître pour écrire des scripts ruby shell scripts ?

Answer 1

Par défaut, vous avez déjà accès à Dir y Fichier qui sont très utiles en soi.

Dir['*.rb'] #basic globs
Dir['**/*.rb'] #** == any depth of directory, including current dir.
#=> array of relative names

File.expand_path('~/file.txt') #=> "/User/mat/file.txt"
File.dirname('dir/file.txt') #=> 'dir'
File.basename('dir/file.txt') #=> 'file.txt'
File.join('a', 'bunch', 'of', 'strings') #=> 'a/bunch/of/strings'

__FILE__ #=> the name of the current file

La stdlib permet également d'utiliser FileUtils

require 'fileutils' #I know, no underscore is not ruby-like
include FileUtils
# Gives you access (without prepending by 'FileUtils.') to
cd(dir, options)
cd(dir, options) {|dir| .... }
pwd()
mkdir(dir, options)
mkdir(list, options)
mkdir_p(dir, options)
mkdir_p(list, options)
rmdir(dir, options)
rmdir(list, options)
ln(old, new, options)
ln(list, destdir, options)
ln_s(old, new, options)
ln_s(list, destdir, options)
ln_sf(src, dest, options)
cp(src, dest, options)
cp(list, dir, options)
cp_r(src, dest, options)
cp_r(list, dir, options)
mv(src, dest, options)
mv(list, dir, options)
rm(list, options)
rm_r(list, options)
rm_rf(list, options)
install(src, dest, mode = <src's>, options)
chmod(mode, list, options)
chmod_R(mode, list, options)
chown(user, group, list, options)
chown_R(user, group, list, options)
touch(list, options)

Ce qui est plutôt bien

Answer 2

Comme les autres l'ont déjà dit, votre première ligne devrait être

#!/usr/bin/env ruby

Vous devez également le rendre exécutable : (dans le shell)

chmod +x test.rb

Vient ensuite le code ruby. Si vous ouvrez un fichier

File.open("file", "r") do |io|
    # do something with io
end

le fichier est ouvert dans le répertoire courant que vous obtiendriez avec pwd dans la coquille.

Le chemin d'accès à votre script est également simple à obtenir. Avec $0 vous obtenez le premier argument du shell, qui est le chemin relatif vers votre script. Le chemin absolu peut être déterminé comme suit :

#!/usr/bin/env ruby
require 'pathname'
p Pathname.new($0).realpath()

Pour les opérations sur le système de fichiers, j'utilise presque toujours Pathname. Il s'agit d'une enveloppe pour de nombreuses autres classes liées au système de fichiers. Également utiles : Dir, File...

Answer 3

Voici quelque chose d'important qui n'a pas été mentionné dans les autres réponses : les paramètres de la ligne de commande sont exposés à votre shell Ruby script à travers le tableau ARGV (global).

Ainsi, si vous avez un script appelé my_shell_script :

#!/usr/bin/env ruby
puts "I was passed: "
ARGV.each do |value|
  puts value
end

...le rendre exécutable (comme d'autres l'ont mentionné) :

chmod u+x my_shell_script

Et appelez-le ainsi :

> ./my_shell_script one two three four five

Vous obtiendrez ceci :

I was passed: 
one
two
three
four
five

Les arguments sont compatibles avec l'expansion des noms de fichiers :

./my_shell_script *

I was passed: 
a_file_in_the_current_directory
another_file    
my_shell_script
the_last_file

La plupart de ces fonctions ne fonctionnent que sous UNIX (Linux, Mac OS X), mais vous pouvez faire des choses similaires (bien que moins pratiques) sous Windows.

Answer 4

Il y a beaucoup de bons conseils ici, alors j'ai voulu en ajouter un tout petit peu.

1. Les backticks (ou back-ticks) vous permettent de réaliser des scripts beaucoup plus facilement. Envisagez

   puts `find . | grep -i lib`

2. Si vous rencontrez des problèmes pour obtenir la sortie des backticks, c'est qu'ils vont dans standard err au lieu de standard out. Utilisez ces conseils

   out = `git status 2>&1`

3. Les points en arrière font l'interpolation de la chaîne de caractères :

   blah = 'lib'
   `touch #{blah}`

4. Vous pouvez également utiliser des tuyaux à l'intérieur de Ruby . C'est un lien vers mon blog, mais il renvoie vers ici, donc c'est bon :) Il y a probablement des choses plus avancées sur ce sujet.

5. Comme d'autres l'ont fait remarquer, si vous voulez être sérieux, il y a Rush : pas seulement pour remplacer les coquillages (ce qui est un peu trop loufoque pour moi), mais aussi pour en tant que bibliothèque à utiliser dans les scripts et programmes shell.

---

Sur Mac, utilisez Applescript dans Ruby pour plus de puissance. Voici mon shell_here script :

#!/usr/bin/env ruby
`env | pbcopy` 
cmd =  %Q@tell app "Terminal" to do script "$(paste_env)"@
puts cmd

`osascript -e "${cmd}"`

Answer 5

Procurez-vous un exemplaire de Les scripts au quotidien avec Ruby . Il contient de nombreux conseils utiles sur la manière de faire les choses que vous souhaitez faire.