How to write back the variables in a tcl readable format to the file intelligently using tcl in the same format - tcl

Question

This code has a class named class1 and methods set, get, load, save
# Class1 definition
oo::class create class1 {
variable dataArr
method set {key value} {
set dataArr($key) $value
}
method get {key} {
if {[info exist dataArr($key)]} {
return $dataArr($key)
}
}
method load {} {
set fp [open /home/karthikc/data.tcl r]
set file_data [read $fp]
puts $file_data
eval $file_data
close $fp
}
method save {{newFilePath ""}} {
if [info exists filePath] {
set tmpFP $filePath
}
if {$newFilePath ne ""} {
set tmpFP $newFilePath
}
if ![info exists tmpFP] {
puts"neither newFilePath argument is passed nor filePath variable is present"
return 0
}
try {
set fhandle [open $tmpFP w]
if ![info exists dataArr] {
puts "dataArr variable doesn't exist in the object [self]"
return 0
}
foreach key [array names dataArr] {
set kvPair [list $key $dataArr($key)]
lappend dataLst $kvPair
puts $fhandle "my set $key $dataArr($key)"
puts "my set $key $dataArr($key)"
}
set filePath $tmpFP
puts "dictionary is successfully saved in the file path"
} on error {result opts} {
puts $result
puts "Return options Directory"
puts $opts
return 0
} finally {
if [info exist fhandle] {
close $fhandle
}
}
return 1
}
}
Which I use like this:
# create object instance
set obj [class1 new]
# call load method
$obj load
# call save method
$obj save /home/karthikc/data.tcl
my data.tcl is
my set key1 value1
my set key2 value2
my set key3 [list valueA valueB valueC]
my set key4 [list valueX [list valueY valueZ]]
I want to write back to same format or some other list of lists

Answer 1

Suggestions for improvement
You can simplify your SERIALIZER, and render it more robust along the way.
First, don't serialize the object's state into a script, but a literal map (associative array or dict in Tcl). And read it as such:
data.tcl could look like:
key3 {valueA valueB valueC}
key4 {valueX {valueY valueZ}}
key1 value1
key2 value2
Your load method could use array set to read this directly:
method load {} {
set fp [open /tmp/data.tcl r]
set file_data [read $fp]
array set dataArr $file_data
close $fp
}
Your save method can directly use array get and produce formatted output:
method save2 {{newFilePath ""}} {
if {[array exists dataArr]} {
set fhandle [open $newFilePath w]
set out ""
foreach {k v} [array get dataArr] {
append out $k " " [list $v] \n
}
puts $fhandle $out
close $fhandle
}
}
Key to the idea is to avoid eval, and, therefore, code injection. And the serialization format matches 1:1 first-class Tcl data structures.
Improving your question
Allow me to say, your question is not a proper question. It does not state a problem, one has to read between the lines and snippets to sense what you are after. Also, the code example should be reduced to a minimum, to demonstrate your perceived problem. It is not helpful to paste your entire code work.

Answer 2

I changed the format of storing the lists
from
my set key1 value1
my set key2 value2
my set key3 [list valueA valueB valueC]
my set key4 [list valueX [list valueY valueZ]]
to
my set key1 value1
my set key2 value2
my set key3 {valueA valueB valueC}
my set key4 {valueX {valueY valueZ}}
and in save method I changed
puts $fhandle "my set $key $dataArr($key)"
to
puts $fhandle [list my set $key $dataArr($key)]
And these changes serve the purpose.