Ruby command line

Przemysław::Kowalczyk
a.k.a. szeryf

ruby -‍-help

Usage: ruby [switches] [--] [programfile] [arguments]
  -0[octal]       specify record separator (\0, if no argument)
  -a              autosplit mode with -n or -p (splits $_ into $F)
  -c              check syntax only
  -Cdirectory     cd to directory, before executing your script
  -d              set debugging flags (set $DEBUG to true)
  -e 'command'    one line of script. Several -e's allowed. Omit [programfile]
  -Eex[:in]       specify the default external and internal character encodings
  -Fpattern       split() pattern for autosplit (-a)
  -i[extension]   edit ARGV files in place (make backup if extension supplied)
  -Idirectory     specify $LOAD_PATH directory (may be used more than once)
  -l              enable line ending processing
  -n              assume 'while gets(); ... end' loop around your script
  -p              assume loop like -n but print line also like sed
  -rlibrary       require the library, before executing your script
  -s              enable some switch parsing for switches after script name
  -S              look for the script using PATH environment variable
  -T[level=1]     turn on tainting checks
  -v              print version number, then turn on verbose mode
  -w              turn warnings on for your script
  -W[level=2]     set warning level; 0=silence, 1=medium, 2=verbose
  -x[directory]   strip off text before #!ruby line and perhaps cd to directory
  --copyright     print the copyright
  --version       print the version

lots of cryptic options
...but some look familiar

