virtual_keywords 0.1.0 → 0.3.0

data/lib/parsetree/test/test_parse_tree_extensions.rb

@@ -0,0 +1,107 @@
+require 'minitest/autorun'
+require 'parse_tree'
+require 'parse_tree_extensions'
+require 'tmpdir'
+
+$: << "../../ruby2ruby/1.3.1/lib" # unoffical dependency - user responsibility
+require 'ruby2ruby'
+
+class R2RTestCase < MiniTest::Unit::TestCase
+  def test_proc_to_ruby
+    util_setup_inline
+    block = proc { puts "something" }
+    assert_equal 'proc { puts("something") }', block.to_ruby
+  end
+
+  # TODO: bus error
+#   def test_proc_to_ruby_args_0
+#     util_setup_inline
+#     block = proc { || puts 42 }
+#     assert_equal 'proc { || puts(42) }', block.to_ruby
+#   end
+
+  def test_proc_to_ruby_args_1
+    util_setup_inline
+    block = proc { |x| puts x }
+    assert_equal 'proc { |x| puts(x) }', block.to_ruby
+  end
+
+  def test_proc_to_ruby_args_n
+    util_setup_inline
+    block = proc { |x| puts x }
+    assert_equal 'proc { |x| puts(x) }', block.to_ruby
+  end
+
+  def test_proc_to_sexp
+    util_setup_inline
+    p = proc { 1 + 1 }
+    s = s(:iter,
+          s(:call, nil, :proc, s(:arglist)),
+          nil,
+          s(:call, s(:lit, 1), :+, s(:arglist, s(:lit, 1))))
+    assert_equal s, p.to_sexp
+  end
+
+  # TODO: bus error
+#   def test_proc_to_sexp_args_0
+#     util_setup_inline
+#     p = proc { || 1 + 1 }
+#     s = s(:iter,
+#           s(:call, nil, :proc, s(:arglist)),
+#           nil,
+#           s(:call, s(:lit, 1), :+, s(:arglist, s(:lit, 1))))
+#     assert_equal s, p.to_sexp
+#   end
+
+  def test_proc_to_sexp_args_1
+    util_setup_inline
+    p = proc {|x| puts x }
+    s = s(:iter,
+          s(:call, nil, :proc, s(:arglist)),
+          s(:lasgn, :x),
+          s(:call, nil, :puts, s(:arglist, s(:lvar, :x))))
+
+    assert_equal s, p.to_sexp
+  end
+
+  def test_proc_to_sexp_args_n
+    util_setup_inline
+    p = proc {|x, y| puts x + y }
+    s = s(:iter,
+          s(:call, nil, :proc, s(:arglist)),
+          s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
+          s(:call, nil, :puts,
+            s(:arglist, s(:call, s(:lvar, :x), :+, s(:arglist, s(:lvar, :y))))))
+
+    assert_equal s, p.to_sexp
+  end
+
+  def test_parse_tree_for_proc # TODO: move?
+    p = proc {|a, b, c|}
+    s = s(:iter,
+          s(:call, nil, :proc, s(:arglist)),
+          s(:masgn, s(:array, s(:lasgn, :a), s(:lasgn, :b), s(:lasgn, :c))))
+
+    pt = ParseTree.new(false)
+    u = Unifier.new
+    sexp = pt.parse_tree_for_proc p
+
+    sexp = u.process(sexp)
+
+    assert_equal s, sexp
+  end
+
+  def test_unbound_method_to_ruby
+    util_setup_inline
+    r = "proc { ||\n  util_setup_inline\n  p = proc { (1 + 1) }\n  s = s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:call, s(:lit, 1), :+, s(:arglist, s(:lit, 1))))\n  assert_equal(s, p.to_sexp)\n}"
+    m = self.class.instance_method(:test_proc_to_sexp)
+
+    assert_equal r, m.to_ruby
+  end
+
+  def util_setup_inline
+    @rootdir = File.join(Dir.tmpdir, "test_ruby_to_ruby.#{$$}")
+    Dir.mkdir @rootdir, 0700 unless test ?d, @rootdir
+    ENV['INLINEDIR'] = @rootdir
+  end
+end

