Thanks to Luis Lavena, ParseTree now has gems precompiled for windows! This makes things like ruby2ruby, heckle, and much more that much more accessible to the OS-challenged!
Recently in ParseTree Category
ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.
As an example:
def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end
becomes:
[:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]
- Uses RubyInline, so it just drops in.
- Includes SexpProcessor and CompositeSexpProcessor.
- Allows you to write very clean filters.
- Includes UnifiedRuby, allowing you to automatically rewrite ruby quirks.
- ParseTree#parsetreefor_string lets you parse arbitrary strings of ruby.
- Includes parsetreeshow, which lets you quickly snoop code.
- echo "1+1" | parsetreeshow -f for quick snippet output.
- Includes parsetreeabc, which lets you get abc metrics on code.
- abc metrics = numbers of assignments, branches, and calls.
- whitespace independent metric for method complexity.
- Includes parsetreedeps, which shows you basic class level dependencies.
- Does not work on the core classes, as they are not ruby (yet).
Changes:
2.1.1 / 2007-12-22
1 bug fix:
- sigh apparently I've been running w/o all my anal compiler flags on.
ruby_parser (RP) is a ruby parser written in pure ruby (utilizing racc--which does by default use a C extension). RP's output is the same as ParseTree's output: s-expressions using ruby's arrays and base types.
FEATURES/PROBLEMS:
- Pure ruby, no compiles.
- Incredibly simple interface.
- Output is 100% equivalent to ParseTree.
- Can utilize PT's SexpProcessor and UnifiedRuby for language processing.
- Known Issue: Speed sucks currently. 5500 tests currently run in 21 min.
- Known Issue: Code is waaay ugly. Port of a port. Not my fault. Will fix RSN.
- Known Issue: I don't currently support newline nodes.
- Known Issue: Totally awesome.
- Known Issue: dasgn_curr decls can be out of order from ParseTree's.
- TODO: Add comment nodes.
SYNOPSIS:
RubyParser.new.parse "1+1"
# => s(:call, s(:lit, 1), :+, s(:array, s(:lit, 1)))
Changes:
1.0.0 / 2007-12-20
1 major enhancement
- Birthday!
ruby2ruby provides a means of generating pure ruby code easily from ParseTree's Sexps. This makes making dynamic language processors much easier in ruby than ever before.
Changes:
1.1.8 / 2007-08-21
6 minor enhancements:
- Added super awesome .autotest file. YAY!
- Removed nil.method_missing... too many ppl bitching about it.
- Renamed RubyToRuby (the class name) to Ruby2Ruby.
- Restructured self-translation tests so they were friendlier when dying.
- Strings are now always one line long only.
- Fully in sync with ParseTree and ruby_parser.
2 bug fixes:
- Fixed a number of issues/bugs discovered via ruby_parser.
- Cleaned out some dead code and hacks we don't need anymore.
- http://rubyforge.org/projects/seattlerb
ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.
As an example:
def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end
becomes:
[:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]
- Uses RubyInline, so it just drops in.
- Includes SexpProcessor and CompositeSexpProcessor.
- Allows you to write very clean filters.
- Includes UnifiedRuby, allowing you to automatically rewrite ruby quirks.
- ParseTree#parsetreefor_string lets you parse arbitrary strings of ruby.
- Includes parsetreeshow, which lets you quickly snoop code.
- echo "1+1" | parsetreeshow -f for quick snippet output.
- Includes parsetreeabc, which lets you get abc metrics on code.
- abc metrics = numbers of assignments, branches, and calls.
- whitespace independent metric for method complexity.
- Includes parsetreedeps, which shows you basic class level dependencies.
- Does not work on the core classes, as they are not ruby (yet).
Changes:
13 minor enhancements:
- Added (partial) regexp flag support, currently numerical. ugh.
- Added -a flag to parsetreeshow to turn on newline (all) nodes.
- Added -r to parsetreeshow for raw arrays instead of sexps.
- Added Unifier (SexpProcessor) class to unified_ruby.rb.
- Added a ton of tests while working on ruby_parser.
- Added ability to tell proc {} (nil arg slot) from proc {||} (0 arg slot)
- Added context tracking to rewriting phase... slightly broken.
- Added evstr support. (I hate evan)
- Added usage for parsetreeshow.
- Changed verbose to be true all the time in parsetreefor_string.
- Removed process_level from SexpProcessor... just look at context size instead.
- Revamped ParseTree. No more passing around newline. Pass around self instead.
- I'm starting to dislike ruby's AST. It is REALLY inconsistent.
6 bug fix:
- SexpProcessor#assert_type now a bit safer with bad values.
- Uncovered a bug in ruby (AST changes when -v used), added handler code.
- Fixed NODE_BLOCK and massively simplified in the process.
- Fixed rewrite_defs to deal with non-block asts.
- Fixed test/unit hack so it does not die under miniunit.
- Found a bug in PT where parsetreefor_string had some shadowed variables.
I'm currently on a plane flying home from the bay area. I just spent the last two days participating in the latest rubinius sprint. (I had to go hem early to teach my ruby class).
So, we got the go ahead/mandate to drop the secrecy. Eric Hodel and I are joining Evan Phoenix at Engine Yard to work on rubinius. This is just about the most bad-ass job I could possibly get (my dreams of becoming an astronaut long-dashed against the rocks of horrible vision and only marginally better grades).
I'm only just digging in. Last night I made some changes to autotest that will make it possible to be used with mspec (rubinius' mini version of rspec). This should help accelerate development.
I'm also feverishly working on a new ruby parser written in pure ruby (+ racc) that outputs the same as ParseTree. I'm 99% done (measuring against my tests + dynamic tests generated from stdlib+all my rubygems). I hope to have a release soon. It does have a long way to go after correctness has been addressed. Namely, it is a port of a port and could use a lot of clean-up esp now that we have the true power of ruby behind it.
Anyhow. I'm terribly excited by this. I can't wait to see where we go next.
Ruby Inline is an analog to Perl's Inline::C. Out of the box, it allows you to embed C/++ external module code in your ruby script directly. By writing simple builder classes, you can teach how to cope with new languages (fortran, perl, whatever). The code is compiled and run on the fly when needed.
Changes:
3.6.5 / 2007-11-08
1 minor enhancement:
- Quick fix for OSX 10.5 native ruby (should be fixed in 10.5.2).
- http://www.zenspider.com/ZSS/Products/RubyInline/
ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.
As an example:
def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end
becomes:
[:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]
- Uses RubyInline, so it just drops in.
- Includes SexpProcessor and CompositeSexpProcessor.
- Allows you to write very clean filters.
- Includes UnifiedRuby, allowing you to automatically rewrite ruby quirks.
- ParseTree#parsetreefor_string lets you parse arbitrary strings of ruby.
- Includes parsetreeshow, which lets you quickly snoop code.
- echo "1+1" | parsetreeshow -f for quick snippet output.
- Includes parsetreeabc, which lets you get abc metrics on code.
- abc metrics = numbers of assignments, branches, and calls.
- whitespace independent metric for method complexity.
- Includes parsetreedeps, which shows you basic class level dependencies.
- Does not work on the core classes, as they are not ruby (yet).
Changes:
2 minor enhancements:
- Deactivated gcc-specific compiler flags unless ENV['ANAL'] or on my domain.
- Minor code cleanup - happier with -pedantic and the like.
1 bug fix:
- FINALLY conquered the splat args bug on certain platforms/versions. Special Thanks to Jonas Pfenniger for debugging this and providing a patch.
ruby2ruby provides a means of generating pure ruby code easily from ParseTree's Sexps. This makes making dynamic language processors much easier in ruby than ever before.
Changes:
1.1.7 / 2007-08-21
- 2 major enhancements:
- Switched to ParseTree's UnifiedRuby... much much cleaner now!
- Made test_ruby2ruby MUCH more rigorous with circular testing.
- 5 minor enhancements:
- Add r2rshow command like parsetreeshow.
- Add parens for :block nodes as appropriate. May be overzealous.
- Make SexpAny work with #==.
- Removed calls to processorstack / caller in favor of self.context.
- Some style differences, eschew rescue.
6 bug fixes:
- Fix R2R bug with masgn/argscat.
- Fixed a bug with new resbody unification.
- Fixes for changes to pt_testcase.
- Fixes the rest of the tests under strict sexp checking.
- Fixed some circular bugs, mostly by hacking them out, wrt operator precidence.
- Fixed trinary operator.
- http://rubyforge.org/projects/seattlerb
ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.
As an example:
def conditional1(arg1)
if arg1 == 0 then
return 1
end
return 0
end
becomes:
[:defn,
:conditional1,
[:scope,
[:block,
[:args, :arg1],
[:if,
[:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]],
[:return, [:lit, 1]],
nil],
[:return, [:lit, 0]]]]]
- Uses RubyInline, so it just drops in.
- Includes SexpProcessor and CompositeSexpProcessor.
- Allows you to write very clean filters.
- Includes UnifiedRuby, allowing you to automatically rewrite ruby quirks.
- ParseTree#parsetreefor_string lets you parse arbitrary strings of ruby.
- Includes parsetreeshow, which lets you quickly snoop code.
- echo "1+1" | parsetreeshow -f for quick snippet output.
- Includes parsetreeabc, which lets you get abc metrics on code.
- abc metrics = numbers of assignments, branches, and calls.
- whitespace independent metric for method complexity.
- Includes parsetreedeps, which shows you basic class level dependencies.
- Does not work on the core classes, as they are not ruby (yet).
Changes:
1 major enhancement:
- Rewrote parsetreeshow to use parsetreefor_string.
- parsetreeshow adds -n=node filtering -u unifying, and -s structure-only.
- parsetreeshow no longer needs -f
4 minor enhancements:
- Added context stack to SexpProcessor! YAY!!!
- Enforce type to be symbol in SexpProcessor... just makes life easier.
- Processing style change mode to UnifiedRuby. Prefer no rescues.
- Sexp#structure is no longer destructive.
4 bug fixes:
- Added 1.8.4 compatibility fix.
- Added args lifting in :defs in UnifiedRuby.
- Fixed unifying argscat, splat, and a couple other oddities.
- Added process_call to UnifiedRuby sigh I'm a tard.
