Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Ruby > [ANN] Ron 0.1.0 Released

Reply
Thread Tools

[ANN] Ron 0.1.0 Released

 
 
Caleb Clausen
Guest
Posts: n/a
 
      10-10-2006
Ron version 0.1.0 has been released!

http://rubyforge.org/projects/ron

Well, who needed another serialization format? Not me, but that's what
I've made. Ruby Object Notation (Ron) is a textual format for the
representation of Ruby data structures. It's somewhat like YAML, XML,
or (most of all) JSON. However, since it is defined entirely within and
as a subset of Ruby, it has the slick property that Ron expressions are
legal Ruby. Thus it is very like JSON, except that it's Ruby-centered
instead of being JavaScript-centered.

Another way to look at Ron is as a purely declarative language for
creating (almost) any type of Ruby data structure.

Ruby already has formats for representing a literal Array, Hash, Set,
String, Symbol, Integer, etc. Ron simply reuses the same notations for
those data types. The major new feature of Ron is that it provides a
literal syntax for representing arbitrary Ruby Objects.

Say you have a class that looks like this:

class K
attr :a
attr :b
end

A Ron literal that represents a K instance might look like this:

K-{:@a=>1, :@b=>2}

Better yet, if you provide setters as well as getters, you can leave
off the @ signs:

class K
attr_accessor :a,:b
end

K-{:a=>1, :b=>2}


This construct breaks encapsulation, so use the capability with
moderation and prudence, please.

An existing object can be rendered into Ron form with a call to
Ron.dump:

Ron.dump([1,2,3]) #=>"[1, 2, 3]"

Ron.load is the inverse operation; it takes a Ron-formatted string and
converts it back to a live Ruby object. (This is just an alias of
eval.):

Ron.load("K-{:@a=>1, :@b=>2}") #=> #<K:@a=2, @b=2>


bugs and limitations
Currently, some types of ruby object cannot be dumped. In some
cases, this is because it is impossible to (correctly) dump those
objects. In others, it's merely difficult. Here are the ones I
think I should eventually be doing, mostly with ParseTree help:

(anonymous) Class and Module
Method
UnboundMethod
Proc

These are very difficult, and I don't see how to approach them
correctly (but it would be very nice...):

Thread
Continuation

These are more or less impossible:

File
Dir
Process
IO

 
Reply With Quote
 
 
 
 
Jonas Pfenniger
Guest
Posts: n/a
 
      10-10-2006
This looks really interesting. So you overloaded the - operator on
classes to achieve the K - {} ?

--
Cheers,
zimbatm

http://zimbatm.oree.ch

 
Reply With Quote
 
 
 
 
Joel VanderWerf
Guest
Posts: n/a
 
      10-10-2006
Caleb Clausen wrote:
> Ron version 0.1.0 has been released!
>
> http://rubyforge.org/projects/ron


How does it compare with amarshal?

http://raa.ruby-lang.org/project/amarshal/

At first glance, the notation

K-{:a=>1, :b=>2}

for a literal instance of K seems new and interesting.

Unfortunately, both the link to Ron (http://rubyforge.org/projects/ron)
and the download for Amarshal seem broken at the moment.

--
vjoel : Joel VanderWerf : path berkeley edu : 510 665 3407

 
Reply With Quote
 
Dr Nic
Guest
Posts: n/a
 
      10-10-2006
> Unfortunately, both the link to Ron (http://rubyforge.org/projects/ron)
> and the download for Amarshal seem broken at the moment.


RF is down @ moment it seems

Nic

--
Posted via http://www.ruby-forum.com/.

 
Reply With Quote
 
Caleb Clausen
Guest
Posts: n/a
 
      10-10-2006
On 10/10/06, Joel VanderWerf <(E-Mail Removed)> wrote:
> How does it compare with amarshal?
>
> http://raa.ruby-lang.org/project/amarshal/


Both are ruby-based serialization packages/languages. Amarshal
generates imperative code, tho, whereas in Ron I've tried to take a
purely declarative approach.
For instance the amarshal representation of [1,2,3] (taken from the website) is:

v = []
v[0] = Array.allocate()
v[0] << 1
v[0] << 2
v[0] << 3
v[0]

In Ron, it's merely: "[1,2,3]". A more interesting example would be a
recursive data structure, say an array containing itself. Here's
amarshal (extrapolating , haven't tried this):

v = []
v[0] = Array.allocate()
v[0] << v[0]
v[0]

Versus Ron:

Recursive(v1_={}, [v1_])


Since this is essentially a declarative problem, my declarative syntax
should be shorter and (hopefully) more readable in most cases.


> At first glance, the notation
>
> K-{:a=>1, :b=>2}
>
> for a literal instance of K seems new and interesting.


Well, thanks. As to Jonas's question about this syntax, yes, it's just
a matter of defining Class#-.

 
Reply With Quote
 
Trans
Guest
Posts: n/a
 
      10-12-2006

Jonas Pfenniger wrote:
> This looks really interesting. So you overloaded the - operator on
> classes to achieve the K - {} ?


I agree, interesting. I would recommend howerver using something other
then '-', b/c there is talk of using that for trait-like extensions to
class/module in future versions of Ruby. '<<' comes to mind a possilble
alternative.

K << { a:1, b:2 }

T.

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
[ANN] Ron 0.1.2 Released Caleb Clausen Ruby 1 01-11-2010 11:58 PM
About Ron Williams..... Network Guru MCSE 11 08-18-2003 03:09 PM
This is ridiculous...I AM THE Ron Williams!! R.J. Williams MCSE 33 08-16-2003 10:15 AM
This is Ludicrous...I AM THE Ron Williams!! R.J. Williams MCSE 2 08-13-2003 09:03 PM
ron's formal apology in the MCSA group licknlabia MCSE 0 08-13-2003 12:04 AM



Advertisments