data/lib/parsetree/test/test_unified_ruby.rb

@@ -0,0 +1,57 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+require 'minitest/autorun' if $0 == __FILE__ unless defined? $ZENTEST and $ZENTEST
+require 'test/unit/testcase'
+require 'sexp'
+require 'sexp_processor'
+require 'unified_ruby'
+
+class TestUnifier < MiniTest::Unit::TestCase
+  def test_pre_fcall
+    u = PreUnifier.new
+
+    input  = [:fcall, :block_given?]
+    expect = s(:fcall, :block_given?, s(:arglist))
+
+    assert_equal expect, u.process(input)
+
+    input  = [:fcall, :m, [:array, [:lit, 42]]]
+    expect = s(:fcall, :m, s(:arglist, s(:lit, 42)))
+
+    assert_equal expect, u.process(input)
+  end
+
+  def test_pre_call
+    u = PreUnifier.new
+
+    input  = [:call, [:self], :method]
+    expect = s(:call, s(:self), :method, s(:arglist))
+
+    assert_equal expect, u.process(input)
+
+    input  = [:fcall, :m, [:array, [:lit, 42]]]
+    expect = s(:fcall, :m, s(:arglist, s(:lit, 42)))
+
+    assert_equal expect, u.process(input)
+  end
+
+  def test_process_bmethod
+    u = Unifier.new
+
+    raw = [:defn, :myproc3,
+           [:bmethod,
+            [:masgn, [:array,
+                      [:dasgn_curr, :a],
+                      [:dasgn_curr, :b],
+                      [:dasgn_curr, :c]],
+             nil, nil]]]
+
+    s = s(:defn, :myproc3,
+          s(:args, :a, :b, :c),
+          s(:scope, s(:block)))
+
+    assert_equal s, u.process(raw)
+  end
+end

