String to complex object

ciao!

ho una serie di string ad esempio:

field_list[:Company][:business_name]=true
field_list[:Company][:email]=true
field_list[:Company][:website]=true
field_list[:Company][:fiscal_code]=true
field_list[:Company][:vat_code]=true
field_list[:Company][:Address][:street]=true
field_list[:Company][:Address][:number]=true
field_list[:Company][:Address][:town]=true
field_list[:Company][:PhoneNumber][:PhoneType][:value]=true
field_list[:Company][:PhoneNumber][:number]=true

(non sono statement sono proprio stringhe)

devo autogenerare la struttura che diverrà quindi del tipo

{
:Company=> {:fiscal_code=>true,
:PhoneNumber=>{ :PhoneType=> { :value=>true },
:number=>true },
:vat_code=>true,
:Address=> { :town=>true,
:street=>true,
:number=>true },
:business_name=>true,
:email=>true,
:website=>true }
}

Qualche suggerimento/idea/plugin ?

così in punta di piedi, direi di usare una eval :stuck_out_tongue:

A.

Il 13/09/2010 14:12, Alessandro S. ha scritto:

Certo eval funzionerebbe molto bene se non fosse che mancano le
“inizializzazioni” delle strutture dati (field_list={} etc… per
intenderci)

Al momento ho risolto cambiando la generazione delle string (che vengono
generate da un post http, così posso usare YAML per salvarmi la
struttura) resta comunque la curiosità …

Andrea P. wrote:

cos� in punta di piedi, direi di usare una eval :stuck_out_tongue:

A.

Il 13/09/2010 14:12, Alessandro S. ha scritto:

Ho l’impressione che servirebbe una di queste due cose:

  1. Un metodo per convertire un blocco in una stringa, così potresti
    farne il parsing e generare le definizioni mancanti iniziando con
    field_list = {}. In pratica è l’inverso della eval e se ci fosse
    potresti scrivere qualcosa come

field_list = Make.hash {
field_list[:Company][:business_name] = true
field_list[:Company][:email] = true
field_list[:Company][:website] = true

}

  1. Un metodo per avere il testo del codice della linea che ha generato
    un errore. Sapendo che field_list[:Company][:business_name] = true ha
    generato un’eccezione potresti fare l’eval di field_list[:Company] = {}

Ma poichè quel codice in qualche modo l’hai generato, perché non ci hai
aggiunto già le definizioni degli hash?

Infine, mentre controllavo le possibili soluzioni ho trovato queste due
cose interessanti:

A) Conoscevate tutti il metodo set_trace_func della classe Kernel?
http://eigenclass.org/hiki/ruby+backtrace+line+numbers

B) Una spiegazione più chiara del solito di cosa sono i blocchi e le
Proc e di come li si passano e li si assegnano
http://weblog.raganwald.com/2008/06/what-does-do-when-used-as-unary.html

Ciao
Paolo

Alessandro S. wrote:

Certo eval funzionerebbe molto bene se non fosse che mancano le
“inizializzazioni” delle strutture dati (field_list={} etc… per
intenderci)

Al momento ho risolto cambiando la generazione delle string (che vengono
generate da un post http, così posso usare YAML per salvarmi la
struttura) resta comunque la curiosità …

Andrea P. wrote:

così in punta di piedi, direi di usare una eval :stuck_out_tongue:

A.

Il 13/09/2010 14:12, Alessandro S. ha scritto:

thanx! nel mio caso ho risolto (come ho scritto sopra) modificando
appunto la generazione della stringa (che ho trasformato in un oggetto
tramite javascript), la mia restava proprio una curiosità generale, un
metodo che data una stringa generi un albero “credibile” che potrebbe
essere di array o hash (magari intelligente in modo che a ogni
successiva richiesta capisca appunto se si tratta di un array o di una
hash modificando il risultato)…

Ero giusto per sapere se qualcuno lo aveva già fatto o meno
(probabilmente lo scriverò io visto che potrebbe servirmi in futuro…
chi lo sà :slight_smile: )

gabriele renzi wrote:

2010/9/14 Paolo M. [email protected]:

Ho l’impressione che servirebbe una di queste due cose:

  1. Un metodo per convertire un blocco in una stringa, cos� potresti
    farne il parsing e generare le definizioni mancanti iniziando con
    field_list = {}. In pratica � l’inverso della eval e se ci fosse
    potresti scrivere qualcosa come

SCRIPT_LINES__ pu� essere tuo amico (la feature meno nota di ruby
AFAICT), ma come dici sotto tu, visto che crei programmaticamente sta
cosa tanto vale metterci anche i metadati.

2010/9/14 Paolo M. [email protected]:

Ho l’impressione che servirebbe una di queste due cose:

  1. Un metodo per convertire un blocco in una stringa, così potresti
    farne il parsing e generare le definizioni mancanti iniziando con
    field_list = {}. In pratica è l’inverso della eval e se ci fosse
    potresti scrivere qualcosa come

SCRIPT_LINES__ può essere tuo amico (la feature meno nota di ruby
AFAICT), ma come dici sotto tu, visto che crei programmaticamente sta
cosa tanto vale metterci anche i metadati.

$ cat t.rb
SCRIPT_LINES__ = {} #se definito, l’interprete carica hash con coppie
file/content
at_exit do p SCRIPT_LINES__ end
$ cat t2.rb
puts “ciao”
mecbuc:Cascaad (stable) rff$ ruby -rt.rb t2.rb
ciao
{“t2.rb”=>[“puts “ciao”\n”]}

Anche ripper & parsetree e simili ti permettono di farlo riparsandoti
il codice (forse evil.rb ?) ma sono hack.

Infine, mentre controllavo le possibili soluzioni ho trovato queste due
cose interessanti:

A) Conoscevate tutti il metodo set_trace_func della classe Kernel?
http://eigenclass.org/hiki/ruby+backtrace+line+numbers

si, ma metteva molto overhead nella 1.8, non so con la 1.9 :slight_smile:

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs