На чистом диске можно искать бесконечно.

(Томас Б. Стил младший)

Вычислительные машины хороши для вычислений. В этой тавтологии больше смысла, чем кажется на первый взгляд. Если бы программа только потребляла процессорное время да изредка обращалась к оперативной памяти, жизнь была бы куда проще.

Но от компьютера, занятого исключительно собой, мало толку. Рано или поздно придется получать информацию извне и отправлять ее во внешний мир, и вот тут-то жизнь перестает казаться медом.

Есть несколько факторов, затрудняющих ввод/вывод. Во-первых, ввод и вывод - совершенно разные вещи, но обычно мы мысленно объединяем их. Во-вторых, операции ввода/вывода столь же разнообразны, как и мир насекомых.

История знает такие устройства, как магнитные барабаны, перфоленты, магнитные ленты, перфокарты и телетайпы. Некоторые имели механические детали, другие были электромагнитными от начала и до конца. Одни позволяли только считывать информацию, другие — только записывать, а третьи умели делать и то и другое. Часть записывающих устройств позволяла стирать данные, другая — нет. Одни были принципиально последовательными, другие допускали произвольный доступ. На иных устройствах информация хранилась постоянно, другие были энергозависимыми. Некоторые требовали человеческого вмешательства, другие — нет. Есть устройства символьного и блочного ввода/вывода. На некоторых блочных устройствах можно хранить только блоки постоянной длины, другие допускают и переменную длину блока. Одни устройства надо периодически опрашивать, другие управляются прерываниями. Прерывания можно реализовать аппаратно, программно или смешанным образом. Есть буферизованный и небуферизованный ввод/вывод. Бывает ввод/вывод с отображением на память и канальный, а с появлением таких операционных систем, как UNIX, мы узнали об устройствах ввода/вывода, отображаемых на элементы файловой системы. Программировать ввод/вывод доводилось на машинном языке, на языке ассемблера и на языках высокого уровня. В некоторые языки механизм ввода/вывода жестко встроен, другие вообще не включают ввод/вывод в спецификацию языка. Приходилось выполнять ввод/вывод с помощью подходящего драйвера или уровня абстракции и без оного.

Возможно, все это показалось вам хаотичным нагромождением разнородных фактов; если так, вы абсолютно правы!.. Отчасти сложность проистекает из самой природы ввода/вывода, отчасти это результат компромиссов, принятых при проектировании, а отчасти следствие наследия прошлых лет, устоявшихся традиций и особенностей различных языков и операционных систем.

Ввод/вывод в Ruby сложен, потому что он сложен в принципе. Но мы старались описать его как можно понятнее и показать, где и когда стоит применять различные приемы.

В основе системы ввода/вывода в Ruby лежит класс

IO

File

File

Stat

stat

lstat

File::Stat

В модуле

FileTest

File

Наконец, методы ввода/вывода есть и в модуле

Kernel

Object

Поначалу может показаться, что это хаотическое хитросплетение перекрывающейся функциональности. Но в каждый момент времени вам необходима лишь небольшая часть всего каркаса.

На более высоком уровне Ruby предлагает механизмы, позволяющие сделать объекты устойчивыми. Метод

Marshal

PStore

На самом высоком уровне возможен интерфейс с системами управления базами данных, например MySQL или Oracle. Эта тема настолько сложна, что ей можно было бы посвятить одну или даже несколько книг. Мы ограничимся лишь кратким введением. В некоторых случаях будут даны ссылки на архивы в сети.

Под файлом мы обычно, хотя и не всегда, понимаем файл на диске. Концепция файла в Ruby, как и в других языках, — это полезная абстракция. Говоря «каталог», мы подразумеваем каталог или папку в смысле, принятом в UNIX и Windows.

Класс

File

IO

Dir

Метод класса

File.new

File

Необязательный второй параметр называется строкой указания режимам он говорит, как нужно открывать файл — для чтения, для записи и т.д. (Строка указания режима не имеет ничего общего с разрешениями.) По умолчанию предполагается режим

"r"

file1 = File.new("one")      # Открыть для чтения.

file2 = File.new("two", "w") # Открыть для записи.

Есть также разновидность метода new, принимающая три параметра. В этом случае второй параметр задает начальные разрешения для файла (обычно записывается в виде восьмеричной константы), а третий представляет собой набор флагов, объединенных союзом ИЛИ. Флаги обозначаются константами, например:

File::CREAT

File::RDONLY

file = File.new("three", 0755, File::CREAT|File::WRONLY)

В виде любезности по отношению к операционной системе и среде исполнения всегда закрывайте открытые вами файлы. Если файл был открыт для записи, то это не просто вежливость, а способ предотвратить потерю данных. Для закрытия файла предназначен метод

close

out = File.new("captains.log", "w")

# Обработка файла...

out.close

Имеется также метод

open

new

trans = File.open("transactions","w")

Но методу

open

File.open("somefile","w") do |file|

 file.puts "Строка 1"

 file.puts "Строка 2"

 file.puts "Третья и последняя строка"

end

# Теперь файл закрыт.

Это изящный способ обеспечить закрытие файла по завершении работы с ним. К тому же при такой записи весь код обработки файла сосредоточен в одном месте.