data/lib/parsetree/validate.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+# set -xv
+
+trap "exit 1" 1 2 3 15
+
+DIRS="-I../../metaruby/dev/tests/builtin -I../../metaruby/dev/tests -Ilib"
+for d in $(ls -d ../../*/dev); do
+    DIRS="-I$d $DIRS"
+done
+
+if [ -f rb.bad.txt ]; then
+    mv rb.bad.txt rb.files.txt
+else
+    find ../../*/dev /usr/local/lib/ruby/1.8/ -name \*.rb > rb.files.txt
+fi
+
+total_count=$(wc -l rb.files.txt | awk '{print $1}')
+curr_count=0
+for f in $(cat rb.files.txt); do
+    curr_count=$(($curr_count + 1))
+    if GEM_SKIP=ParseTree ruby $DIRS ./bin/parse_tree_show -q $f > /dev/null 2> rb.err.txt < /dev/null; then
+	echo $f >> rb.good.txt
+	status=pass
+    else
+	echo $f >> rb.bad.txt	
+	status=fail
+    fi
+    fname=`basename $f`
+    printf "%4d/%4d: %s %s\n" $curr_count $total_count $status $fname
+done

data/lib/sexps/sexps_not.rb

@@ -0,0 +1,24 @@
+# Before
+s(:defn, :negate,
+  s(:scope,
+    s(:block, s(:args),
+      s(:not, s(:ivar, :@value))
+    )
+  )
+)
+
+# After
+s(:defn, :negate_result,
+  s(:scope,
+    s(:block, s(:args),
+      s(:fcall, :my_not,
+        s(:array,
+          s(:iter,
+            s(:fcall, :lambda), nil,
+            s(:ivar, :@value)
+          )
+        )
+      )
+    )
+  )
+)

data/lib/sexps/sexps_until.rb

@@ -0,0 +1,60 @@
+# Before
+s(:defn, :until_count_to_value,
+  s(:scope,
+    s(:block, s(:args),
+      s(:until,
+        # Condition
+        s(:call, s(:ivar, :@i), :>,
+          s(:array, s(:ivar, :@value))
+        ),
+        # Body
+        s(:block,
+          s(:call, s(:ivar, :@counts), :<<,
+            s(:array, s(:ivar, :@i))
+          ),
+          s(:iasgn, :@i,
+            s(:call, s(:ivar, :@i), :+,
+              s(:array, s(:lit, 1))
+            )
+          )
+        ),
+        # TODO Again, I'm not sure what this true is for
+        true
+      ),
+      s(:ivar, :@counts)
+    )
+  )
+)
+
+# After
+s(:defn, :until_result,
+  s(:scope,
+    s(:block, s(:args),
+      s(:fcall, :my_until,
+        s(:array,
+          s(:iter,
+            s(:fcall, :lambda), nil,
+            # Condition
+            s(:call, s(:ivar, :@i), :>,
+              s(:array, s(:ivar, :@value))
+            )
+          ),
+          s(:iter,
+            s(:fcall, :lambda), nil,
+            # Body
+            s(:block,
+              s(:call, s(:ivar, :@counts), :<<,
+                s(:array, s(:ivar, :@i))
+              ),
+              s(:iasgn, :@i,
+                s(:call, s(:ivar, :@i), :+,
+                  s(:array, s(:lit, 1)))
+              )
+            )
+          )
+        )
+      ),
+      s(:ivar, :@counts)
+    )
+  )
+)

data/lib/spec/class_reflection_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe 'ClassReflection' do
+  before :each do
+    class MyClass
+      def foo
+        :hello
+      end
+    end
+    @object = MyClass.new
+    @object2 = MyClass.new
+
+    @reflection = VirtualKeywords::ClassReflection.new
+  end
+
+  it 'retrieves the instance methods of a class' do
+    method_names = @reflection.instance_methods_of(Fizzbuzzer).keys
+    method_names.should include :fizzbuzz
+  end
+
+  it 'finds the subclasses of classes and flattens the result' do
+    rails_classes = [ActiveRecord::Base, ApplicationController]
+    subclasses = @reflection.subclasses_of_classes rails_classes
+
+    subclasses.should include Fizzbuzzer
+    subclasses.should include Greeter
+  end
+
+  it 'installs methods on classes' do
+    @reflection.install_method_on_class(MyClass, 'def foo; :goodbye; end')
+    @object.foo.should eql :goodbye
+  end
+
+  it 'installs methods that change instance fields' do
+    class MyClass
+      def foo
+        :hello
+      end
+    end
+    @reflection.install_method_on_class(
+        MyClass, 'def foo; @bar = :bar; :goodbye; end')
+    @reflection.install_method_on_class(
+        MyClass, 'def bar; @bar; end')
+
+    @object.foo.should eql :goodbye
+    @object.bar.should eql :bar
+  end
+
+  it 'installs methods that mutate globals' do
+    $thing = :old
+    @reflection.install_method_on_class(
+        MyClass, 'def foo; $thing = :new; end')
+    
+    @object.foo
+    $thing.should eql :new
+  end
+
+  it 'installs methods on specific instances' do
+    @reflection.install_method_on_instance(
+        @object, 'def foo; :goodbye; end')
+    @object.foo.should eql :goodbye
+    @object2.foo.should eql :hello
+  end
+end

data/lib/spec/keyword_rewriter_spec.rb

@@ -2,60 +2,13 @@ require 'spec_helper'
 
 describe 'KeywordRewriter' do
   before :each do
-    #@while_count_sexp = method_to_sexp(WhileUser, :while_count_to_value)
-    #@while_result_sexp = method_to_sexp(WhileUser, :while_result)
+    #@not = method_to_sexp(NotUser, :negate)
+    #@not_result = method_to_sexp(NotUser, :negate_result)
   end
 
-  # These two "specs" produce sexps that I used to figure out how
-  # to do the rewrite. Their outputs are in sexps_greet.txt and
-  # count_to_ten_sexp.txt
-  
-  #it 'compares sexps of manually translated if' do
-    #puts 'before translation'
-    #p @greet_if_else_sexp
-    #puts ''
-
-    #puts 'after translation'
-    #p @greet_changed_sexp
-    #puts ''
-  #end
-
-  #it 'turns a method with block code into a sexp' do
-    #count_sexp = method_to_sexp(Greeter, :count_to_ten)
-    #p count_sexp
-  #end
-  
-  # Spec used to see how "and" should be translated
-  #it 'compares sexps of manually translated and' do
-    #puts 'before'
-    #p @method_with_and_sexp
-    #puts ''
-
-    #puts 'after'
-    #p @method_with_and_result_sexp
-    #puts ''
-  #end
-  
-  # Spec used to see how && should be translated
-  # Looks like it uses :and same as the other one
-  # Aren't they different semantically though?
-  #it 'compares sexps of manually translated &&' do
-    #puts 'before'
-    #p @symbolic_and_sexp
-    #puts ''
-
-    #puts 'after'
-    #p @symbolic_and_result_sexp
-    #puts ''
-  #end
-
-  #it 'turns a case-when into a sexp' do
-    #p @describe_value_sexp  
-  #end
- 
-  #it 'turns a while into a sexp' do
-    #p @while_count_sexp
-    #puts ''
-    #p @while_result_sexp
-  #end
+  it 'turns a not into a sexp' do
+    #p @not    
+    #puts ""
+    #p @not_result
+  end  
 end

data/lib/spec/not_rewriter_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'NotRewriter' do
+  include TrackNots, DoRewrite
+
+  before :each do
+    @not_user = NotUser.new true  
+    @methods = sexpify_instance_methods NotUser
+    @not_rewriter = VirtualKeywords::NotRewriter.new
+
+    @my_not_calls = 0
+
+    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
+        @not_user, :not, my_not)
+  end
+
+  def rewriters
+    [@not_rewriter]
+  end
+
+  it 'rewrites "not" expressions' do
+    do_rewrite(:negate, @not_user)
+    @my_not_calls.should eql 1
+  end
+end

