Программирование на языке Ruby - Хэл Фултон

10.2.1. Простой маршалинг

Часто бывает необходимо создать объект и сохранить его для последующего использования. В 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), то версии должны совпадать точно. Эти номера версий не связаны с номерами версий Ruby.

Третий параметр 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. Отрицательное значение означает, что глубина вложенности не проверяется.

10.2.2. Более сложный маршалинг

Иногда мы хотим настроить маршалинг под свои нужды. Такую возможность дают методы _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).

10.2.3. Ограниченное «глубокое копирование» в ходе маршалинга

В Ruby нет операции «глубокого копирования». Методы dup и clone не всегда работают, как ожидается. Объект может содержать ссылки на вложенные объекты, а это превращает операцию копирования в игру «собери палочки».

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

def deep_copy(obj)

 Marshal.load(Marshal.dump(obj))

end

a = deep_copy(b)

10.2.4. Обеспечение устойчивости объектов с помощью библиотеки PStore

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

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

10.2.5. Работа с данными в формате CSV

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

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

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