Чтобы открыть файл для чтения и записи, достаточно добавить знак плюс (

+

f1 = File.new("file1", "r+")

# Чтение/запись, от начала файла.

f2 = File.new("file2", "w+")

# Чтение/запись; усечь существующий файл или создать новый.

f3 = File.new("file3", "а+")

# Чтение/запись; перейти в конец существующего файла или создать новый.

Чтобы дописать данные в конец существующего файла, нужно задать строку указания режима

"а"

logfile = File.open("captains_log", "a")

# Добавить строку в конец и закрыть файл.

logfile.puts "Stardate 47824.1: Our show has been canceled."

logfile.close

Для чтения из файла в произвольном порядке, а не последовательно, можно воспользоваться методом

seek

File

IO

# myfile содержит строку: abcdefghi

file = File.new("myfile")

file.seek(5)

str = file.gets # "fghi"

Если все строки в файле имеют одинаковую длину, то можно перейти сразу в начало нужной строки:

# Предполагается, что все строки имеют длину 20.

# Строка N начинается с байта (N-1)*20

file = File.new("fixedlines")

file.seek(5*20) # Шестая строка!

Для выполнения относительного поиска воспользуйтесь вторым параметром. Константа

IO::SEEK_CUR

file = File.new("somefile")

file.seek(55)                # Позиция 55.

file.seek(-22, IO::SEEK_CUR) # Позиция 33.

file.seek(47, IO::SEEK_CUR)  # Позиция 80.

Можно также искать относительно конца файла, в таком случае смещение может быть только отрицательным:

file.seek(-20, IO::SEEK_END) # Двадцать байтов от конца файла.

Есть еще и третья константа

IO::SEEK_SET

Метод

tell

pos

file.seek(20)

pos1 = file.tell # 20

file.seek(50, IO::SEEK_CUR)

pos2 = file.pos  # 70

Метод

rewind

Для выполнения прямого доступа файл часто открывается в режиме обновления (для чтения и записи). Этот режим обозначается знаком

+

Когда-то давно программисты на языке С включали в строку указания режима символ

"b"

Исключение составляет семейство операционных систем Windows, в которых различие все еще имеет место. Основное отличие двоичных файлов от текстовых на этой платформе состоит в том, что в двоичном режиме конец строки не преобразуется в один символ перевода строки, а представляется в виде пары «возврат каретки — перевод строки». Еще одно важное отличие — интерпретация символа control-Z как конца файла в текстовом режиме:

# Создать файл (в двоичном режиме).

File.open("myfile","wb") {|f| f.syswrite("12345\0326789\r") }

#Обратите внимание на восьмеричное 032 (^Z).

# Читать как двоичный файл.

str = nil

File.open("myfile","rb") {|f| str = f.sysread(15) )

puts str.size # 11

# Читать как текстовый файл.

str = nil

File.open("myfile","r") {|f| str = f.sysread(15) }

puts str.size # 5

В следующем фрагменте показано, что на платформе Windows символ возврата каретки не преобразуется в двоичном режиме:

# Входной файл содержит всего одну строку: Строка 1.

file = File.open("data")

line = file.readline          # "Строка 1.\n"

puts "#{line.size} символов." # 10 символов,

file.close

file = File.open("data","rb")

line = file.readline          # "Строка 1.\r\n"

puts "#{line.size} символов." # 11 символов.

file.close

Отметим, что упомянутый в коде метод

binmode

file = File.open("data")

file.binmode

line = file.readline        # "Строка 1.\r\n"

puts {line.size} символов." # 11 символов.

file.close

При необходимости выполнить низкоуровневый ввод/вывод можете воспользоваться методами

sysread

syswrite

sysread

input = File.new("infile")

output = File.new("outfile")

instr = input.sysread(10);

bytes = output.syswrite("Это тест.")

Отметим, что метод

sysread

EOFError

SystemCallError

При работе с двоичными данными могут оказаться полезны метод

pack

Array

unpack

String

В тех операционных системах, которые поддерживают такую возможность, метод

flock

File

File::LOCK_EX

File::LOCK_NB

File::LOCK_SH

File::LOCK_UN

file = File.new("somefile")

file.flock(File::LOCK_EX) # Исключительная блокировка; никакой другой

                          # процесс не может обратиться к файлу.

file.flock(File::LOCK_UN) # Разблокировать.

file.flock(File::LOCK_SH) # Разделяемая блокировка (другие

                          # процессы могут сделать то же самое).

file.flock(File::LOCK_UN) # Разблокировать.

locked = file.flock(File::LOCK_EX | File::LOCK_NB)

# Пытаемся заблокировать файл, но не приостанавливаем программу, если

# не получилось; в таком случае переменная locked будет равна false.

Для семейства операционных систем Windows эта функция не реализована.

Вы уже знакомы с некоторыми методами ввода/вывода из модуля

Kernel

gets

puts

print

printf

p

inspect

Но есть и другие методы, которые следует упомянуть для полноты. Метод

putc

getc

Kernel

IO

String

putc(?\n) # Вывести символ новой строки.

putc("X") # Вывести букву X.

Интересный вопрос: куда направляется вывод, если эти методы вызываются без указания объекта? Начнем с того, что в среде исполнения Ruby определены три глобальные константы, соответствующие трем стандартным потокам ввода/вывода, к которым мы привыкли в UNIX. Это

STDIN

STDOUT

STDERR

IO

Имеется также глобальная переменная

$stdout

Kernel

STDOUT

$stdout

IO

diskfile = File.new("foofile","w")

puts "Привет..." # Выводится на stdout.

$stdout = diskfile

puts "Пока!"     # Выводится в файл "foofile".

diskfile.close

$stdout = STDOUT # Восстановление исходного значения.

puts "Это все."  # Выводится на stdout.

Помимо метода

gets

Kernel

readline

readlines

gets

EOFError

nil

IO.readlines

Откуда мы получаем ввод? Есть переменная

$stdin

STDIN

$stderr

STDERR

Еще имеется интересный глобальный объект

ARGF

File

# Прочитать все файлы, а затем вывести их.

puts ARGF.read

# А при таком способе более экономно расходуется память:

while ! ARGF.eof?

 puts ARGF.readline

end

# Пример: ruby cat.rb file1 file2 file3

При чтении из стандартного ввода (

stdin

Kernel

ARGF

# Прочитать строку из стандартного ввода.

str1 = STDIN.gets

# Прочитать строку из ARGF.

str2 = ARGF.gets

# А теперь снова из стандартного ввода.

str3 = STDIN.gets

В некоторых случаях Ruby осуществляет буферизацию самостоятельно. Рассмотрим следующий фрагмент:

print "Привет... "

sleep 10

print "Пока!\n"

Если запустить эту программу, то вы увидите, что сообщения «Привет» и «Пока» появляются одновременно, после завершения

sleep

Это можно исправить, вызвав метод

flush

$defout

Kernel

print "Привет... "

STDOUT.flush

sleep 10

print "Пока!\n"

Буферизацию можно отключить (или включить) методом

sync=

sync

buf_flag = $defout.sync # true

STDOUT.sync = false

buf_flag = STDOUT.sync  # false

Есть еще по крайней мере один низкий уровень буферизации, который не виден. Если метод

getc

ungetc

ch = mystream.getc # ?А

mystream.ungetc(?C)

ch = mystream.getc # ?C

Тут следует иметь в виду три вещи. Во-первых, только что упомянутая буферизация не имеет отношения к механизму буферизации, о котором мы говорили выше в этом разделе. Иными словами, предложение

sync=false

ungetc

ungetc

sysread

Вопрос о владении файлами и разрешениях сильно зависит от платформы. Как правило, в системе UNIX функций больше, чем предоставляет Ruby, а на других платформах многие возможности не реализованы.

Для определения владельца и группы файла (это целые числа) класс

File::Stat

uid

gid

data = File.stat("somefile")

owner_id = data.uid

group_id = data.gid

В классе

File::Stat

perms = File.stat("somefile").mode

В классе

File

chown

nil

uid = 201

gid = 10

File.chown(uid, gid, "alpha", "beta")

f1 = File.new("delta")

f1.chown(uid, gid)

f2 = File.new("gamma")

f2.chown(nil, gid) # Оставить идентификатор владельца без изменения.

Разрешения можно изменить с помощью метода

chmod

File.chmod(0644, "epsilon", "theta")

f = File.new("eta")

f.chmod(0444)

Процесс всегда работает от имени какого-то пользователя (возможно,

root

File::Stat

info = File.stat("/tmp/secrets")

rflag = info.readable?

wflag = info.writable?

xflag = info.executable?

Иногда нужно отличить действующий идентификатор пользователя от реального. На этот случай предлагаются методы экземпляра

readable_real?

writable_real?

executable_real?

info = File.stat("/tmp/secrets")

rflag2 = info.readable_real?

wflag2 = info.writable_real?

xflag2 = info.executable_real?

Можно сравнить владельца файла с действующим идентификатором пользователя (и идентификатором группы) текущего процесса. В классе

File::Stat

owned?

grpowned?

Отметим, что многие из этих методов можно найти также в модуле

FileTest

rflag = FileTest::readable?("pentagon_files")

# Прочие методы: writable? executable? readable_real?

# writable_real? executable_real? owned? grpowned?

# Отсутствуют здесь: uid gid mode.

Маска

umask

0777

umask

022

0755

Получить или установить маску можно с помощью метода

umask

File

File.umask(0237) # Установить umask.

current_umask = File.umask # 0237

Некоторые биты режима файла (например, бит фиксации — sticky bit) не имеют прямого отношения к разрешениям. Эта тема обсуждается в разделе 10.1.12.

С каждым файлом на диске связано несколько временных штампов (в разных операционных системах они различны). Ruby понимает три таких штампа: время модификации (когда в последний раз было изменено содержимое файла), время доступа (когда в последний раз файл читался) и время изменения (когда в последний раз была изменена информация о файле, хранящаяся в каталоге).

Получить эту информацию можно тремя разными способами, хотя все они дают один и тот же результат.

Методы

mtime

atime

ctime

File

File

t1 = File.mtime("somefile")

# Thu Jan 04 09:03:10 GMT-6:00 2001

t2 = File.atime("somefile")

# Tue Jan 09 10:03:34 GMT-6:00 2001

t3 = File.ctime("somefile")

# Sun Nov 26 23:48:32 GMT-6:00 2000

Если файл, представленный экземпляром

File

myfile = File.new("somefile")

t1 = myfile.mtime

t2 = myfile.atime

t3 = myfile.ctime

А если имеется экземпляр класса

File::Stat

myfile = File.new("somefile")

info = myfile.stat

t1 = info.mtime

t2 = info.atime

t3 = info.ctime

Отметим, что объект

File::Stat

stat

File

lstat

Для изменения времени доступа и модификации применяется метод

utime

Time

today = Time.now

yesterday = today - 86400

File.utime(today, today, "alpha")

File.utime(today, yesterday, "beta", "gamma")

Поскольку оба временных штампа изменяются одновременно, то при желании оставить один без изменения его сначала следует получить и сохранить.

mtime = File.mtime("delta")

File.utime(Time.now, mtime, "delta")

Часто необходимо знать, существует ли файл с данным именем. Это позволяет выяснить метод

exist?

FileTest

flag = FileTest::exist?("LochNessMonster")

flag = FileTest::exists?("UFO")

# exists? является синонимом exist?

Понятно, что такой метод не может быть методом экземпляра

File

File

exist?

С вопросом о том, существует ли файл, связан другой вопрос: а есть ли в нем какие-нибудь данные? Ведь файл может существовать, но иметь нулевую длину — а это практически равносильно тому, что он отсутствует.

Если нас интересует только, пуст ли файл, то в классе

File::Stat

zero?

true

false

flag = File.new("somefile").stat.zero?

Метод

size?

nil

true

nil

false

if File.new("myfile").stat.size?

 puts "В файле есть данные."

else

 puts "Файл пуст."

end

Методы

zero?

size?

FileTest

flag1 = FileTest::zero?("file1")

flag2 = FileTest::size?("file2")

Далее возникает следующий вопрос: «Каков размер файла?» Мы уже видели что для непустого файла метод

size?

nil

В классе

File

File::Stat

size1 = File.size("file1")

size2 = File.stat("file2").size

Чтобы получить размер файла в блоках, а не в байтах, можно обратиться к методу

blocks

File::Stat

blksize

info = File.stat("somefile")

total_bytes = info.blocks * info.blksize

У файла есть много свойств, которые можно опросить. Мы перечислим в этом разделе те встроенные методы, для которых не нашлось другого места. Почти все они являются предикатами.

Читая этот раздел (да и большую часть этой главы), помните о двух вещах. Во-первых, так как класс

File

FileTest

FileTest

File::Stat

stat

lstat

В некоторых операционных системах устройства подразделяются на блочные и символьные. Файл может ссылаться как на то, так и на другое, но не на оба сразу. Методы

blockdev?

chardev?

FileTest

flag1 = FileTest::chardev?("/dev/hdisk0")  # false

flag2 = FileTest::blockdev?("/dev/hdisk0") # true

Иногда нужно знать, ассоциирован ли данный поток с терминалом. Метод

tty?

IO

isatty

flag1 = STDIN.tty?                  # true

flag2 = File.new("diskfile").isatty # false

Поток может быть связан с каналом (pipe) или сокетом. В модуле

FileTest

flag1 = FileTest::pipe?(myfile)

flag2 = FileTest::socket?(myfile)

Напомним, что каталог — это разновидность файла. Поэтому нужно уметь отличать каталоги от обычных файлов, для чего предназначены два метода из модуля

FileTest

file1 = File.new("/tmp")

file2 = File.new("/tmp/myfile")

test1 = file1.directory? # true

test2 = file1.file?      # false

test3 = file2.directory? # false

test4 = file2.file?      # true

В классе

File

ftype

File::Stat

file

directory

blockSpecial

characterSpecial

fifo

link

socket

fifо

this_kind = File.ftype("/dev/hdisk0")   # "blockSpecial"

that_kind = File.new("/tmp").stat.ftype # "directory"

В маске, описывающей режим файла, можно устанавливать или сбрасывать некоторые биты. Они не имеют прямого отношения к битам, обсуждавшимся в разделе 10.1.9. Речь идет о битах set-group-id, set-user-id и бите фиксации (sticky bit). Для каждого из них есть метод в модуле

FileTest

file = File.new("somefile")

info = file.stat

sticky_flag = info.sticky?

setgid_flag = info.setgid?

setuid_flag = info.setuid?

К дисковому файлу могут вести символические или физические ссылки (в тех операционных системах, где такой механизм поддерживается). Чтобы проверить, является ли файл символической ссылкой на другой файл, обратитесь к методу

symlink?

FileTest

nlink

File::Stat

File.symlink("yourfile","myfile")          # Создать ссылку

is_sym = FileTest::symlink?("myfile")      # true

hard_count = File.new("myfile").stat.nlink # 0

Отметим попутно, что в предыдущем примере мы воспользовались методом класса

symlink

File

В редких случаях может понадобиться информация о файле еще более низкого уровня. В классе

File::Stat

dev

rdev

ino

file = File.new("diskfile")

info = file.stat

device = info.dev

devtype = info.rdev

inode = info.ino

Ruby поддерживает разные способы читать из канала и писать в него. Метод класса

IO.popen

check = IO.popen("spell","r+")

check.puts("'T was brillig, and the slithy toves")

check.puts("Did gyre and gimble in the wabe.")

check.close_write

list = check.readlines

list.collect! { |x| x.chomp }

# list равно %w[brillig gimble gyre slithy toves wabe]

Отметим, что вызов

close_write

File.popen("/usr/games/fortune") do |pipe|

quote = pipe.gets

puts quote

# На чистом диске можно искать бесконечно. - Том Стил.

end

Если задана строка

"-"

nil

IO

IO.popen("-")

do |mypipe|

 if mypipe

  puts "Я родитель: pid = #{Process.pid}"

  listen = mypipe.gets

  puts listen

 else

  puts "Я потомок: pid = #{Process.pid}"

 end

end

# Печатается:

# Я родитель: pid = 10580

# Я потомок: pid = 10582

Метод

pipe

pipe = IO.pipe

reader = pipe[0]

writer = pipe[1]

str = nil

thread1 = Thread.new(reader,writer) do |reader,writer|

 # writer.close_write

 str = reader.gets

 reader.close

end

thread2 = Thread.new(reader,writer) do |reader,writer|

 # reader.close_read

 writer.puts("What hath God wrought?")

 writer.close

end

thread1.join

thread2.join

puts str # What hath God wrought?

В Ruby можно выполнять низкоуровневые операции ввода/вывода. Мы только упомянем о существовании таких методов; если вы собираетесь ими пользоваться, имейте в виду, что некоторые машиннозависимы (различаются даже в разных версиях UNIX).

Метод

ioctl

Метод

fcntl

ioctl

Метод

select

Kernel

Метод

syscall

Kernel

Метод

fileno

desc = $stderr.fileno # 2

«За кулисами» Ruby предпринимает согласованные меры, чтобы операции ввода/вывода не блокировали выполнение программы. В большинстве случаев для управления вводом/выводом можно пользоваться потоками — один поток может выполнить блокирующую операцию, а второй будет продолжать работу.

Это немного противоречит интуиции. Потоки Ruby работают в том же процессе, они не являются платформенными потоками. Быть может, вам кажется, что блокирующая операция ввода/вывода должна приостанавливать весь процесс, а значит, и все его потоки. Это не так — Ruby аккуратно управляет вводом/выводом прозрачно для программиста.

Но если вы все же хотите включить неблокирующий режим ввода/вывода, такая возможность есть. Небольшая библиотека

io/nonblock

IO

require 'io/nonblock'

# ...

test = mysock.nonblock? # false

mysock.nonblock = true  # Отключить блокирующий режим.

# ...

mysock.nonblock = false # Снова включить его.

mysock.nonblock { some_operation(mysock) }

# Выполнить some_operation в неблокирующем режиме.

mysock.nonblock(false) { other_operation(mysock) }

# Выполнить other_operation в блокирующем режиме.

Метод

readpartial

Параметр «максимальная длина» (max length) обязателен. Если задан параметр buffer, то он должен ссылаться на строку, в которой будут храниться данные.

data = sock.readpartial(128) # Читать не более 128 байтов.

Метод

readpartial

Таким образом, если в потоке есть данные, то

readpartial

Если в потоке нет данных, но при этом достигнут конец файла, то

readpartial

EOFError

Если вызов блокирующий, то он ожидает, пока не произойдет одно из двух событий: придут новые данные или обнаружится конец файла. Если поступают данные, метод возвращает их вызывающей программе, а в случае обнаружения конца файла возбуждает исключение

EOFError

При вызове метода

sysread

readpartial

Основными методами для работы с путевыми именами являются методы класса

File.dirname

File.basename

basename

str = "/home/dave/podbay.rb"

dir = File.dirname(str)          # "/home/dave"

file1 = File.basename(str)       # "podbay.rb"

file2 = File.basename(str,".rb") # "podbay"

Хотя это методы класса

File

Упомянем также метод

File.split

info = File.split(str) # ["/home/dave","podbay.rb"]

Метод класса

expand_path

~

~user

Dir.chdir("/home/poole/personal/docs")

abs = File.expand_path("../../misc") # "/home/poole/misc"

Если передать методу

path

file = File.new("../../foobar")

name = file.path # "../../foobar"

Константа

File::Separator

File::SEPARATOR

Метод класса

join

path = File.join("usr","local","bin","someprog")

# path равно "usr/local/bin/someprog".

# Обратите внимание, что в начало имени разделитель не добавляется!

Не думайте, что методы

File.join

File.split

Следует знать о существовании стандартной библиотеки

pathname

Pathname

Dir

File

FileTest

FileUtils

path = Pathname.new("/home/hal")

file = Pathname.new("file.txt")

p2 = path + file

path.directory?     # true

path.file?          # false

p2.directory?       # false

p2.file?            # true

parts = path2.split # [Путевое имя:/home/hal, Путевое имя:file.txt]

ext = path2.extname # .txt

Как и следовало ожидать, имеется ряд вспомогательных методов. Метод

root?

parent?

children

p1 = Pathname.new("//") # Странно, но допустимо.

p1.root?                # true

р2 = Pathname.new("/home/poole")

p3 = p2.parent          # Путевое имя:/home

items = p2.children     # Массив объектов Pathname

                        # (все файлы и каталоги, являющиеся

                        # непосредственными потомками р2).

Как и следовало ожидать, методы

relative

absolute

p1 = Pathname.new("/home/dave")

p1.absolute? # true

p1.relative? # false

Многие методы, например

size

unlink

File

FileTest

FileUtils

Дополнительную информацию о классе

Pathname

Часто приходится манипулировать файлами так, как это делается с помощью командной строки: копировать, удалять, переименовывать и т.д.

Многие из этих операций реализованы встроенными методами, некоторые находятся в модуле

FileUtils

fileutils

FileUtils

File

Для удаления файла служит метод

File.delete

File.unlink

File.delete("history")

File.unlink("toast")

Переименовать файл позволяет метод

File.rename

File.rename("Ceylon","SriLanka")

Создать ссылку на файл (физическую или символическую) позволяют методы

File.link

File.symlink

File.link("/etc/hosts","/etc/hostfile") # Физическая ссылка.

File.symlink("/etc/hosts","/tmp/hosts") # Символическая ссылка.

Файл можно усечь до нулевой длины (или до любой другой), воспользовавшись методом экземпляра

truncate

File.truncate("myfile",1000) # Теперь не более 1000 байтов.

Два файла можно сравнить с помощью метода

compare_file

cmp

compare_stream

require "fileutils"

same = FileUtils.compare_file("alpha","beta") # true

Метод

copy

cp

require "fileutils"

# Скопировать файл epsilon в theta с протоколированием ошибок.

FileUtils.сору("epsilon","theta", true)

Файл можно перемещать методом

move

mv

сору

require "fileutils"

FileUtils.move( "/trap/names", "/etc") # Переместить в другой каталог.

FileUtils.move("colours","colors")     # Просто переименовать.

Метод

safe_unlink

true

false

require "fileutils"

FileUtils.safe_unlink("alpha","beta","gamma")

# Протоколировать ошибки при удалении следующих двух файлов:

FileUtils.safe_unlink("delta","epsilon",true)

Наконец, метод

install

syscopy

require "fileutils"

FileUtils.install("foo.so","/usr/lib")

# Существующий файл foo.so не будет переписан,

# если он не отличается от нового.

Дополнительную информацию о модуле

FileUtils

В данном случае мы имеем в виду небуферизованный ввод, когда символ обрабатывается сразу после нажатия клавиши, не дожидаясь, пока будет введена вся строка.

Это можно сделать и в UNIX, и в Windows, но, к сожалению, совершенно по-разному.

Версия для UNIX прямолинейна. Мы переводим терминал в режим прямого ввода (raw mode) и обычно одновременно отключаем эхо-контроль.

def getchar

 system("stty raw -echo") # Прямой ввод без эхо-контроля.

 char = STDIN.getc

 system("stty -raw echo") # Восстановить режим терминала.

 char

end

На платформе Windows придется написать расширение на С. Пока что альтернативой является использование одной из функций в библиотеке

Win32API

require 'Win32API'

def getchar

 char = Win32API.new("crtdll", "_getch", [], 'L').Call

end

Поведение в обоих случаях идентично.

Чтобы прочитать весь файл в массив, не нужно даже его предварительно открывать. Все сделает метод

IO.readlines

arr = IO.readlines("myfile")

lines = arr.size

puts "myfile содержит #{lines} строк."

longest = arr.collect {|x| x.length}.max

puts "Самая длинная строка содержит #{longest} символов."

Можно также воспользоваться методом

IO.read

str = IO.read("myfile")

bytes = arr.size

puts "myfile содержит #{bytes} байтов."

longest=str.collect {|x| x.length}.max # строки - перечисляемые объекты!

puts "Самая длинная строка содержит #{longest} символов."

Поскольку класс

IO

File

File.deadlines

File.read

Чтобы читать по одной строке из файла, можно обратиться к методу класса

IO.foreach

each

# Напечатать все строки, содержащие слово "target".

IO.foreach("somefile") do |line|

 puts line if line =~ /target/

end

# Другой способ...

file = File.new("somefile")

file.each do |line|

 puts line if line =~ /target/

end

Отметим, что

each_line

each

Для чтения из файла по одному байту служит метод экземпляра

each_byte

chr

file = File.new("myfile")

e_count = 0

file.each_byte do |byte|

 e_count += 1 if byte == ?e

end

Иногда возникает необходимость рассматривать строку как файл. Что под этим понимается, зависит от конкретной задачи.

Объект определяется прежде всего своими методами. В следующем фрагменте показано, как к объекту

source

source

source.each do |line|

 puts line

end

Это могли бы быть как файл, так и строка, содержащая внутри символы новой строки. В таких случаях строку можно трактовать как файл без всякого труда.

В последних версиях Ruby имеется также библиотека

stringio

Интерфейс класса

StringIO

string

require 'stringio'

ios = StringIO.new("abcdefghijkl\nABC\n123")

ios.seek(5)

ios.puts("xyz")

puts ios.tell        # 8

puts ios.string.dump # "abcdexyzijkl\nABC\n123"

с = ios.getc

puts "с = #{c}"      # с = 105

ios.ungetc(?w)

puts ios.string.dump # "abcdexyzwjkl\nABC\n123"

puts "Ptr = #{ios.tell}"

s1 = ios.gets        # "wjkl"

s2 = ios.gets        # "ABC"

Когда подростком вы учили язык BASIC, копируя программы из журналов, то, наверное, для удобства часто пользовались предложением

DATA

При желании то же самое можно сделать и в Ruby. Директива

__END__

DATA

IO

__END__

# Распечатать все строки "задом наперед"...

DATA.each_line do |line|

 puts line.reverse

end

__END__

A man, a plan, a canal... Panama!

Madam, I'm Adam.

,siht daer nac uoy fI

.drah oot gnikrow neeb ev'uoy

Если вы хотите получить доступ к исходному тексту собственной программы, то можете воспользоваться уже описанным выше трюком (см. раздел 10.1.25).

Глобальная константа

DATA

IO

__END__

rewind

Следующая программа выводит собственный текст, снабжая его номерами строк. Это не очень полезно, но, быть может, вы найдете и другие применения такой техники.

DATA.rewind

num = 1

DATA.each_line do |line|

 puts "#{'%03d' % num} #{line}"

 num += 1

end

__END__

Отметим, что наличие директивы

__END__

DATA

Во многих случаях необходимо работать с файлами, которые по сути своей анонимны. Мы не хотим возиться с присваиванием им имен и проверять, что при этом не возникает конфликтов с существующими файлами. И помнить о том, что такие файлы нужно удалять, тоже не хочется.

Все эти проблемы решает библиотека

Tempfile

new

open

tmpdir

tmp

temp

"/tmp"

Возвращаемый объект

IO

У метода

close

true

path

require "tempfile"

temp = Tempfile.new("stuff")

name = temp.path # "/tmp/stuff17060.0"

temp.puts "Здесь был Вася"

temp.close

# Позже...

temp.open

str = temp.gets  # "Здесь был Вася"

temp.close(true) # Удалить СЕЙЧАС.

Получить имя текущего каталога можно с помощью метода

Dir.pwd

Dir.getwd

Для изменения текущего каталога служит метод

Dir.chdir

Dir.chdir("/var/tmp")

puts Dir.pwd   # "/var/tmp"

puts Dir.getwd # "/var/tmp"

Этот метод также принимает блок в качестве параметра. Если блок задан, то текущий каталог изменяется только на время выполнения блока, а потом восстанавливается первоначальное значение:

Dir.chdir("/home")

Dir.chdir("/tmp") do

 puts Dir.pwd # /tmp

 # Какой-то код...

end

puts Dir.pwd  # /home

В большинстве систем UNIX можно изменить «представление» процесса о том, что такое корневой каталог

/

chroot

Dir.chdir("/home/guy/sandbox/tmp")

Dir.chroot("/home/guy/sandbox")

puts Dir.pwd # "/tmp"

Метод класса

foreach

each

Dir.foreach("/tmp") { |entry| puts entry }

dir = Dir.new("/tmp")

dir.each { |entry| puts entry }

Оба фрагмента печатают одно и то же (имена всех файлов и подкаталогов в каталоге /tmp).

Метод класса

Dir.entries

list = Dir.entries("/tmp") # %w[. .. alpha.txt beta.doc]

Как видите, включаются и элементы, соответствующие текущему и родительскому каталогу. Если они вам не нужны, придется отфильтровать их вручную.

Иногда необходимо создать глубоко вложенный каталог, причем промежуточные каталоги могут и не существовать. В UNIX мы воспользовались бы для этого командой

mkdir -p

В программе на Ruby такую операцию выполняет метод

FileUtils.makedirs

fileutils

require "fileutils"

FileUtils.makedirs("/tmp/these/dirs/need/not/exist")

В UNIX команда

rm -rf dir

dir

В последних версиях Ruby в класс

Pathname

rmtree

FileUtils

rm_r

require 'pathname'

dir = Pathname.new("/home/poole/")

dir.rmtree

# или:

require 'fileutils'

FileUtils.rm_r("/home/poole")

Ниже мы воспользовались стандартной библиотекой

find.rb

require "find"

def findfiles(dir, name)

 list = []

 Find.find(dir) do |path|

  Find.prune if [".",".."].include? Path

  case name

   when String

    list << path if File.basename(path) == name

   when Regexp

    list << path if File.basename(path) =~ name

   else

    raise ArgumentError

  end

 end

 list

end

findfiles "/home/hal", "toc.txt"

# ["/home/hal/docs/toc.txt", "/home/hal/misc/toc.txt"]

findfiles "/home", /^[a-z]+.doc/

# ["/home/hal/docs/alpha.doc", "/home/guy/guide.doc",

# "/home/bill/help/readme.doc"]

Часто возникает необходимость хранить и извлекать данные более прозрачным способом. Модуль

Marshal

PStore

dbm

Часто бывает необходимо создать объект и сохранить его для последующего использования. В Ruby есть рудиментарная поддержка для обеспечения устойчивости объекта или маршалинга. Модуль

Marshal

# Массив элементов [composer, work, minutes]

works = [["Leonard Bernstein","Overture to Candide",11],

["Aaron Copland","Symphony No. 3",45],

["Jean Sibelius","Finlandia",20]]

# Мы хотим сохранить его для последующего использования...

File.open("store","w") do |file|

 Marshal.dump(works,file)

end

# Намного позже...

File.open("store") do |file|

 works = Marshal.load(file)

end

Недостаток такого подхода заключается в том, что не все объекты можно сохранить. Для объектов, включающих другие объекты низкого уровня, маршалинг невозможен. К числу таких низкоуровневых объектов относятся, в частности,

IO

Proc

Binding

Метод

Marshal.dump

s = Marshal.dump(works)

p s[0] # 4

p s[1] # 8

Обычно попытка загрузить такие данные оказывается успешной только в случае, если номера старших версий совпадают и номер младшей версии данных не больше младшей версии метода. Но если при вызове интерпретатора Ruby задан флаг «болтливости» (

verbose

v

Третий параметр

limit

Marshal.dump

ArgumentError

File.open("store","w") do |file|

 arr = []

 Marshal.dump(arr,file,0) # Внутри 'dump': превышена пороговая глубина.

                          # (ArgumentError)

 Marshal.dump(arr,file,1)

 arr = [1, 2, 3]

 Marshal.dump(arr,file,1) # Внутри 'dump': превышена пороговая глубина.

                          # (ArgumentError)

 Marshal.dump(arr,file,2) arr = [1, [2], 3]

 Marshal.dump(arr,file,2) # Внутри 'dump': превышена пороговая глубина.

                          # (ArgumentError)

 Marshal.dump(arr,file,3)

end

File.open("store") do |file|

 p Marshal.load(file) # [ ]

 p Marshal.load(file) # [1, 2, 3]

 p Marshal.load(file) # arr = [1, [2], 3]

end

По умолчанию третий параметр равен 1. Отрицательное значение означает, что глубина вложенности не проверяется.

Иногда мы хотим настроить маршалинг под свои нужды. Такую возможность дают методы

_load

_dump

В следующем примере человек получает 5-процентный доход на начальный капитал с момента рождения. Мы не храним ни возраст, ни текущий баланс, поскольку они являются функциями времени.

class Person

 attr_reader :name

 attr_reader :age

 attr_reader :balance

 def initialize(name,birthdate,beginning)

  @name = name

  @birthdate = birthdate

  @beginning = beginning

  @age = (Time.now - @birthdate)/(365*86400)

  @balance = @beginning*(1.05**@age)

 end

 def marshal_dump

  Struct.new("Human",:name,:birthdate,:beginning)

  str = Struct::Human.new(@name, @birthdate, @beginning)

  str

 end

 def marshal_load(str)

  self.instance_eval do

   initialize(str.name, str.birthdate, str.beginning)

  end

 end

 # Прочие методы...

end

p1 = Person.new("Rudy",Time.now - (14 * 365 * 86400), 100)

p [p1.name, p1.age, p1.balance] # ["Rudy", 14.0, 197.99315994394]

str = Marshal.dump(p1)

p2 = Marshal.load(str)

p [p2.name, p2.age, p2.balance] # ["Rudy", 14.0, 197.99315994394]

При сохранении объекта этого типа атрибуты

age

balance

marshal_load

initialize

new

В Ruby нет операции «глубокого копирования». Методы

dup

clone

Ниже предлагается способ реализовать глубокое копирование с некоторыми ограничениями, обусловленными тем, что наш подход основан на использовании класса

Marshal

def deep_copy(obj)

 Marshal.load(Marshal.dump(obj))

end

a = deep_copy(b)

Библиотека

PStore

PStore

require "pstore"

# Сохранить.

db = PStore.new("employee.dat") db.transaction do

 db["params"] = {"name" => "Fred", "age" => 32,

                 "salary" => 48000 }

end

# Восстановить.

require "pstore"

db = Pstore.new("employee.dat")

emp = nil

db.transaction { emp = db["params"] }

Обычно внутри блока транзакции используется переданный ему объект

PStore

Эта техника ориентирована на транзакции; в начале блока обрабатываемые данные читаются с диска. А в конце прозрачно для программиста записываются на диск.

Мы можем завершить транзакцию досрочно, вызвав метод

commit

abort

require "pstore"

# Предполагается, что существует файл с двумя объектами.

store = PStore.new("objects")

store.transaction do |s|

 a = s["my_array"] h = s["my_hash"]

 # Опущен воображаемый код, манипулирующий объектами

 # a, h и т. д.

 # Предполагается, что переменная "condition" может

 # принимать значения 1, 2, 3...

 case condition

  when 1

   puts "Отмена."

   s.abort # Изменения будут потеряны.

  when 2

   puts "Фиксируем и выходим."

   s.commit # Изменения будут сохранены.

  when 3

   # Ничего не делаем...

 end

 puts "Транзакция дошла до конца."

 # Изменения будут сохранены.

end

Внутри транзакции можно вызвать метод

roots

root?

delete

store.transaction do |s|

 list = s.roots  # ["my_array","my_hash"]

 if s.root?("my_tree")

  puts "Найдено my_tree."

 else

  puts "He найдено # my_tree."

 end

 s.delete("my_hash")

 list2 = s.roots # ["my_array"]

end

CSV (comma-separated values — значения, разделенные запятыми) — это формат, с которым вам доводилось сталкиваться, если вы работали с электронными таблицами или базами данных. К счастью, Хироси Накамура (Hiroshi Nakamura) написал для Ruby соответствующий модуль и поместил его в архив приложений Ruby.

Имеется также библиотека FasterCSV, которую создал Джеймс Эдвард Грей III (James Edward Gray III). Как явствует из названия, она работает быстрее, к тому же имеет несколько видоизмененный и улучшенный интерфейс (хотя для пользователей старой библиотеки есть «режим совместимости»). Во время работы над книгой велись дискуссии о том, следует ли сделать библиотеку FasterCSV стандартной, заменив старую библиотеку (при этом ей, вероятно, будет присвоено старое имя).

Ясно, что это не настоящая база данных. Но более подходящего места, чем эта глава, для нее не нашлось.

Модуль CSV (

csv.rb

• разделитель записей: CR + LF;

• разделитель полей: запятая (,);

• данные, содержащие символы CR, LF или запятую, заключаются в двойные кавычки;

• двойной кавычке внутри двойных кавычек должен предшествовать еще один символ двойной кавычки ("→"");

• пустое поле в кавычках обозначает пустую строку (данные,"",данные);

• пустое поле без кавычек означает NULL (данные,,данные).

В настоящем разделе мы рассмотрим лишь часть функциональных возможностей библиотеки. Этого достаточно для введения в предмет, а самую актуальную документацию, как всегда, можно найти в сети (начните с сайта ruby-doc.org).

Начнем с создания файла. Чтобы вывести данные, разделенные запятыми, мы просто открываем файл для записи; метод open передает объект-писатель в блок. Затем с помощью оператора добавления мы добавляем массивы данных (при записи они преобразуются в формат CSV). Первая строка является заголовком.

require 'csv'

CSV.open("data.csv","w") do |wr|

 wr << ["name", "age", "salary"]

 wr << ["mark", "29", "34500"]

 wr << ["joe", "42", "32000"]

 wr << ["fred", "22", "22000"]

 wr << ["jake", "25", "24000"]

 wr << ["don", "32", "52000"]

end

В результате исполнения этого кода мы получаем такой файл

data.csv

"name","age","salary"

"mark",29,34500

"joe",42,32000

"fred",22,22000

"jake",25,24000

"don",32,52000

Другая программа может прочитать этот файл:

require 'csv'

CSV.open('data.csv', ' r') do |row|

 p row

end

# Выводится:

# ["name", "age", "salary"]

# ["mark", "29", "34500"]

# ["joe", "42", "32000"]

# ["fred", "22", "22000"]

# ["jake", "25", "24000"]

# ["don", "32", "52000"]

Этот фрагмент можно было бы записать и без блока, тогда метод

open

shift

В библиотеке есть и более развитые средства, а также вспомогательные методы. Для получения дополнительной информации обратитесь к сайту ruby-doc.org или архиву приложений Ruby.

Аббревиатура YAML означает «YAML Ain't Markup Language» (YAML — не язык разметки). Это не что иное, как гибкий, понятный человеку формат хранения данных. Он напоминает XML, но «красивее».

Затребовав директивой

require

yaml

to_yaml

require 'yaml'

str = "Hello, world"

num = 237

arr = %w[ Jan Feb Mar Apr ]

hsh = {"This" => "is", "just a"=>"hash."}

puts str.to_yaml

puts num.to_yaml

puts arr.to_yaml

puts hsh.to_yaml

# Выводится:

# --- "Hello, world"

# --- 237

# ---

# - Jan

# - Feb

# - Mar

# - Apr

# ---

# just a: hash.

# This: is

Обратным по отношению к

to_yaml

YAML.load

Предположим, что имеется такой файл

data.yaml

---

- "Hello, world"

- 237

-

  - Jan

  - Feb

  - Mar

  - Apr

-

 just a: hash.

 This: is

Это те же четыре элемента данных, которые мы видели раньше, только они сгруппированы в единый массив. Если загрузить этот поток, то получим массив-

require 'yaml'

file = File.new("data.yaml")

array = YAML.load(file)

file.close

p array

# Выводится:

# ["Hello, world", 237, ["Jan", "Feb", "Mar", "Apr"],

# {"just a"=>"hash.", "This"=>"is"} ]

В общем и целом YAML — еще один способ выполнить маршалинг объектов. На верхнем уровне его можно использовать для самых разных целей. Например, человек может не только читать данные в этом формате, но и редактировать их, поэтому его естественно применять для записи конфигурационных файлов и т.п.

YAML позволяет и многое другое, о чем мы не можем здесь рассказать. Дополнительную информацию вы найдете на сайте ruby-doc.org или в справочном руководстве.

В некоторых кругах популярна идея преобладающих объектов (object prevalence). Смысл ее в том, что память дешева и продолжает дешеветь, а базы данных в большинстве своем невелики, поэтому о них можно вообще забыть и хранить все объекты в памяти.

Классической реализацией является пакет Prevayler, написанный на языке Java. Версия для Ruby называется Madeleine.

Madeleine годится не для всех приложений. У методики преобладающих объектов есть собственные правила и ограничения. Все объекты должны, во-первых, помещаться в памяти; во-вторых, быть сериализуемы.

Объекты должны быть детерминированы, то есть вести себя одним и тем же образом при получении одних и тех же данных. (Следовательно, применение системного таймера или случайных чисел оказывается под вопросом.)

Объекты должны быть по возможности изолированы от ввода/вывода (файлов и сети). Обычно весь ввод/вывод выполняется вне системы преобладающих объектов.

Наконец, любая команда, которая изменяет состояние системы преобладающих объектов, должна иметь вид объекта-команды (то есть для таких объектов тоже должна иметься возможность сериализации и сохранения).

Madeleine предлагает два основных метода доступа к системе объектов. Метод

execute_query

execute_command

Оба метода принимают в качестве параметра объект

Command

execute

Работа системы состоит в том, что во время исполнения приложения она периодически делает моментальные снимки всей системы объектов. Команды сериализуются наравне с другими объектами. В настоящее время не существует способа «откатить» набор транзакций.

Трудно привести содержательный пример использования этой библиотеки. Если вы знакомы с Java-версией, рекомендую изучить API для Ruby и освоить ее таким образом. Хороших руководств нет — может быть, вы напишете первое.

DBM

dbm

Для использования этого класса нужно создать объект DBM, указав для него имя файла, а дальше работать с ним, как с обычным хэшем. По завершении работы файл следует закрыть.

require 'dbm'

d = DBM.new("data")

d["123"] = "toodle-oo!"

puts d["123"] # "toodle-oo!"

d.close

puts d["123"] # RuntimeError: закрытый DBM-файл.

e = DBM.open("data")

e["123"]      # "toodle-oo!"

w=e.to_hash   # {"123"=>"toodle-oo!"}

e.close

e["123"]      # RuntimeError: закрытый DBM-файл.

w["123"]      # "toodle-oo!

Интерфейс к DBM реализован в виде одного класса, к которому подмешан модуль

Enumerable

new

open

q=DBM.new("data.dbm")  #

f=DBM.open("data.dbm") # Errno::EWOULDBLOCK:

                       #  Try again - "data.dbm"

Всего есть 34 метода экземпляра, многие из которых являются синонимами или аналогичны методам хэша. Почти все операции с настоящим хэшем применимы и к объекту

dbm

Метод

to_hash

close

rehash

sort

default

default=

to_s

KirbyBase — небольшая библиотека, с которой должен освоиться каждый программист на Ruby. В настоящее время она не входит в стандартный дистрибутив, а если бы входила, то была бы еще полезнее.

KirbyBase — плод трудов Джейми Криббса (Jamey Cribbs), названный, к слову, в честь его собаки. Во многих отношениях это полноценная база данных, но есть причины, по которым мы рассматриваем ее здесь, а не вместе с MySQL и Oracle.

Во-первых, это не автономное приложение. Это библиотека для Ruby, и без Ruby ее использовать нельзя. Во-вторых, она вообще не знает, что такое язык SQL. Если вам без SQL не обойтись, то эта библиотека не для вас. В-третьих, если приложение достаточно сложное, то функциональных возможностей и быстродействия KirbyBase может не хватить.

Но несмотря на все это, есть немало причин любить KirbyBase. Это написанная целиком на Ruby библиотека, состоящая из единственного файла, которую не нужно ни устанавливать, ни конфигурировать. Она работает на всех платформах, и созданные с ее помощью файлы можно переносить с одной платформы на другую. Это «настоящая» база данных в том смысле, что данные не загружаются целиком в память.

Библиотекой легко пользоваться, а ее интерфейс выдержан в духе Ruby с легким налетом DBI. В общем, база данных соответствует каталогу, а каждая таблица — одному файлу. Формат данных в таблицах таков, что человек может их читать (и редактировать). Дополнительно таблицы можно зашифровать — но только для того, чтобы затруднить редактирование. База знает об объектах Ruby; допускается их хранение и извлечение без потери информации.

Наконец, благодаря интерфейсу dRuby библиотека может работать в распределенном режиме. К данным, хранящимся в KirbyBase, можно с одинаковым успехом обращаться как с локальной, так и с удаленной машины.

Чтобы открыть базу данных, нужно сначала указать, является ли она локальной. Следующие два параметра обычно равны

nil

Чтобы создать таблицу, вызывается метод

create_table

Symbol

require 'kirbybase'

db = KirbyBase.new(:local, nil, nil, "mydata")

books = db.create_table(:books, # Имя таблицы.

         :title, :String,       # Поле, тип, ...

         :author, :String)

В текущей версии KirbyBase распознает следующие типы полей:

String

Integer

Float

Boolean

Time

Date

DateTime

Memo

Blob

YAML

Для вставки записи в таблицу применяется метод

insert

books.insert("The Case for Mars","Robert Zubrin")

books.insert(:title => "Democracy in America",

             :author => "Alexis de Tocqueville")

Book = Struct.new(:title, :author)

book = Book.new("The Ruby Way","Hal Fulton")

books.insert(book)

В любом случае метод

insert

select

find_all

list1 = people.select             # Все люди, все поля.

list2 = people.select(:name,:age) # Все люди, только имя и возраст.

list3 = people.select(:name) {|x| x.age >= 18 && x.age < 30 }

# Имена всех людей от 18 до 30 лет.

В блоке допустимы любые операции. Это означает, например, что можно формулировать запрос с помощью регулярных выражений (в отличие от типичной SQL-базы).

Результирующий набор, возвращаемый KirbyBase, можно сортировать по нескольким ключам в порядке возрастания или убывания. Для сортировки по убыванию перед именем ключа ставится минус. (Это работает, потому что в класс

Symbol

sorted = people.select.sort(:name,-:age)

# Отсортировать в порядке возрастания name и в порядке убывания age.

У результирующего набора есть одно интересное свойство: он может предоставлять массивы, «срезающие» результат. С первого раза это довольно трудно понять.

Предположим, что есть результирующий набор записей, представляющих людей, и в каждой записи хранятся имя, возраст, рост и вес. Понятно, что этот результирующий набор можно индексировать как массив, но одновременно он имеет методы, названные так же, как поля. Каждый такой метод возвращает массив значений только соответствующего ему поля. Например:

list = people.select(:name,:age,:heightweight)

p list[0]         # Вся информация о человеке 0.

p list[1].age     # Только возраст человека 1.

p list[2].height  # Рост человека 2.

ages = list.age   # Массив: возрасты всех людей.

names = list.name # Массив: имена всех людей.

В KirbyBase есть ограниченные средства печати отчетов; достаточно вызвать метод

to_report

rpt = books.select.sort(:title).to_report

puts rpt

# Выводится:

# recno | title                | author

# -----------------------------------------------------------

#     2 | Democracy in America | Alexis de Tocqueville

#     1 | The Case for Mars    | Robert Zubrin

#     3 | The Ruby Way         | Hal Fulton

Атрибут таблицы

encrypt

true

db.create_table(:mytable, f1, :String, f2, :Date) {|t| t.encrypt = true }

Поскольку удаленный доступ — интересное средство, уделим ему немного внимания. Вот пример сервера:

require 'kirbybase'

require 'drb'

host = 'localhost'

port = 44444

db = KirbyBase.new(:server) # Создать экземпляр базы данных.

DRb.start_service("druby://#{host} :#{port)", db)

DRb.thread.join

Это прямое применение интерфейса dRuby (см. главу 20). На стороне клиента следует при подключении к базе данных задать символ

:client

:local

db = KirbyBase.new(:client,'localhost',44444)

# Весь остальной код не изменяется.

Можно также выполнять обычные операции: обновлять и удалять записи, удалять таблицы и т.д. Есть и более сложные механизмы, о которых я не буду рассказывать подробно: связи один-ко-многим, вычисляемые поля и нестандартные классы записей. Подробнее см. документацию по KirbyBase на сайте RubyForge.

Благодаря усилиям многих людей Ruby может взаимодействовать с разными базами данных, от монолитных систем типа Oracle до более скромного MySQL. Для полноты описания мы включили в него также текстовые файлы в формате CSV.

Уровень функциональности, реализованный в этих пакетах, постоянно изменяется. Обязательно познакомьтесь с последней версией документации в сети. Неплохой отправной точкой станет архив приложений Ruby.

SQLite — популярная база данных для тех, кто ценит программное обеспечение, которое не нужно конфигурировать. Это небольшая автономная исполняемая программа, написанная на языке С, которая хранит всю базу данных в одном файле. Хотя обычно она используется для небольших баз, но теоретически способна управиться с терабайтными объемами.

Привязка Ruby к SQLite довольно прямолинейна. API, написанный на С, обернут в класс

SQLite::API

В большинстве ситуаций вам будет достаточно класса

SQLite::Database

require 'sqlite'

db = SQLite::Database.new("library.db")

db.execute("select title,author from books") do |row|

 p row

end

db.close

# Выводится:

# ["The Case for Mars", "Robert Zubrin"]

# ["Democracy in America", "Alexis de Tocqueville"]

# ...

Если блок не задан, то метод

execute

ResultSet

rs = db.execute("select title,author from books")

rs.each {|row| p row } # Тот же результат, что и выше.

rs.close

Если получен объект

ResultSet

reset

next

eof?

rs = db.execute("select title,author from books")

while ! rs.eof?

 rec = rs.next

 p rec # Тот же результат, что и выше.

end

rs.close

Методы библиотеки могут возбуждать различные исключения. Все они являются подклассами класса

SQLite::Exception

Отметим еще, что библиотека написана так, что может работать совместно с библиотекой

ArrayFields

sqlite

arrayfields

ResultSet

Hash

Хотя библиотека

sqlite

Интерфейс Ruby с MySQL — один из самых стабильных и полнофункциональных среди всех интерфейсов с базами данных. Это расширение, которое должно устанавливаться после инсталляции Ruby и MySQL.

Для использования модуля нужно выполнить три шага: прежде всего, загрузить модуль в свой сценарий, затем установить соединение с базой данных и, наконец, начать работать с таблицами. Для установления соединения следует задать обычные параметры: имя хоста, имя пользователя, пароль, имя базы данных и т.д.

require 'mysql'

m = Mysql.new("localhost","ruby","secret","maillist")

r = m.query("SELECT * FROM people ORDER BY name")

r.each_hash do |f|

 print "#{f['name']} - #{f['email']}"

end

# Выводится что-то вроде:

# John Doe - jdoe@rubynewbie.com

# Fred Smith - smithf@rubyexpert.com

Особенно полезны методы класса

Mysql.new

MysqlRes.each_hash

query

Модуль состоит из четырех классов (

Mysql

MysqlRes

MysqlField

MysqlError

Метод класса

Mysql.new

nil

host

user

passwd

db

port

sock

flag

new

real_connect

connect

Методы

create_db

select_db

drop_db

close

m=Mysql.new("localhost","ruby","secret")

m.create_db("rtest")  # Создать новую базу данных.

m.select_db("rtest2") # Выбрать другую базу данных.

in.drop_db("rtest")   # Удалить базу данных.

m.close               # Закрыть соединение.

В последних версиях методы

create_db

drop_db

class Mysql

 def create_db(db)

  query("CREATE DATABASE #{db}")

 end

 def drop_db(db)

  query("DROP DATABASE #{db}")

 end

end

Метод

list_dbs

dbs = m.list_dbs # ["people","places","things"]

Метод

query

MysqlRes

query_with_result

Mysql

Если произошла ошибка, то ее номер можно получить, обратившись к методу

errno

error

begin

 r=m.query("create table rtable

 (

  id int not null auto_increment,

  name varchar(35) not null,

  desc varchar(128) not null,

  unique id(id)

 )")

# Произошло исключение...

rescue

 puts m.error

  # Печатается: You have an error in your SQL syntax

  # near 'desc varchar(128) not null ,

  # unique id(id)

  # )' at line 5"

 puts m.errno

  # Печатается 1064

  # ('desc' is reserved for descending order)

end

Ниже перечислено несколько полезных методов экземпляра, определенных в классе

MysqlRes

• 

fetch_fields

MysqlField

• 

fetch_row

• 

fetch_hash(with_table=false)

• 

num_rows

• 

each

• 

each_hash(with_table=false)

{имя_поля => значение_поля}

x['имя_поля']

Вот некоторые методы экземпляра, определенные в классе

MysqlField

• 

name

• 

table

• 

length

• 

max_length

• 

hash

name

table

def

type

length

max_length

flags

decimals

Если изложенный здесь материал противоречит онлайновой документации, предпочтение следует отдать документации. Более подробную информацию вы найдете на официальном сайте MySQL (http://www.mysql.com) и в архиве приложений Ruby.

В архиве RAA есть также расширение, реализующее доступ к СУБД PostgreSQL (работает с версиями PostgreSQL 6.5/7.0).

В предположении, что PostgreSQL уже установлена и сконфигурирована (и в базе данных есть таблица

testdb

require 'postgres'

conn = PGconn.connect("", 5432, "", "", "testdb")

conn.exec("create table rtest ( number integer default 0 );")

conn.exec("insert into rtest values ( 99 )")

res = conn.query("select * from rtest")

# res id [["99"]]

В классе

PGconn

connect

connect

new

Для работы с таблицами нужно уметь выполнять запросы. Для этого служат методы

PGconn#exec

PGconn#query

Метод

exec

PGresult

PGError

Метод

query

nil

error

Имеется специальный метод

insert_table

PGconn

conn.insert_table("rtest",[[34]])

res = conn.query("select * from rtest")

res равно [["99"], ["34"]]

В этом примере в таблицу

rtest

res

PGresult

PGresult

В классе

PGconn

• 

db

• 

host

• 

user

• 

error

• 

finish

close

• 

loimport(file)

PGlarge

PGError

• 

loexport(oid, file)

oid

• 

locreate([mode])

PGlarge

PGError

• 

loopen(oid, [mode])

oid

PGlarge

mode

"INV_READ"

"INV_WRITE"

"INV_READ"

• 

lounlink(oid)

oid

Отметим, что пять последних методов (

loimport

loexport

locreate

loopen

lounlink

PGlarge

loimport

locreate

loopen

Ниже перечислены методы, определенные в классе

PGlarge

• 

open([mode])

mode

PGconn#loopen

• 

close

• 

read([length])

length

length

• 

write(str)

• 

tell

• 

seek(offset, whence)

offset

whence

SEEK_SET

SEEK_CUR

SEEK_END

• 

unlink

• 

oid

• 

size

• 

export(file)

Более интересны методы экземпляра, определенные в классе

PGresult

PGresult#clear

• 

result

• 

each

• 

[]

• 

fields

• 

num_tuples

• 

fieldnum(name)

• 

type(index)

• 

size(index)

• 

getvalue(tup_num, field_num)

tup_num

• 

getlength(tup_num, field_num)

• 

cmdstatus

• 

clear

PGresult

Для Ruby есть по меньшей мере три разных библиотеки, позволяющих работать с протоколом LDAP. Ruby/LDAP, написанная Такааки Татеиси (Takaaki Tateishi), — это довольно «тонкая» обертка. Если вы хорошо знакомы с LDAP, то ее может оказаться достаточно; в противном случае вы, наверное, сочтете ее слишком сложной. Пример:

conn = LDAP::Conn.new("rsads02.foo.com")

conn.bind("CN=username,CN=Users,DC=foo,DC=com", "password") do |bound|

 bound.search("DC=foo,DC=com", LDAP::LDAP_SCOPE_SUBTREE,

  "(&(name=*) (objectCategory=person))", ['name','ipPhone'])

 do |user|

  puts "#{user['name']} #{user['ipPhone']}"

 end

end

Библиотека

ActiveLDAP

ActiveRecord

require 'activeldap'

require 'examples/objects/user'

require 'password'

# Установить соединение Ruby/ActiveLDAP и т. д.

ActiveLDAP::Base.connect(:password_block

 => Proc.new { Password.get('Password: ') },

  :allow_anonymous => false)

# Загрузить запись с данными о пользователе

# (ее класс определен в примерах).

wad = User.new('wad')

# Напечатать общее имя.

р wad.cn

# Изменить общее имя.

wad.cn = "Will"

# Сохранить в LDAP.

wad.write

Есть также сравнительно недавняя библиотека, написанная Фрэнсисом Чианфрокка (Francis Cianfrocca), многие предпочитают именно ее:

require 'net/ldap'

ldap = Net::LDAP.new :host => server_ip_address,

 :port => 389,

 :auth => {

  :method => :simple,

  :username => "cn=manager,dc=example,dc=com",

  :password => "opensesame"

 }

filter = Net::LDAP::Filter.eq( "cn", "George*" )

treebase = "dc=example,dc=com"

ldap.search( :base => treebase, :filter => filter ) do |entry|

 puts "DN: #{entry.dn}"

 entry.each do |attribute, values|

  puts " #{attribute}:"

  values.each do |value|

   puts " --->#{value}"

  end

 end

end

p ldap.get_operation_result

Какая из этих библиотек лучше — дело вкуса. Я рекомендую познакомиться со всеми и сформировать собственное мнение.

Oracle — одна из наиболее мощных и популярных СУБД в мире. Понятно, что было много попыток реализовать интерфейс с этой базой данных из Ruby. На сегодняшний день лучшей считается библиотека OCI8, которую написал Кубо Такехиро (Kubo Takehiro).

Вопреки названию, библиотека OCI8 работает и с версиями Oracle младше 8. Но она еще не вполне зрелая, поэтому не позволяет воспользоваться некоторыми средствами, появившимися в последних версиях.

API состоит из двух уровней: тонкая обертка (низкоуровневый API, довольно точно повторяющий интерфейс вызовов Oracle — Call Level Interface). Но в большинстве случаев вы будете работать с высокоуровневым API. Не исключено, что в будущем низкоуровневый API станет недокументированным.

Модуль OCI8 включает классы

Cursor

Blob

OCIException

OCIError

OCIBreak

OCIInvalidHandle

Чтобы установить соединение с сервером, вызывается метод

OCI8.new

require 'oci8'

session = OCI8.new('user', 'password')

query = "SELECT TO_CHAR(SYSDATE, 'YYYY/MM/DD') FROM DUAL"

cursor = session.exec(query)

result = cursor.fetch # В данном случае всего одна итерация.

cursor.close

session.logoff

В примере выше показано, как манипулировать курсором, хотя в данном случае перед закрытием выполняется всего одна операция

fetch

query = 'select * from some_table'

cursor = session.exec(query)

while row = cursor.fetch

 puts row.join(",")

end

cursor.close

# Или с помощью блока:

nrows = session.exec(query) do |row|

 puts row.join(",")

end

Связанные переменные в запросе напоминают символы. Есть несколько способов связать переменные со значениями:

session = OCI8.new("user","password")

query = "select * from people where name = :name"

# Первый способ...

session.exec(query,'John Smith')

# Второй...

cursor = session.parse(query)

cursor.exec('John Smith')

# Третий...

cursor = session.parse(query)

cursor.bind_param(':name','John Smith') # Связывание по имени.

cursor.exec

# И четвертый.

cursor = session.parse(query)

cursor.bind_param(1,'John Smith')       # Связывание по номеру.

cursor.exec

Для тех, кто предпочитает интерфейс DBI, имеется соответствующий адаптер. Дополнительную информацию можно найти в документации по OCI8

Теоретически интерфейс DBI обеспечивает доступ к любым базам данных. Иными словами, один и тот же код должен работать и с Oracle, и с MySQL, и с PostgreSQL, и с любой другой СУБД, стоит лишь изменить одну строку, в которой указан нужный адаптер. Иногда эта идеология не срабатывает для сложных операций, специфичных для конкретной СУБД, но для рутинных задач она вполне годится.

Пусть имеется база данных под управлением Oracle и используется драйвер (он же адаптер), поставляемый вместе с библиотекой OCI8. Методу

connect

require "dbi"

db = DBI.connect("dbi:OCI8:mydb", "user", "password")

query = "select * from people"

stmt = db.prepare(query)

stmt.execute

while row = stmt.fetch do

 puts row.join(",")

end

stmt.finish

db.disconnect

Здесь метод

prepare

fetch

nil

while

finish

Полную информацию обо всех возможностях DBI можно найти в любом справочном руководстве. Список имеющихся драйверов приведен на сайте RubyForge и в архиве приложений Ruby.

Традиционная реляционная база данных прекрасно справляется со своими задачами. Она эффективно выполняет произвольные запросы, о которых заранее ничего не знает. Но эта модель плохо уживается с объектной ориентированностью.

Повсеместная распространенность обеих моделей (РСУБД и ООП) и «несогласованный импеданс» между ними побудил многих людей попытаться перебросить мост. Этот программный мост получил название «объектно-реляционное отображение» (Object-Relational Mapper — ORM).

К этой задаче существуют разные подходы. У каждого есть свои достоинства и недостатки. Ниже мы рассмотрим два популярных ORM:

ActiveRecord

Og

Библиотека

ActiveRecord

Каждая таблица описывается классом, производным от

ActiveRecord::Base

require 'active_record'

ActiveRecord::Base.establish_connection(:adapter => "oci8",

 :username => "username",

 :password => "password",

 :database => "mydb",

 :host => "myhost")

class SomeTable < ActiveRecord::Base

 set_table_name "test_table"

 set_primary_key "some_id"

end

SomeTable.find(:all).each do |rec|

 # Обработать запись...

end

item = SomeTable.new

item.id = 1001

item.some_column = "test"

item.save

Библиотека предлагает богатый и сложный API. Я рекомендую ознакомиться со всеми руководствами, которые вы сможете найти в сети или в книгах. Поскольку эта библиотека составляет неотъемлемую часть системы «Ruby on Rails», то мы еще вернемся к ней в главе, посвященной этой теме.

Og

ActiveRecord

Og

При работе с

Og

Определяя подлежащий хранению класс, мы пользуемся методом

property

attr_accessor

class SomeClass

 property :alpha, String

 property :beta, String

 property :gamma, String

end

Поддерживаются также типы данных

Integer

Float

Time

Date

Соединение с базой данных устанавливается так же, как в случае

ActiveRecord

DBI

db = Og::Database.new(:destroy => false,

 :name => 'mydb',

 :store => :mysql,

 :user => 'hal9000',

 :password => 'chandra')

У каждого объекта есть метод

save

obj = SomeClass.new

obj.alpha = "Poole"

obj.beta = "Whitehead"

obj.gamma = "Kaminski"

obj.save

Имеются также методы для описания связей объекта в терминах классической теории баз данных:

class Dog

 has_one    :house

 belongs_to :owner

 has_many   :fleas

end

Эти, а также другие методы, например

many_to_many

refers_to

Библиотека

Og

В данной главе был представлен обзор ввода/вывода в Ruby. Мы рассмотрели сам класс

IO

File

Dir

Pathname

IO

Также было уделено внимание вопросам хранения данных на более высоком уровне, точнее, на внешних носителях в виде сериализованных объектов. Наконец, мы дали краткий обзор решений, которые Ruby предлагает для интерфейса с настоящими базами данных, а кроме того, познакомились с некоторыми объектно-ориентированными подходами к взаимодействию с реляционными СУБД.

Ниже мы еще вернемся к вводу/выводу в контексте сокетов и сетевого программирования. Но предварительно рассмотрим некоторые другие темы.