Class PStore < Object

# File ../ruby/lib/pstore.rb, line 121
def initialize(file, thread_safe = false)
  dir = File::dirname(file)
  unless File::directory? dir
    raise PStore::Error, format("directory %s does not exist", dir)
  end
  if File::exist? file and not File::readable? file
    raise PStore::Error, format("file %s not readable", file)
  end
  @filename = file
  @abort = false
  @ultra_safe = false
  @thread_safe = thread_safe
  @lock = Mutex.new
end

# File ../ruby/lib/pstore.rb, line 157
def [](name)
  in_transaction
  @table[name]
end

# File ../ruby/lib/pstore.rb, line 202
def []=(name, value)
  in_transaction_wr()
  @table[name] = value
end

# File ../ruby/lib/pstore.rb, line 290
def abort
  in_transaction
  @abort = true
  throw :pstore_abort_transaction
end

# File ../ruby/lib/pstore.rb, line 264
def commit
  in_transaction
  @abort = false
  throw :pstore_abort_transaction
end

# File ../ruby/lib/pstore.rb, line 212
def delete(name)
  in_transaction_wr()
  @table.delete name
end

# File ../ruby/lib/pstore.rb, line 171
def fetch(name, default=PStore::Error)
  in_transaction
  unless @table.key? name
    if default == PStore::Error
      raise PStore::Error, format("undefined root name `%s'", name)
    else
      return default
    end
  end
  @table[name]
end

# File ../ruby/lib/pstore.rb, line 238
def path
  @filename
end

# File ../ruby/lib/pstore.rb, line 233
def root?(name)
  in_transaction
  @table.key? name
end

# File ../ruby/lib/pstore.rb, line 223
def roots
  in_transaction
  @table.keys
end

# File ../ruby/lib/pstore.rb, line 313
def transaction(read_only = false, &block)  # :yields:  pstore
  value = nil
  raise PStore::Error, "nested transaction" if !@thread_safe && @lock.locked?
  @lock.synchronize do
    @rdonly = read_only
    @abort = false
    file = open_and_lock_file(@filename, read_only)
    if file
      begin
        @table, checksum, original_data_size = load_data(file, read_only)

        catch(:pstore_abort_transaction) do
          value = yield(self)
        end

        if !@abort && !read_only
          save_data(checksum, original_data_size, file)
        end
      ensure
        file.close if !file.closed?
      end
    else
      # This can only occur if read_only == true.
      @table = {}
      catch(:pstore_abort_transaction) do
        value = yield(self)
      end
    end
  end
  value
rescue ThreadError
  raise PStore::Error, "nested transaction"
end

# File ../ruby/lib/pstore.rb, line 507
def empty_marshal_checksum
  EMPTY_MARSHAL_CHECKSUM
end

# File ../ruby/lib/pstore.rb, line 504
def empty_marshal_data
  EMPTY_MARSHAL_DATA
end

# File ../ruby/lib/pstore.rb, line 137
def in_transaction
  raise PStore::Error, "not in transaction" unless @lock.locked?
end

# File ../ruby/lib/pstore.rb, line 144
def in_transaction_wr()
  in_transaction()
  raise PStore::Error, "in read-only transaction" if @rdonly
end

# File ../ruby/lib/pstore.rb, line 387
def load_data(file, read_only)
  if read_only
    begin
      table = load(file)
      if !table.is_a?(Hash)
        raise Error, "PStore file seems to be corrupted."
      end
    rescue EOFError
      # This seems to be a newly-created file.
      table = {}
    end
    table
  else
    data = file.read
    if data.empty?
      # This seems to be a newly-created file.
      table = {}
      checksum = empty_marshal_checksum
      size = empty_marshal_data.size
    else
      table = load(data)
      checksum = Digest::MD5.digest(data)
      size = data.size
      if !table.is_a?(Hash)
        raise Error, "PStore file seems to be corrupted."
      end
    end
    data.replace(EMPTY_STRING)
    [table, checksum, size]
  end
end

# File ../ruby/lib/pstore.rb, line 433
def marshal_dump_supports_canonical_option?
  begin
    Marshal.dump(nil, -1, true)
    result = true
  rescue
    result = false
  end
  self.class.instance_method(:marshal_dump_supports_canonical_option?)
  self.class.__send__(:define_method, :marshal_dump_supports_canonical_option?) do
    result
  end
  result
end

# File ../ruby/lib/pstore.rb, line 419
def on_windows?
  is_windows = RUBY_PLATFORM =~ /mswin/  ||
               RUBY_PLATFORM =~ /mingw/  ||
               RUBY_PLATFORM =~ /bccwin/ ||
               RUBY_PLATFORM =~ /wince/
  self.class.__send__(:define_method, :on_windows?) do
    is_windows
  end
  is_windows
end

# File ../ruby/lib/pstore.rb, line 362
def open_and_lock_file(filename, read_only)
  if read_only
    begin
      file = File.new(filename, RD_ACCESS)
      begin
        file.flock(File::LOCK_SH)
        return file
      rescue
        file.close
        raise
      end
    rescue Errno::ENOENT
      return nil
    end
  else
    file = File.new(filename, RDWR_ACCESS)
    file.flock(File::LOCK_EX)
    return file
  end
end

# File ../ruby/lib/pstore.rb, line 447
def save_data(original_checksum, original_file_size, file)
  # We only want to save the new data if the size or checksum has changed.
  # This results in less filesystem calls, which is good for performance.
  if marshal_dump_supports_canonical_option?
    new_data = Marshal.dump(@table, -1, true)
  else
    new_data = dump(@table)
  end
  new_checksum = Digest::MD5.digest(new_data)

  if new_data.size != original_file_size || new_checksum != original_checksum
    if @ultra_safe && !on_windows?
      # Windows doesn't support atomic file renames.
      save_data_with_atomic_file_rename_strategy(new_data, file)
    else
      save_data_with_fast_strategy(new_data, file)
    end
  end

  new_data.replace(EMPTY_STRING)
end

# File ../ruby/lib/pstore.rb, line 469
def save_data_with_atomic_file_rename_strategy(data, file)
  temp_filename = "#{@filename}.tmp.#{Process.pid}.#{rand 1000000}"
  temp_file = File.new(temp_filename, WR_ACCESS)
  begin
    temp_file.flock(File::LOCK_EX)
    temp_file.write(data)
    temp_file.flush
    File.rename(temp_filename, @filename)
  rescue
    File.unlink(temp_file) rescue nil
    raise
  ensure
    temp_file.close
  end
end

# File ../ruby/lib/pstore.rb, line 485
def save_data_with_fast_strategy(data, file)
  file.rewind
  file.truncate(0)
  file.write(data)
end