redparse 0.8.4 → 1.0.0

data/History.txt

@@ -1,3 +1,195 @@
+=== v1.0.0 26oct2011
+* performance improvements:
+  * coalescer:
+    * a new backend, the 'coalescer' is 10x faster and actually works!
+    * canned coalesce output (which takes forever to generate otherwise)
+  * cache:
+    * cached outputs are stored near to the inputs if that's writeable
+    * otherwise, they're in the first writeable directory of:
+      * Etc.getpwuid if any, $HOME if any, root dir
+    * if none are writeable, nothing is cached
+    * defined a parser signature that will change when:
+      * parser source code changes, or
+      * parser type (including modules parser is extended by) changes, or
+      * lexer type changes
+* many improvements to #unparse (which turns Node trees back into ruby code):
+  * slightly tweaked the unparsing of defined? so it'll reparse correctly
+  * in AssignNode#unparse, always put spaces around assign op
+  * only elide spaces right before [ on unparse of BracketsGetNode
+  * unparse of for node should not start with newlines...
+  * speed up unparse_nl when no token provided
+  * 3rd param to unparse_nl (alt) should never be nil
+  * parens and the like and when to omit them from unparse output:
+    * need to call to_s on body of ParenedNode#unparse
+    * emit extra () on unparse in hash and array lits and method call params.
+    * better detection of when to leave out curly braces in hash literal
+    * unparse of MethodNode and CallSiteNode now omits parens if original did
+    * hardcode unparse of NopNode to "()" (was empty string)
+    * NopNode in str inclusion unparses to #{} (was: #{()})
+  * string literal unparsing:
+    * fix unparse of string when delimiter is \r
+    * better detection of backslash (and friends) in strings
+    * for splitting word array or requoting here docs
+  * exception machinery and unparsing:
+    * tolerate missing #rescues in nodes which allow rescue
+    * oops, #unparse was inserting extraneous empty elses
+  * unparsing float literals:
+    * unparse to original string rep of a float literal if available
+      * (to reduce rounding errors)
+    * unparse of -0.0 preserves its sign
+    * more forgiving about parsing floats
+    * better error message on float coercion problem
+* ruby 1.9:
+  * generally improving ability to run under mri 1.9 (fixing warnings, mostly)
+    all the new 1.9 syntax should now work 
+      * notably improvements to -> and .()
+    avoiding warnings about undef'd ivars
+    avoiding duplication in char classes
+  * encoding:
+    * pass encoding on to the lexer
+    * encoding names should always be represented as symbols
+  * 1.9+extensibility:
+    * made @funclikes and @varlikes: ivars instead of constants
+    * @funclikes and @varlikes vary depending on whether in 1.9 mode
+    * -> is now considered a funclike keyword
+    * VALUELIKE_LA converted from a constant to a method
+    * FUNCLIKE_KEYWORD is now a method rather than a constant
+  * 1.9 syntax:
+    * look for block locals in method params only in -> args
+    * -> now has no method params but does have block params (and block locals)
+    * add locals slot for BlockNode
+      * and fill from vars after ; in block params
+    * special rule for -> in 1.9 not needed now (treated like KWCallNode)
+    * new exception in 1.9 for !@ method
+    * improved support for .() type calls in 1.9 mode
+* programmer's interface:
+  * ast creation:
+    * Node.new should optionally allow ivars to be set using named params
+    * on StringNode.[], don't overwrite @modifiers if one is provided
+    * now parser uses LiteralNode.create to create literals
+      * (so client code can use LiteralNode.new)
+    * sugary constructor for ListInNode
+    * make RawOpNode#new arg parsing more robust
+  * ast reading/searching/reflecting:
+    * some utilities for finding nodes in node trees
+    * to_ruby is an alias for unparse in RedParse::Node and descendants
+    * ListInNode should compare == only if both sides are ListInNode
+    * explicit, public accessors for things that were private:
+      * added #body #reversed and #test_first to while and until nodes
+      * make the #string representation of literal nodes publicly accessible
+      * MethodNode#has_parens? now returns whether formal args had parens
+    * new names for things that were already available:
+      * give RescueOpNode an #op method (always returns "rescue")
+      * alias RescueOpNode#right to #rescue_with (for the fallback expression)
+      * alias CallSiteNode#has_parens? to #real_parens
+      * alias RescueNode#name to its varname
+      * alias UnOpNode#arg to #val
+      * alias UnaryOpNode to UnOpNode
+    * changes in structure, shouldn't impact users:
+      * empty parens should make a ParenedNode, not a SequenceNode
+      * NopNode is now a descendant of SequenceNode
+      * created UnAmpNode for unary ampersand
+  * location:
+    * print error location when parse or lex error occurs
+    * line numbers in Node trees are present/correct in more cases
+  * inspect:
+    * Node#inspect now omits some unimportant or duplicate subfields
+    * remove some duplication in pp output
+    * put + in front of ListInNode on inspect... so it looks like other nodes
+    * head of a constant is now inspected correctly if it happened to be a node
+    * make #inspect more robust in the presence of weird labels
+    * use shorter inspect in error string for misparsed nodes
+    * allow Node subclasses to exclude certain ivars from #inspect
+    * leave HashNode's @no_braces undef'd if not set... makes inspect view prettier
+  * misc api:
+    * added RedParse.parse, for parsing without a RedParse object
+    * all RedParse.new options after the 1st can now be omitted
+    * allow cache mode to be given in a env var, if not otherwise specified
+    * always put error messages on stderr!
+    * added stack attr to RedParse to allow access to the stack from outside
+    * created a #pretty_stack method for printing the stack out
+    * use pretty_stack to print stack
+    * display more fields of @input on inspect
+    * RedParse#inspect cleaner, while preserving old functionality via #dump
+    * have RedParse#to_s emit a more accurate image of the actual type
+    * improve RedParse#to_s slightly for faux @lexers
+    * made #rules an alias for #expanded_RULES
+    * rubyversion attr is no longer writable
+* misc
+  * ripper emulation, still pretty raw/incomplete
+  * beginnings of drop-in replacements for 3 other parsers
+  * find stuff in gemspec relative to __FILE__ instead of .
+  * don't need this trashy rakefile anymore
+  * re-enabled the compiler
+  * support octal literals starting with +
+  * make sure there's a #blame in nodes that have #error?   [api,AST]
+  * EXCLUDED_IVARS no longer needs to keep symbol and string forms of each elem
+* command line:
+  * added --coalesce cmdline option to use new 'coalescer' parser compiler
+  * made an option for omitting the output of the parse tree
+  * added --cache cmdline option to control caching
+  * avoid printing initial garbage tokens when --print-tokens enabled
+  * added long names for -7 and -9 flags (version selection)
+  * don't require the compiler unless --compile given on cmdline 
+  * don't print ugly minor node details unless -v set
+* parsetree:
+  * improved compatibility w/ parsetree generally
+  * in HasRescue#parsetree should not modify reciever now
+  * in quirks mode:
+    * always force a :block to wrap #parsetree of begin..end nodes
+      * if the sole expression in the body is an undef
+      * (sigh...improves compatibility with cranky ref impl)
+    * only search for literals to nopify at the start
+      * of a sequence, instead of all but the last element
+  * paren node with no body looks like nil to #parsetree
+  * added several to known parsetree/mri boo-boos
+* tests for ruby 1.9 variant:
+  * disable caching in 1.9 tests
+  * put each 1.9 test case in its own test method
+  * let's do all 1.9 testing in utf-8
+  * expect no sequences except in block bodies
+  * expect no multiassigns except if top-level is an assignment
+  * print code that failed if exception in 1.9 tests
+  * made test for invalid 1.9 expressions
+  * adding test for 1.9 constructs equivalent to other 1.9 constructs
+  * add test case for block locals in .() call
+  * tried to improve parse tree 'blurring' code
+    * (which ignores bs_handler in strings)
+  * include 1_9 in names of 1.9 tests
+* tests:
+  * added extra_summary utility method to Test::Unit,
+    * which can print additional messages when the test is over
+    * used with known ruby bugs, keep a them separate
+    * since those aren't bugs in redparse
+  * cut down on the rate of the differed-by-begin warning
+  * a system of 'interactive' testing
+    * to allow user to confirm whether unparse is valid
+    * when not exactly equal to original
+  * only wank about parse errors if an env var is set
+  * an option to divide tests into multiple processes
+  * oops, error in mangle mode's detection of globals
+  * fixed a couple test cases that needed to have newlines
+  * a buncha new good (=exhibits errors) test data
+  * new wrappers and injectables expand the reach of mangle mode tests
+  * correcting or moving bad test cases
+  * eliminate duplicate tests
+* rules:
+  * simplify operator rule by removing KeywordToken match
+    * but now => has to be parsed separately
+  * herebodytoken delete rule eliminated... now a lexer hack
+  * moved rules for parsing parenthesized expressions down to be lower prec than KWCallNode   [rules]
+  * expand duties of expanded_RULES to wrapping string/regexp matchers in KW()   [rules]
+  * rewrote #lower_op to return a proc   [rules]
+  * cacheing of parse table intermediate structures
+  * @compiled_rules cache not needed anymore
+  * (slightly) improve error handling when no block to item_that
+  * initial stab at DanglingStarNode.create   [rules]
+  * mini version of ruleset, just a few rules, for debugging [rules]
+  * improving readability in a char class
+* moved lexer-specific code into the lexer
+  * __FILE__/__LINE__ value setting 
+  * token linenums determination
+
 === 0.8.4 / 21dec2009
 * 5 Major Enhancements:
   * OpNode and related modules are now classes

data/Makefile

@@ -2,6 +2,15 @@ name=RedParse
 lname=redparse
 gemname=redparse
 
+lib/redparse/ReduceWithsFor_RedParse_1_8.rb: lib/redparse.rb
+	redparse --cache=no -c
+
+lib/redparse/ReduceWithsFor_RedParse_1_9.rb: lib/redparse.rb
+	redparse --cache=no -c '1.9'
+
+parser: lib/redparse/ReduceWithsFor_RedParse_1_8.rb lib/redparse/ReduceWithsFor_RedParse_1_9.rb
+.PHONY: parser
+
 #everything after this line is generic
 
 version=$(shell ruby -r ./lib/$(lname)/version.rb -e "puts $(name)::VERSION")

data/README.txt

@@ -4,31 +4,20 @@
 
 == DESCRIPTION:
 
-RedParse is a ruby parser written in pure ruby. Instead of YACC or 
-ANTLR, it's parse tool is a home-brewed "compiler-interpreter". (The
-tool is LALR(1)-equivalent and the 'parse language' is pretty nice, 
-even in it's current crude form.)
+RedParse is a ruby parser (and parser-compiler) written in pure ruby. 
+Instead of YACC or ANTLR, it's parse tool is a home-brewed language. (The
+tool is (at least) LALR(1)-equivalent and the 'parse language' is 
+pretty nice, even in it's current form.)
 
 My intent is to have a completely correct parser for ruby, in 100% 
-ruby. Currently, RedParse can parse all known ruby 1.8 constructions
-correctly. There might be some problems with unparsing or otherwise 
-working with texts in a character set other than ascii. Some of the
-new ruby 1.9 constructions are supported in 1.9 mode. For more
-details on known problems, see below. 
-
-== REQUIREMENTS:
-* RedParse requires RubyLexer, my hand-coded lexer for ruby. It also 
-  uses Reg, (a pattern-matcher). RubyLexer depends on Sequence, 
-  (external iterators). Reg depends on Sequence's predecessor, Cursor, 
-  altho Cursor isn't used at all in RedParse. The (long-delayed) next 
-  version of Reg will use Sequence. To summarize:
-  *  RedParse 0.8.2 requires RubyLexer>=0.7.4 and Reg>=0.4.7
-  *  RubyLexer 0.7.4 requires Sequence>=0.2.0
-  *  Reg 0.4.7 requires Cursor (not really needed here)
-* All are available as gems. (Or tarballs on rubyforge, if you must.)
+ruby. And I think I've more or less succeeded. Aside from some fairly
+minor quibbles (see below), RedParse can parse all known ruby 1.8 and 1.9 
+constructions correctly. Input text may be encoded in ascii, binary, 
+utf-8, iso-8859-1, and the euc-* family of encodings. Sjis is not yet 
+supported.
 
 == INSTALL:
-* gem install redparse #(if root as necssary)
+* gem install redparse #(as root if necessary)
 
 == LICENSE:
 
@@ -40,8 +29,7 @@ Please see COPYING.LGPL for details.
 * Pure ruby, through and through. No part is written in C, YACC, 
   ANTLR, lisp, assembly, intercal, befunge or any other language
   except ruby.
-* Pretty AST trees (at least, I think so). (To program for, not
-  necessarily to look at.)
+* Pretty AST trees (at least, I think so). 
 * AST trees closely mirror the actual structure of source code.
 * unparser is built in
 * ParseTree format output too, if you want that.
@@ -56,20 +44,20 @@ Please see COPYING.LGPL for details.
   actions (which occupy somewhere under 3100 lines in RedParse). 
   Also, what is a rule? I counted most things which required a 
   separate action in MRI's parser, I'm not sure if that's fair.
-  But in the end, I still think RedParse is still much easier to 
+  On the other hand, RedParse rules require no separate actions 
+  anywhere.In the end, I still think RedParse is still much easier to 
   understand than MRI's parse.y.) 
 * "loosey-goosey" parser happily parses many expressions which normal 
   ruby considers errors.
 
 == Drawbacks:
 
-* Pathetically, ridiculously slow (ok, compiler-compilers are hard...)
-* Error handling is very minimal right now.
+* Slow. Not as bad as it used to be, tho.
+* Error coverage is sketchy at best
 * No warnings at all.
-* Unit test takes a fairly long time.
+* Unit test takes a fairly long time (much better now, tho! down to 15min).
 * Lots of warnings printed during unit test.
 * Debugging parse rules is not straightforward.
-* Incomplete support for ruby 1.9.
 * "loosey-goosey" parser happily parses many expressions which normal 
   ruby considers errors.
 
@@ -248,22 +236,47 @@ existing format in the future, but no incompatibility-creating changes.
  ErrorNode         #mixed in to nodes with a syntax error
  +-MisparsedNode   #mismatched braces or begin..end or the like
 
+== REQUIREMENTS:
+* RedParse requires RubyLexer, my hand-coded lexer for ruby. It also 
+  uses Reg, (a pattern-matcher). RubyLexer depends on Sequence, 
+  (external iterators). Reg depends on Sequence as well. To summarize:
+  *  RedParse 1.0.0 requires RubyLexer 0.8.0 and Reg>=0.4.8
+  *  RubyLexer 0.8.0 requires Sequence>=0.2.4
+  *  Reg 0.4.8 requires Sequence>=0.2.3
+* All are available as gems. (Or tarballs on rubyforge, if you must.)
+
 == Known problems with the parser:
 * Encoding of the input is not stored anywhere in resulting parse tree.
 * Ascii, binary, utf-8, and euc encodings are supported, but sjis is not.
+* offsets of some nodes are incorrect
+* multi-assign nested in multi-assign as receiver of an attribute lhs won't parse right
+* these expressions won't parse:
+  <<x.
+   1111
+  x
+  a0 rescue b0()
+
+  ?\
+  __END__
+  -?
+
+  __END__  #with a comment
+
+  * =f,g rescue b and c
 
 == Known problems with the unparser:
-* On unparse, here documents are converted into regular strings. For the most 
-  part, these are exactly equivalent to the original. However, whatever tokens
-  appeared between the here document header and body will now show up on a 
-  different line. If one of those tokens was __LINE__, it will have a 
-  different value in the unparsed code than it had originally.
-* some floating-point literals don't survive parse/unparse roundtrip intact, 
-  due to bugs in MRI 1.8's Float#to_s/String#to_f.
-* unparsing of trees whose input was in a character set other than ascii may
-  not work.
-
-== Known problems with ParseTree compatibility 
+* Major:
+  * unparsing of trees whose input was in a character set other than ascii may
+    not work.
+* Minor:
+  * On unparse, here documents are converted into regular strings. For the 
+    most part, these are exactly equivalent to the original. However, 
+    whatever tokens appeared between the here document header and body will 
+    now show up on a different line. If one of those tokens was __LINE__, 
+    it will have a different value in the unparsed code than it had 
+    originally.
+
+== Known problems with ParseTree creator
 * Major:
   * converting non-ascii encoded parsetrees to ParseTree format doesn't work
 * Minor:
@@ -273,6 +286,9 @@ existing format in the future, but no incompatibility-creating changes.
     but what I emit is equivalent.
     * %W"is #{"Slim #{2?"W":"S"}"}#{xx}."
   * silly empty case nodes aren't always optimized to nop like in ParseTree.
+  * begin..end blocks nested in other begin..end blocks aren't combined
+  * literal strings,numbers,symbols,etc as their own stmts should be optimized away
+  * BEGIN expressions not in their own statement may not be treated right
 
 == Bugs in ruby
 * These expressions don't parse the same as in MRI because of bug(s) in MRI:
@@ -291,3 +307,20 @@ existing format in the future, but no incompatibility-creating changes.
 * def sum(options = {:weights => weights = Hash.new(1)}); opt; end
 * def foo(a = 1)    end; def foo(a=b=c={})  end; def bar(a=b=c=1,d=2)  end
 * yield [a_i, *p] 
+
+== Copyright
+    redparse - a ruby parser written in ruby
+    Copyright (C) 2008,2009, 2012, 2016  Caleb Clausen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/bin/redparse

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 =begin           
     redparse - a ruby parser written in ruby
-    Copyright (C) 2008  Caleb Clausen
+    Copyright (C) 2008, 2012, 2016  Caleb Clausen
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
@@ -96,27 +96,71 @@ while /^-/===ARGV.first
       when "--pp"; output=:pp
       when "--lisp"; output=:lisp
       when "--parsetree"; output=:parsetree
+      when "--ripper"; output=:ripper; ruby19=true
+      when "--no-parsetree"; output=:no_parsetree
       when "--vsparsetree"; output=:vsparsetree
       when "--vsparsetree2"; output=:vsparsetree2
+      when "--vsripper"; output=:vsripper; ruby19=true
+      when "--vsripper2"; output=:vsripper2; ruby19=true
       when "--update-problemfiles"; problemfiles=ProblemFiles.new
       when "--ignore-silly-begins"; ignorebegins=true
-      when "--tokens"; ENV['PRINT_TOKENS']='1'
-      when "--rawtokens"; ENV['RAW_PRINT_TOKENS']='1'
-      when "--stack"; ENV['PRINT_STACK']='1'
+      when "--tokens"; tokens=ENV['PRINT_TOKENS']='1'
+      when "--rawtokens"; rawtokens=ENV['RAW_PRINT_TOKENS']='1'
+      when "--stack"; stack=ENV['PRINT_STACK']='1'
       when "--unparse"; unparse=true
-      when "--compile", "-c"; compile=true
-      when "--macros", "--macro", "-m";
+      when /^(?:--output|-o)=?(.*)$/
+        outputf=($1.size>0 ? $1 : (/^[^-]/===ARGV.first && ARGV.shift ))
+      when /^(?:--require|-r)=?(.*)$/
+        reqs||=[]
+        reqs<<($1.size>0 ? $1 : (/^[^-]/===ARGV.first && ARGV.shift ))
+      when /^(?:--coalesce|-c)=?(.*)$/; 
+        coalesce=true
+        variant=($1.size>0 ? $1 : (/^[^-]/===ARGV.first && ARGV.shift or ''))
+      when "--compile"; require 'redparse/compile'; compile=true
+      when "--macros", "--macro", "-m"
         require 'rubygems'
         require 'macro'
         parserclass=Macro::RedParseWithMacros
+      when /^--cache(?:=(.*))?$/
+        cache_mode=
+        case mode=$1||ARGV.shift
+        when 'r','ro'; :read_only
+        when 'w','wo'; :write_only
+        when 'rw'; :read_write #default
+        when 'n','no','none'; :none
+        else mode.to_sym
+        end 
       when "-q"; quiet=true
       when "-v"; verbose=true
       when "-e"; inputs=[ARGV.join(" ")]; names=["-e"]; break
-      when "-7"; ruby187=true
-      when "-9"; ruby19=true
+      when "-7", "--1.8.7"; ruby187=true
+      when "-9", "--1.9"; ruby19=true
       else fail "unknown option: #{opt}"
     end
 end
+
+if coalesce
+  variant=variant.split(' ')
+
+  if reqs
+    $:.push '.'
+      reqs.each{|req| require req }
+    $:.delete '.'
+  end
+  versions,modules=variant.partition{|v| /^\d/===v }
+  modules.map!{|m| RedParse.const_get m }
+  fail if versions.size>1
+  version=versions.first||(ruby19 ? 1.9 : 1.8)
+  version=version.to_f
+  classes=modules.grep Class
+  modules-=classes
+  assert classes.size<=1
+  k=classes.first||RedParse
+  rp=k.new("",:rubyversion=>version,:cache_mode=>:none)
+  modules.each{|m| rp.extend m }
+  rp.write_reduce_withs outputf
+  exit
+end
   
 unless inputs
     if ARGV.empty?
@@ -142,6 +186,8 @@ inputs.each_index{|i|
     input=inputs[i] or next
     name=names[i]
 
+    orig_input=input
+
     if /\A=begin\s/===input
       #combine 1st 2 lines of input
       if /\A(=begin(.*)\n=end\s(.*))\n/===input
@@ -164,11 +210,22 @@ inputs.each_index{|i|
         else
           options={:rubyversion=>1.8}
         end
+        options[:cache_mode]=cache_mode if cache_mode
+        parser=(parserclass||RedParse).new(input,name,1,[],options)
+        seen_ends=0
+        parser.print_filter=proc{|t| 
+          if RedParse::KeywordToken===t and /^(\}|end)$/===t.ident
+            seen_ends+=1
+            seen_ends>=3
+          else
+            seen_ends>=2
+          end
+        }
         tree=if compile
-          huh (parserclass||RedParse).new(input,name,1,[],options).compile
+          huh parser.compile
           huh parse
         else
-          (parserclass||RedParse).new(input,name,1,[],options).parse
+          parser.parse
         end
         nil
       } #raise NeverExecThis
@@ -198,16 +255,53 @@ inputs.each_index{|i|
       require 'pp'
       pp tree
     when :p
-      p tree
+      puts tree.inspect(nil,0,verbose)
     when :lisp
       puts tree.to_lisp
     when :parsetree
       tree=tree.to_parsetree
       hack=tree.dup
-      p hack
-      hack.first[1..2]=[]  #get rid of BEGIN blocks inserted into beginning of input
-      hack=if hack.first.size<=2; hack.first[1] else hack end
+      #p hack
+=begin
+        hack.first[1..2]=[]  #get rid of BEGIN blocks inserted into beginning of input
+        hack=if hack.first.size<=2; hack.first[1] else hack end
+      rescue Exception
+=end
       pp(hack||[])
+    when :vsripper,:vsripper2,:ripper
+      warn "disabling positioning info in ripper emulation output for now"
+      begin
+        require 'ripper'
+        require 'ripper/sexp'
+        class ::Ripper::SexpBuilder
+          def column; 0; end
+          def lineno; 0; end
+        end
+      rescue LoadError
+      end
+      require 'redparse/ripper'
+      require 'redparse/ripper_sexp'
+      RedParse::Ripper.instrumentSexpBuilder(::Ripper::SexpBuilder)if verbose and defined? ::Ripper
+      RedParse::Ripper.instrumentSexpBuilder(::Ripper::SexpBuilderPP)if verbose and defined? ::Ripper
+      RedParse::Ripper.instrumentSexpBuilder(::RedParse::Ripper::SexpBuilder)if verbose
+      RedParse::Ripper.instrumentSexpBuilder(::RedParse::Ripper::SexpBuilderPP)if verbose
+      rip=Ripper.sexp_raw(orig_input,name) if output!=:ripper and defined? ::Ripper
+      rp=RedParse::Ripper::SexpBuilder.new(input,name)
+      rp.parser=tree
+      begin
+        rp= rp.parse :quirks=>true
+      rescue Exception=>e
+        warn e.backtrace.unshift(e.inspect).join("\n  ")
+        rp=[:failed]
+      end
+      if rip and rip==rp
+        puts "no differences"
+      else
+        puts "mine:"
+        pp rp
+        puts "minero's:"
+        pp rip
+      end
     when :vsparsetree,:vsparsetree2
       begin
       require 'rubygems'