Usage: perl [switches] [--] [programfile] [arguments]
  -0[octal]         specify record separator (\0, if no argument)
  -a                autosplit mode with -n or -p (splits $_ into @F)
  -C[number/list]   enables the listed Unicode features
  -c                check syntax only (runs BEGIN and CHECK blocks)
  -d[:debugger]     run program under debugger
  -D[number/list]   set debugging flags (argument is a bit mask or alphabets)
  -e program        one line of program (several -e's allowed, omit programfile)
  -E program        like -e, but enables all optional features
  -f                don't do $sitelib/sitecustomize.pl at startup
  -F/pattern/       split() pattern for -a switch (//'s are optional)
  -i[extension]     edit <> files in place (makes backup if extension supplied)
  -Idirectory       specify @INC/#include directory (several -I's allowed)
  -l[octal]         enable line ending processing, specifies line terminator
  -[mM][-]module    execute "use/no module..." before executing program
  -n                assume "while (<>) { ... }" loop around program
  -p                assume loop like -n but print line also, like sed
  -P                run program through C preprocessor before compilation
  -s                enable rudimentary parsing for switches after programfile
  -S                look for programfile using PATH environment variable
  -t                enable tainting warnings
  -T                enable tainting checks
  -u                dump core after parsing program
  -U                allow unsafe operations
  -v                print version, subversion (includes VERY IMPORTANT perl info)
  -V[:variable]     print configuration summary (or a single Config.pm variable)
  -w                enable many useful warnings (RECOMMENDED)
  -W                enable all warnings
  -x[directory]     strip off text before #!perl line and perhaps cd to directory
  -X                disable all warnings

Usage: perl [switches] [--] [programfile] [arguments]
  -0[octal]         specify record separator (\0, if no argument)
  -a                autosplit mode with -n or -p (splits $_ into @F)
  -C[number/list]   enables the listed Unicode features
  -c                check syntax only (runs BEGIN and CHECK blocks)
  -d[:debugger]     run program under debugger
  -D[number/list]   set debugging flags (argument is a bit mask or alphabets)
  -e program        one line of program (several -e's allowed, omit programfile)
  -E program        like -e, but enables all optional features
  -f                don't do $sitelib/sitecustomize.pl at startup
  -F/pattern/       split() pattern for -a switch (//'s are optional)
  -i[extension]     edit <> files in place (makes backup if extension supplied)
  -Idirectory       specify @INC/#include directory (several -I's allowed)
  -l[octal]         enable line ending processing, specifies line terminator
  -[mM][-]module    execute "use/no module..." before executing program
  -n                assume "while (<>) { ... }" loop around program
  -p                assume loop like -n but print line also, like sed
  -P                run program through C preprocessor before compilation
  -s                enable rudimentary parsing for switches after programfile
  -S                look for programfile using PATH environment variable
  -t                enable tainting warnings
  -T                enable tainting checks
  -u                dump core after parsing program
  -U                allow unsafe operations
  -v                print version, subversion (includes VERY IMPORTANT perl info)
  -V[:variable]     print configuration summary (or a single Config.pm variable)
  -w                enable many useful warnings (RECOMMENDED)
  -W                enable all warnings
  -x[directory]     strip off text before #!perl line and perhaps cd to directory
  -X                disable all warnings

Usage: ruby [switches] [--] [programfile] [arguments]
  -0[octal]       specify record separator (\0, if no argument)
  -a              autosplit mode with -n or -p (splits $_ into $F)
  -c              check syntax only
  -Cdirectory     cd to directory, before executing your script
  -d              set debugging flags (set $DEBUG to true)
  -e 'command'    one line of script. Several -e's allowed. Omit [programfile]
  -Eex[:in]       specify the default external and internal character encodings
  -Fpattern       split() pattern for autosplit (-a)
  -i[extension]   edit ARGV files in place (make backup if extension supplied)
  -Idirectory     specify $LOAD_PATH directory (may be used more than once)
  -l              enable line ending processing
  -n              assume 'while gets(); ... end' loop around your script
  -p              assume loop like -n but print line also like sed
  -rlibrary       require the library, before executing your script
  -s              enable some switch parsing for switches after script name
  -S              look for the script using PATH environment variable
  -T[level=1]     turn on tainting checks
  -v              print version number, then turn on verbose mode
  -w              turn warnings on for your script
  -W[level=2]     set warning level; 0=silence, 1=medium, 2=verbose
  -x[directory]   strip off text before #!ruby line and perhaps cd to directory
  --copyright     print the copyright
  --version       print the version

Is Ruby influenced by Perl?

I wanted a scripting language that was more powerful than Perl, and more object-oriented than Python. (...)

Ruby's class library is an object-oriented reorganization of Perl functionality--plus some Smalltalk and Lisp stuff.

Yukihiro Matsumoto a.k.a. "Matz"

http://www.flickr.com/photos/32513189@N03/6064652520

basic options

`ruby --version`
`ruby -v`

$ cat version.rb 
puts RUBY_VERSION

$ ruby version.rb 
1.9.3

$ ruby -‍-version
ruby 1.9.3p125 (2012-02-16 revision 34643) [x86_64-darwin10.8.0]

$ ruby -v
ruby 1.9.3p125 (2012-02-16 revision 34643) [x86_64-darwin10.8.0]

`ruby -c`
`ruby -w`

$ cat warnings.rb 
a = 1
3.times {|a| 
  puts (a)
}

$ ruby -c warnings.rb 
Syntax OK

$ ruby -cw warnings.rb 
warnings.rb:2: warning: shadowing outer local variable - a
warnings.rb:3: warning: (...) interpreted as grouped expression
Syntax OK

$ ruby -w warnings.rb 
warnings.rb:2: warning: shadowing outer local variable - a
warnings.rb:3: warning: (...) interpreted as grouped expression
0
1
2

TextMate's Ruby bundle runs
`ruby -cw`
on save

http://www.flickr.com/photos/kenb/1398914855

slightly advanced options

`ruby -e 'command'`
one line of script. Several -e's allowed. Omit [programfile]

$ ruby -e 'f=[0,1];15.times{f<<f[-1]+f[-2]};p f'
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]

`ruby -Idirectory`
specify $LOAD_PATH directory (may be used more than once)
`ruby -rlibrary`
require the library, before executing your script

$ ruby -I.:lib:test -rubygems -e \
  "%w[test/unit test/unit/project_test.rb].each { |f| require f }"
  
$ ruby -I.:lib:test -rubygems \
  -rtest/unit -rtest/unit/project_test.rb -e ''

Fun fact #1:
`require 'ubygems'` actually works!

http://www.flickr.com/photos/andrewdewolfe/865858309

moderately convoluted options

`ruby -s` enable some switch parsing for switches after script name (does not work with `-e`)

$ cat s-opt.rb 
#!ruby -s
p xyz: $xyz
p val: $val
p i_can_haz_hyphens: $i_can_haz_hyphens
p ARGV: ARGV

$ ruby ./s-opt.rb -xyz -val=123 -i-can-haz-hyphens
{:xyz=>true}
{:val=>"123"}
{:i_can_haz_hyphens=>true}
{:ARGV=>[]}

$ ruby ./s-opt.rb -xyz -‍- -val=123 -i-can-haz-hyphens
{:xyz=>true}
{:val=>nil}
{:i_can_haz_hyphens=>nil}
{:ARGV=>["-val=123", "-i-can-haz-hyphens"]}

Might be actually useful... `my-script.rb -verbose`

#!ruby -s

log "some message" if $verbose

`ruby -Cdirectory` cd to directory, before executing your script

$ ls
src/  lib/  doc/  ext/

$ for x in */ ; do ruby -C$x clean.rb ; done
src-cleaning /path/to/src/
lib-cleaning /path/to/lib/
doc-cleaning /path/to/doc/
ext-cleaning /path/to/ext/

$ for x in */ ; do ruby -C$x /path/to/clean.rb ; done
cleaning /path/to/src/
cleaning /path/to/lib/
cleaning /path/to/doc/
cleaning /path/to/ext/

http://www.flickr.com/photos/alykat/4895929410

higher driving school

`ruby -n` assume 'while gets(); ... end' loop around your script

$ ruby -ne 'print if $..even?' < s-opt.rb
p xyz: $xyz
p i_can_haz_hyphens: $i_can_haz_hyphens

$ ruby -ne 'print if /xyz/' s-opt.rb 
p xyz: $xyz

How does it work?

$ ruby -ne 'print if $..even?' s-opt.rb

becomes while gets print if $..even? end

which is equivalent to ARGF = ARGV.empty? ? STDIN : read_all_args_as_one_stream $. = 0 while $_ = gets(ARGF) $. += 1 print $_ if $..even? end

`ruby -p` assume loop like -n but print line also like sed

$ cat s-opt.rb 
#!ruby -s
p xyz: $xyz
p val: $val
p i_can_haz_hyphens: $i_can_haz_hyphens
p ARGV: ARGV

$ ruby -pe 'gsub(/(\w+):/) { ":#{$1} =>" }' s-opt.rb
#!ruby -s
p :xyz => $xyz
p :val => $val
p :i_can_haz_hyphens => $i_can_haz_hyphens
p :ARGV => ARGV

How does it work?

$ ruby -pe 'gsub(/(\w+):/) { ":#{$1} =>" }' s-opt.rb

becomes

while $_ = gets
  $_ = $_.gsub(/(\w+):/) { ":#{$1} =>" }
  print $_
end

* gsub(...){...} does not work with -n on Ruby MRI 1.9.3, works on 1.8.7

Ruby defines special versions of `chomp`, `chop`, `gsub`, `sub` in loop mode

More examples

$ ruby -pe puts file.txt

Inserts empty line before each line

$ ruby -pe '$\="\n"' file.txt

Inserts empty line after each line

$ ruby -pe 'gsub(/\s+$/, $/)' file.txt

Strip trailing whitespace from each line

$ ruby -pe 'exit if $. > 10' file.txt

Print first 10 lines of file.

Even more examples

$ ruby -ne 'print if /<body>/../<\/body>/' index.html 
  <body>
    <a href="refactoring-to-use-cases/uc.html">Refactoring to use-cases</a>
    <a href="ruby-command-line/ruby.html">Ruby command line</a>
  </body>

Print lines between line containing <body> and line containing </body>

$ ruby -pe '$_.tr!"a-zA-Z","n-za-mN-ZA-M"' s-opt.rb 
#!ehol -f
c klm: $klm
c iny: $iny
c v_pna_unm_ulcuraf: $v_pna_unm_ulcuraf
c NETI: NETI

ROT13 like a (Ruby) boss!

`ruby -l` enable line ending processing

$ ruby -pe '$_.reverse!' s-opt.rb 

s- ybur!#
zyx$ :zyx p
lav$ :lav p
snehpyh_zah_nac_i$ :snehpyh_zah_nac_i p
VGRA :VGRA p$
$ ruby -lpe '$_.reverse!' s-opt.rb 
s- ybur!#
zyx$ :zyx p
lav$ :lav p
snehpyh_zah_nac_i$ :snehpyh_zah_nac_i p
VGRA :VGRA p

source:wikipedia

ninjas only

`ruby -a` autosplit mode with -n or -p (splits $_ into $F)

$ ruby -nae 'puts $F[1] if $F[0]=="127.0.0.1"' /etc/hosts
localhost
local.dev
backend.dev
frontend.dev

`ruby -Fpattern` split() pattern for autosplit (-a)

$ ruby -naF: -e 'puts $F[0] if $F[4]=~/server/i' /etc/passwd 
_postfix
_pcastserver
_www
_cvs
_svn
_mysql

`BEGIN` & `END` blocks

$ ruby -nae 'BEGIN{c = w = 0}; c += $_.size; w += $F.size; \
END{ printf "%8d%8d%8d %s\n", $., w, c, $FILENAME }' s-opt.rb
       5      14      87 s-opt.rb
$ wc s-opt.rb
       5      14      87 s-opt.rb

More fun with `BEGIN` & `END`

$ cat example.csv 
First name;Last name;Email
Przemek;Kowalczyk;szeryf74@gmail.com
John;Doe;jdoe@example.com

$ ruby -F\; -nale 'BEGIN{puts "<table>"; t=:th}; 
puts " <tr>", $F.map{|c|"  <#{t}>#{c}</#{t}>"}, " </tr>"; 
t=:td; END{puts "</table>"}' example.csv 
<table>
 <tr>
  <th>First name</th>
  <th>Last name</th>
  <th>Email</th>
 </tr>
 <tr>
  <td>Przemek</td>
  <td>Kowalczyk</td>
  <td>szeryf74@gmail.com</td>
 </tr>
 <tr>
  <td>John</td>
  <td>Doe</td>
  <td>jdoe@example.com</td>
 </tr>
</table>

source:wikipedia

you've got to be kidding

`ruby -0[octal]` specify record separator (`\0`, if no argument)

$ find . -iname \*.rb -print0 | ruby -pl0e '$_.upcase!'
./CLEAN.RB
./S-OPT.RB
./VERSION.RB
./WARNINGS.RB

`ruby -0777` read whole file at once as a single string

$ ruby -n0777ae 'h=Hash.new(0); $F.each{|w|h[w.downcase]+=1};
puts h.to_a.sort_by(&:last).last(5)' file.txt 
się
52
jest
54
nie
58
to
63
w
85

`ruby -00` read file in paragraph mode

$ cat -> file.txt
This should all be on one line 
since it's one sentence.

This is a new paragraph that
should be separate.

$ ruby -l00pe 'gsub(/\s*\n/, " ")' file.txt 
This should all be on one line since it's one sentence. 
This is a new paragraph that should be separate.

$ ruby -00lpe 'gsub(/\s*\n/, " ")' file.txt 
This should all be on one line since it's one sentence. 

This is a new paragraph that should be separate.

Mastering `-l`-fu & `-0`jitsu

$/ is input record separator.
Default value is "\n". Set by -0 option.
$\ is output record separator.
Appended to Kernel.print output if non‐nil. Default value is nil.
-l means $\ = $/
-0 means $/ = "\0"
or whatever is the argument to -0
-l00 means $\ = $/; $/ = "\n\n"
-00l means $/ = "\n\n"; $\ = $/

`ruby -i[extension]` edit ARGV files in place (make backup if extension supplied)

$ ruby -i -pe 'gsub(/(\w+):/) { ":#{$1} =>" }' s-opt.rb

$ cat s-opt.rb 
#!ruby -s
p :xyz => $xyz
p :val => $val
p :i_can_haz_hyphens => $i_can_haz_hyphens
p :ARGV => ARGV

`ruby -i[extension]` edit ARGV files in place (make backup if extension supplied)

$ ruby -i.bak -pe 'gsub(/:(\w+) =>/) { "#{$1}:" }' s-opt.rb

$ cat s-opt.rb
#!ruby -s
p xyz: $xyz
p val: $val
p i_can_haz_hyphens: $i_can_haz_hyphens
p ARGV: ARGV

$ cat s-opt.rb.bak 
#!ruby -s
p :xyz => $xyz
p :val => $val
p :i_can_haz_hyphens => $i_can_haz_hyphens
p :ARGV => ARGV

source:wikipedia

Thank you!

Questions?

Where do I find...

This presentation
http://szeryf.github.com/ruby-command-line/ruby.html
My github account
http://github.com/szeryf
My almost defunct blog
http://szeryf.wordpress.com/

Ruby command line

Przemysław::Kowalczyk a.k.a. szeryf

ruby -‍-help

lots of cryptic options...but some look familiar

Is Ruby influenced by Perl?

basic options

ruby --version ruby -v

ruby -c ruby -w

TextMate's Ruby bundle runs ruby -cw on save

slightly advanced options

ruby -e 'command' one line of script. Several -e's allowed. Omit [programfile]

ruby -Idirectory specify $LOAD_PATH directory (may be used more than once) ruby -rlibrary require the library, before executing your script

Fun fact #1: require 'ubygems' actually works!

moderately convoluted options

ruby -s enable some switch parsing for switches after script name (does not work with -e)

Might be actually useful... my-script.rb -verbose

ruby -Cdirectory cd to directory, before executing your script

higher driving school

ruby -n assume 'while gets(); ... end' loop around your script

How does it work?

ruby -p assume loop like -n but print line also like sed

How does it work?

Ruby defines special versions of chomp, chop, gsub, sub in loop mode

More examples

Even more examples

ruby -l enable line ending processing

ninjas only

ruby -a autosplit mode with -n or -p (splits $_ into $F)

ruby -Fpattern split() pattern for autosplit (-a)

BEGIN & END blocks

More fun with BEGIN & END

you've got to be kidding

ruby -0[octal] specify record separator (\0, if no argument)

ruby -0777 read whole file at once as a single string

ruby -00 read file in paragraph mode

Mastering -l-fu & -0jitsu

$/ is input record separator.

$\ is output record separator.

-l means $\ = $/

-0 means $/ = "\0"

-l00 means $\ = $/; $/ = "\n\n"

-00l means $/ = "\n\n"; $\ = $/

ruby -i[extension] edit ARGV files in place (make backup if extension supplied)

ruby -i[extension] edit ARGV files in place (make backup if extension supplied)

Thank you! Questions?

Where do I find...

This presentation

My github account

My almost defunct blog

Przemysław::Kowalczyk
a.k.a. szeryf

lots of cryptic options
...but some look familiar

`ruby --version`
`ruby -v`

`ruby -c`
`ruby -w`

TextMate's Ruby bundle runs
`ruby -cw`
on save

`ruby -e 'command'`
one line of script. Several -e's allowed. Omit [programfile]

`ruby -Idirectory`
specify $LOAD_PATH directory (may be used more than once)
`ruby -rlibrary`
require the library, before executing your script

Fun fact #1:
`require 'ubygems'` actually works!

`ruby -s` enable some switch parsing for switches after script name (does not work with `-e`)

Might be actually useful... `my-script.rb -verbose`

`ruby -Cdirectory` cd to directory, before executing your script

`ruby -n` assume 'while gets(); ... end' loop around your script

`ruby -p` assume loop like -n but print line also like sed

Ruby defines special versions of `chomp`, `chop`, `gsub`, `sub` in loop mode

`ruby -l` enable line ending processing

`ruby -a` autosplit mode with -n or -p (splits $_ into $F)

`ruby -Fpattern` split() pattern for autosplit (-a)

`BEGIN` & `END` blocks

More fun with `BEGIN` & `END`

`ruby -0[octal]` specify record separator (`\0`, if no argument)

`ruby -0777` read whole file at once as a single string

`ruby -00` read file in paragraph mode

Mastering `-l`-fu & `-0`jitsu

`$/` is input record separator.

`$\` is output record separator.

`-l` means `$\ = $/`

`-0` means `$/ = "\0"`

`-l00` means `$\ = $/; $/ = "\n\n"`

`-00l` means `$/ = "\n\n"; $\ = $/`

`ruby -i[extension]` edit ARGV files in place (make backup if extension supplied)

`ruby -i[extension]` edit ARGV files in place (make backup if extension supplied)

Thank you!

Questions?