data/lib/spec/parser_strategy_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe 'ParseTreeStrategy' do
+  before :each do
+    @parse_tree = double 'ParseTree'
+    @sexp_processor = double 'SexpProcessor'
+
+    @strategy = VirtualKeywords::ParseTreeStrategy.new(
+        @parse_tree, @sexp_processor)
+  end
+
+  it 'runs the ParseTree parser, then converts the result into a sexp' do
+    klass = :foo
+    method_name = :bar
+    parse_result = :parsed
+    result = :sexp
+    @parse_tree.should_receive(:translate).with(klass, method_name).
+        and_return parse_result
+    @sexp_processor.should_receive(:process).with(parse_result).
+        and_return result
+    @strategy.translate_instance_method(klass, method_name).should eql result
+  end
+end

data/lib/spec/sexp_stringifier_spec.rb

@@ -0,0 +1,19 @@
+describe 'SexpStringifier' do
+  before :each do
+    @stub_unifier = double 'Unifier'
+    @stub_ruby2ruby = double 'Ruby2Ruby'
+    @stringifier = VirtualKeywords::SexpStringifier.new(
+        @stub_unifier, @stub_ruby2ruby)
+  end
+
+  it 'stringifies sexps using unifier and ruby2ruby' do
+    sexp = :fake_sexp
+    unifier_result = :unified
+    final_result = :final
+    @stub_unifier.should_receive(:process).with(sexp).
+        and_return unifier_result
+    @stub_ruby2ruby.should_receive(:process).with(unifier_result).
+        and_return final_result
+    @stringifier.stringify(sexp).should eql final_result
+  end
+end