Class: YAML::DBM (Ruby 2.2.3)
Description: Class : YAML::DBM - Ruby 2.2.3

- Home
- Core 2.2.3
- Std-lib 2.2.3
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- yaml/dbm.rb

### Parent

DBM

### Methods

- #[]
- #[]=
- #delete
- #delete_if
- #each
- #each_pair
- #each_value
- #fetch
- #has_value?
- #index
- #invert
- #key
- #reject
- #replace
- #select
- #shift
- #store
- #to_a
- #to_hash
- #update
- #values
- #values_at

### Class/Module Index

Quicksearch

- Object
- YAML
- YAML::DBM
- YAML::Store

No matching classes.

# YAML::DBM

YAML + DBM = YDBM

YAML::DBM provides the same interface as ::DBM.

However, while DBM only allows strings for both keys and values, this library allows one to use most Ruby objects for values by first converting them to YAML. Keys must be strings.

Conversion to and from YAML is performed automatically.

See the documentation for ::DBM and ::YAML for more information.

### Public Instance Methods

ydbm[key] → value click to toggle source

Return value associated with `key` from database.

Returns `nil` if there is no such `key`.

See fetch for more information.

                   # File yaml/dbm.rb, line 28
    def []( key )
        fetch( key )
    end

ydbm[key] = value click to toggle source

Set `key` to `value` in database.

`value` will be converted to YAML before storage.

See store for more information.

                   # File yaml/dbm.rb, line 40
    def []=( key, val )
        store( key, val )
    end

delete(key) click to toggle source

Deletes value from database associated with `key`.

Returns value or `nil`.

                   # File yaml/dbm.rb, line 101
    def delete( key )
        v = super( key )
        if String === v
            v = YAML.load( v )
        end
        v
    end

delete_if { |key, value| ... } click to toggle source

Calls the given block once for each `key`, `value` pair in the database. Deletes all entries for which the block returns true.

Returns `self`.

                   # File yaml/dbm.rb, line 116
    def delete_if # :yields: [key, value]
        del_keys = keys.dup
        del_keys.delete_if { |k| yield( k, fetch( k ) ) == false }
        del_keys.each { |k| delete( k ) }
        self
    end

each() click to toggle source
Alias for: each_pair
each_pair { |key, value| ... } click to toggle source

Calls the given block once for each `key`, `value` pair in the database.

Returns `self`.

                   # File yaml/dbm.rb, line 139
    def each_pair # :yields: [key, value]
        keys.each { |k| yield k, fetch( k ) }
        self
    end

Also aliased as: each
each_value { |value| ... } click to toggle source

Calls the given block for each value in database.

Returns `self`.

                   # File yaml/dbm.rb, line 150
    def each_value # :yields: value
        super { |v| yield YAML.load( v ) }
        self
    end

fetch( key, ifnone = nil ) click to toggle source
fetch( key ) { |key| ... }

Return value associated with `key`.

If there is no value for `key` and no block is given, returns `ifnone`.

Otherwise, calls block passing in the given `key`.

See ::DBM#fetch for more information.

                   # File yaml/dbm.rb, line 55
    def fetch( keystr, ifnone = nil )
        begin
            val = super( keystr )
            return YAML.load( val ) if String === val
        rescue IndexError
        end
        if block_given?
            yield keystr
        else
            ifnone
        end
    end

has_value?(value) click to toggle source

Returns true if specified `value` is found in the database.

                   # File yaml/dbm.rb, line 167
    def has_value?( val )
        each_value { |v| return true if v == val }
        return false
    end

index( keystr ) click to toggle source

Deprecated, used #key instead.

Note: #index makes warning from internal of ::DBM#index. It says 'DBM#index is deprecated; use #key', but #key behaves not same as #index.

                   # File yaml/dbm.rb, line 75
    def index( keystr )
        super( keystr.to_yaml )
    end

invert → hash click to toggle source

Returns a Hash (not a DBM database) created by using each value in the database as a key, with the corresponding key as its value.

Note that all values in the hash will be Strings, but the keys will be actual objects.

                   # File yaml/dbm.rb, line 180
    def invert
        h = {}
        keys.each { |k| h[ self.fetch( k ) ] = k }
        h
    end

key(value) → string click to toggle source

Returns the key for the specified value.

                   # File yaml/dbm.rb, line 83
    def key( keystr )
        invert[keystr]
    end

reject { |key, value| ... } click to toggle source

Converts the contents of the database to an in-memory Hash, then calls Hash#reject with the specified code block, returning a new Hash.

                   # File yaml/dbm.rb, line 128
    def reject
        hsh = self.to_hash
        hsh.reject { |k,v| yield k, v }
    end

replace(hash) → ydbm click to toggle source

Replaces the contents of the database with the contents of the specified object. Takes any object which implements the #each_pair method, including Hash and DBM objects.

                   # File yaml/dbm.rb, line 192
    def replace( hsh )
        clear
        update( hsh )
    end

select { |key, value| ... } click to toggle source
select(*keys)

If a block is provided, returns a new array containing [key, value] pairs for which the block returns true.

Otherwise, same as values_at

                   # File yaml/dbm.rb, line 218
    def select( *keys )
        if block_given?
            self.keys.collect { |k| v = self[k]; [k, v] if yield k, v }.compact
        else
            values_at( *keys )
        end
    end

shift → [key, value] click to toggle source

Removes a [key, value] pair from the database, and returns it. If the database is empty, returns `nil`.

The order in which values are removed/returned is not guaranteed.

                   # File yaml/dbm.rb, line 204
    def shift
        a = super
        a[1] = YAML.load( a[1] ) if a
        a
    end

store(key, value) → value click to toggle source

Stores `value` in database with `key` as the index. `value` is converted to YAML before being stored.

Returns `value`

                   # File yaml/dbm.rb, line 233
    def store( key, val )
        super( key, val.to_yaml )
        val
    end

to_a → array click to toggle source

Converts the contents of the database to an array of [key, value] arrays, and returns it.

                   # File yaml/dbm.rb, line 258
    def to_a
        a = []
        keys.each { |k| a.push [ k, self.fetch( k ) ] }
        a
    end

to_hash → hash click to toggle source

Converts the contents of the database to an in-memory Hash object, and returns it.

                   # File yaml/dbm.rb, line 270
    def to_hash
        h = {}
        keys.each { |k| h[ k ] = self.fetch( k ) }
        h
    end

update(hash) → ydbm click to toggle source

Updates the database with multiple values from the specified object. Takes any object which implements the #each_pair method, including Hash and DBM objects.

Returns `self`.

                   # File yaml/dbm.rb, line 246
    def update( hsh )
        hsh.each_pair do |k,v|
            self.store( k, v )
        end
        self
    end

values click to toggle source

Returns an array of values from the database.

                   # File yaml/dbm.rb, line 159
    def values
        super.collect { |v| YAML.load( v ) }
    end

values_at(*keys) click to toggle source

Returns an array containing the values associated with the given keys.

                   # File yaml/dbm.rb, line 91
    def values_at( *keys )
        keys.collect { |k| fetch( k ) }
    end