[newbie]saving and reading array of associative array

[Yvon Thoraval]

i'm looking for examples of saving to file and reading back an array of
associative array, in a ruby like way.

saying i have something like :

one = {"Name" => "Smith", "Surname" => "John" ...}
two = {"Name" => "Dupont", "Surname" => "Jean" ...}

myFriends = [one, two, ...]

i want to save into a file "myFriends.db" the array of hashes myFriends
in such a way reading it back will recorver the array of hashes the
easiest way...
--
Yvon

[gabriele renzi]

il Wed, 17 Sep 2003 11:13:26 +0200,
[email]yvon.thoravallist@-SUPPRIMEZ-free.fr.inva[/email]lid (Yvon Thoraval) ha
scritto::

>i'm looking for examples of saving to file and reading back an array of
>associative array, in a ruby like way.
>
>saying i have something like :
>
>one = {"Name" => "Smith", "Surname" => "John" ...}
>two = {"Name" => "Dupont", "Surname" => "Jean" ...}
>
>myFriends = [one, two, ...]
>
>i want to save into a file "myFriends.db" the array of hashes myFriends
>in such a way reading it back will recorver the array of hashes the
>easiest way...

----------------------------------------------------------
Marshal::dump
dump( anObject [, anIO] , limit=--1 ) -> anIO
------------------------------------------------------------------------
Serializes anObject and all descendent objects. If anIO is
specified, the serialized data will be written to it, otherwise
the
data will be returned as a String. If limit is specified, the
traversal of subobjects will be limited to that depth. If limit
is
negative, no checking of depth will be performed.

More easy than you think ;)

BTW you could even use PStore, included in the standard lib, it works
similar to an hash, but gets saved on disk and supports 'transactions'
for data integrity.

[Yvon Thoraval]

gabriele renzi <surrender_it@remove.yahoo.it> wrote:

>
> ----------------------------------------------------------
> Marshal::dump
> dump( anObject [, anIO] , limit=--1 ) -> anIO
> ------------------------------------------------------------------------
> Serializes anObject and all descendent objects. If anIO is
> specified, the serialized data will be written to it, otherwise
> the
> data will be returned as a String. If limit is specified, the
> traversal of subobjects will be limited to that depth. If limit
> is
> negative, no checking of depth will be performed.
>
> More easy than you think ;)
>
> BTW you could even use PStore, included in the standard lib, it works
> similar to an hash, but gets saved on disk and supports 'transactions'
> for data integrity.

tanxs a lot !
--
Yvon

[Joey Gibson]

On 9/17/2003 6:34 AM, gabriele renzi wrote:

>Marshal::dump
> dump( anObject [, anIO] , limit=--1 ) -> anIO
>
>BTW you could even use PStore, included in the standard lib, it works
>similar to an hash, but gets saved on disk and supports 'transactions'
>for data integrity.
>
>

You could also use YAML:

require 'yaml'
one = {"Name" => "Smith", "Surname" => "John"}
two = {"Name" => "Dupont", "Surname" => "Jean"}

myFriends = [one, two]

File.open("myfriends.db", "w") {|file| file.write(myFriends.to_yaml)}
myFriends = File.open("myfriends.db") {|file| YAML.load(file)}


--
Dean saor, dean saor an spiorad. Is seinn d'orain beo.

[url]http://www.joeygibson.com[/url]
[url]http://www.joeygibson.com/blog/life/Wisdom.html[/url]

[Yvon Thoraval]

Joey Gibson <joey@joeygibson.com> wrote:

>
> You could also use YAML:
>
> require 'yaml'
> one = {"Name" => "Smith", "Surname" => "John"}
> two = {"Name" => "Dupont", "Surname" => "Jean"}
>
> myFriends = [one, two]
>
> File.open("myfriends.db", "w") {|file| file.write(myFriends.to_yaml)}
> myFriends = File.open("myfriends.db") {|file| YAML.load(file)}

fine, i should say i've other versions of what i plan to do in :

- perlCocoa (CamelBones specific to MacOS X)
- php + xml
- php + mySQL

--
Yvon

[Jason Creighton]

On Wed, 17 Sep 2003 21:22:13 +0900
Joey Gibson <joey@joeygibson.com> wrote:

> On 9/17/2003 6:34 AM, gabriele renzi wrote:
>

> >Marshal::dump
> > dump( anObject [, anIO] , limit=--1 ) -> anIO
> >
> >BTW you could even use PStore, included in the standard lib, it works
> >similar to an hash, but gets saved on disk and supports 'transactions'
> >for data integrity.
> >
> >

>
> You could also use YAML:
>
> require 'yaml'
> one = {"Name" => "Smith", "Surname" => "John"}
> two = {"Name" => "Dupont", "Surname" => "Jean"}
>
> myFriends = [one, two]
>
> File.open("myfriends.db", "w") {|file| file.write(myFriends.to_yaml)}
> myFriends = File.open("myfriends.db") {|file| YAML.load(file)}

Yes, I was just about to mention YAML. Also note that you can use
YAML::Store as a drop-in PStore replacement. (In fact, this example is
the example given in pstore.rb, I just require'd yaml/store, and changed
the db = line to YAML::Store)

~/prog/ruby$ cat yaml-store-example.rb
require 'yaml/store'
db = YAML::Store.new("/tmp/foo")
db.transaction do
p db.roots
ary = db["root"] = [1,2,3,4]
ary[0] = [1,1.5]
end

db.transaction do
p db["root"]
end
~/prog/ruby$ ruby yaml-store-example.rb
[]
[[1, 1.5], 2, 3, 4]
~/prog/ruby$ cat /tmp/foo
---
root:
-
- 1
- 1.5
- 2
- 3
- 4
~/prog/ruby$

Jason Creighton