Pass Nokogiri object to ERB page, and then back to post - ruby

Question

This is in Sinatra. In my 'get', I create an instance variable which is a nokogiri object, created from an external xml file. I go to an erb file and parse through that nokogiri object in order to do the page layout. In my post method, I need access to that same nokogiri object (I may return to post numerous times and may modify the nokogiri object). The way I've been doing this is to set a hidden variable in the erb page, like this:
<input type="hidden" name="test" value= '<%= #test %>' >
Then in my post, I create a nokogiri object from that variable like this:
#test = Nokogiri::XML(params["test"])
This seemed clunky, but I'm not experienced in this stuff. Anyway, everything worked fine, except that somewhere along the line, my embedded quotes in the xml get mangled. For example, node in my file starts like this:
<property name="blah" value='{"name:foo"}'> </property>
And when I do a puts in my post of params["test"], I get this:
<property name="blah" value="{"name:foo"}"> </property>
(single quotes became double quotes), and finally, after converting it back into a nokogiri object, with the following code:
#test = Nokogiri::XML(params["test"])
I get this:
<property name="blah" value="{"/>name:foo"}"> </root>
Is there a better way to retain access to the object? If not, is there a way to retain my embedded quotes ( I think setting the hidden variable in the erb file is where it gets mangeled)

Answer 1

Summary
Cache the Nokogiri documents in a constant (e.g. a hash or module), which live across requests (within the same server run; see below).
Send only the key to the hash in your form.
Use the key to get the document back out of the constant later on.
Example
package_32.xml
<packages><kittens in_box="true">32</kittens></packages>
cache_nokodocs.rb
require 'sinatra'
require 'nokogiri'
module NokoDocs
#docs_by_file = {}
def self.[](file)
#docs_by_file[file] ||= Nokogiri::XML(IO.read(file))
end
end
get "/xml/:doc" do
#doc = params['doc']
#xml = NokoDocs[#doc]
<<-ENDHTML
The XML starts with '#{#xml.root.name}'
<form method="post" action="/">
<input type="hidden" name="xml" value="#{#doc}">
<button type="submit">Go</button>
</form>
ENDHTML
end
post "/" do
#xml = NokoDocs[params['xml']]
#xml.to_s
end
Using
C:\>curl http://localhost:4567/xml/package_32.xml
The XML starts with 'packages'
<form method="post" action="/">
<input type="hidden" name="xml" value="package_32.xml">
<button type="submit">Go</button>
</form>
# simulate post that the web browser does from the command line
C:\>curl -d xml="package_32.xml" http://localhost:4567/
<?xml version="1.0"?>
<packages>
<kittens in_box="true">32</kittens>
</packages>
The first time any user requests a particular XML file, it will be loaded into the hash; subsequent requests for that file will fetch it from the hash directly, pre-parsed.
Beware!
The documents will not be cached across multiple instances of the server (e.g. if you're behind a reverse proxy). They will also not be cached across server restarts. However, if these are static files on disk, the worst that will happen is that the particular server session will just have to re-create the Nokogiri document once before caching it.
Using the file name on disk and then letting the user post it back to you is probably a really, really dangerous thing to do. Instead, you might create a custom or random key when you load the document and use that. For example:
require 'digest'
module NokoDocs
#docs_by_file = {}
def self.from_file(file)
key = Digest::SHA1( file + rand(100) )
[
#docs_by_file[key] ||= Nokogiri::XML(IO.read(file)),
key
]
end
def self.from_key(key)
#docs_by_file[key]
end
end
get "/xml/:doc" do
#xml, #key = NokoDocs.from_file params['doc']
...
"<input type="hidden" name="key" value="#{#key}">"
...
end
post "/" do
#xml = NokoDocs.from_key params['key']
end
This is a potential memory leak. Each unique document your users request is parsed as a big Nokogiri document and preserved forever (until you restart the server). You might want a system that records the last access time and have a timed job that periodically sweeps out items that haven't been accessed in a while.