virtual_keywords 0.0.0 → 0.1.0

data/lib/sexps/sexps_case_when.txt

@@ -0,0 +1,34 @@
+# Before translation
+# Ok, so each s(:when) has 2 elements: the condition and the consequence
+# They're not wrapped in an array or anything, so this is a lot more
+# complicated...
+s(:defn, :describe_value,
+  s(:scope,
+    s(:block, s(:args),
+      s(:case, s(:ivar, :@value),
+        s(:when,
+          s(:array, s(:lit, 1)),
+          s(:lit, :one)
+        ),
+        s(:when,
+          s(:array, s(:lit, 3..5)),
+          s(:lit, :three_to_five)
+        ),
+        s(:when,
+          s(:array, s(:lit, 7), s(:lit, 9)),
+          s(:lit, :seven_or_nine)
+        ),
+        s(:when,
+          s(:array,
+            s(:call,
+              s(:call, s(:vcall, :value), :*, s(:array, s(:lit, 10))),
+              :<, s(:array, s(:lit, 90))
+            )
+          ),
+          s(:lit, :passes_multiplication_test)
+        ),
+        s(:lit, :something_else)
+      )
+    )
+  )
+)

data/lib/sexps/sexps_while.txt

@@ -0,0 +1,65 @@
+# Structure of a while
+# So the first element is the condition, and the second is the body, wrapped
+# in a :block (TODO and then a "true", what is it for?)
+s(:defn, :while_count_to_value,
+  s(:scope,
+    s(:block, s(:args),
+      s(:while,
+        # The condition
+        s(:call, s(:ivar, :@i), :<,
+          s(:array, s(:vcall, :value))
+        ),
+        # End condition
+        # The 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))
+            )
+          )
+        ),
+        # End body
+        true
+      )
+    )
+  )
+)
+
+# After
+s(:defn, :while_result,
+  s(:scope,
+    s(:block, s(:args),
+      s(:fcall, :my_while,
+        s(:array,
+          s(:iter,
+            s(:fcall, :lambda), nil,
+            # The condition
+            s(:call, s(:ivar, :@i), :<,
+              s(:array, s(:vcall, :value))
+            )
+            # End condition
+          ),
+          s(:iter,
+            s(:fcall, :lambda), nil,
+            # The 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))
+                )
+              )
+            )
+            # End body
+          )
+        )
+      )
+    )
+  )
+)
+

data/lib/spec/and_rewriter_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe 'AndRewriter' do
+  include TrackIfs, TrackAnds, DoRewrite
+
+  before :each do
+    @and_user = AndUser.new false
+    @methods = sexpify_instance_methods AndUser
+    @if_rewriter = VirtualKeywords::IfRewriter.new
+    @and_rewriter = VirtualKeywords::AndRewriter.new
+
+    @my_and_calls = 0
+    @my_if_calls = 0
+
+    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
+        @and_user, :and, my_and)
+    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
+        @and_user, :if, my_if)
+  end
+
+  def rewriters
+    [@if_rewriter, @and_rewriter]
+  end
+
+  it 'rewrites "and" statements' do
+    do_rewrite(:method_with_and, @and_user)
+    @my_and_calls.should eql 1
+  end
+
+  it 'handles ifs with "and"s in the predicate' do
+    do_rewrite(:if_with_and, @and_user)
+    @my_and_calls.should eql 1
+    @my_if_calls.should eql 1
+  end
+end
+
+describe 'AndRewriter on &&' do
+  include TrackAnds, DoRewrite
+
+  before :each do
+    @operator_user = OperatorUser.new false
+    @methods = sexpify_instance_methods OperatorUser
+    @and_rewriter = VirtualKeywords::AndRewriter.new
+
+    @my_and_calls = 0
+
+    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
+        @operator_user, :and, my_and)
+  end
+
+  def rewriters
+    [@and_rewriter]
+  end
+
+  it 'rewrites &&' do
+    do_rewrite(:symbolic_and, @operator_user)
+    @my_and_calls.should eql 1
+  end
+end

data/lib/spec/if_rewriter_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe 'IfRewriter' do
+  include TrackIfs, DoRewrite
+
+  before :each do
+    @greeter = Greeter.new true
+    @methods = sexpify_instance_methods Greeter
+    @if_rewriter = VirtualKeywords::IfRewriter.new
+
+    @my_if_calls = 0
+
+    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
+        @greeter, :if, my_if)
+  end
+
+  def rewriters
+    [@if_rewriter]
+  end
+
+  def greeter_rewrite_should_work(method_name,
+      required_calls = 1, verbose = false)
+    do_rewrite(method_name, @greeter, verbose = verbose)
+    @my_if_calls.should eql required_calls
+  end
+
+  it 'rewrites greet with if and else' do
+    greeter_rewrite_should_work :greet_if_else
+  end
+
+  it 'rewrites greet with if without else' do
+    # We don't need to do anything special for if without else
+    # They use the same sexp as if with else, with an empty block for the
+    # else clause
+    greeter_rewrite_should_work :greet_if_without_else
+  end
+
+  it 'rewrites greet with postfix if' do
+    # Again, we don't need to do anything special - they turn into the same sexp
+    greeter_rewrite_should_work :greet_postfix_if
+  end
+
+  it 'rewrites greet with if then else on one line' do
+    greeter_rewrite_should_work :greet_if_then_else
+  end
+
+  it 'rewrites greet with if then but no else on one line' do
+    greeter_rewrite_should_work :greet_if_then_no_else
+  end
+
+  it 'rewrites greet with unless' do
+    greeter_rewrite_should_work :greet_unless
+  end
+
+  it 'rewrites greet with unless and else' do
+    greeter_rewrite_should_work :greet_unless_else
+  end
+
+  it 'rewrites greet with postfix unless' do
+    greeter_rewrite_should_work :greet_postfix_unless
+  end
+
+  it 'combines ifs without interference' do
+    greeter_rewrite_should_work(:greet_all, required_calls = 5)
+  end
+
+  it 'handles nested ifs' do
+    greeter_rewrite_should_work(:greet_nested, required_calls = 2)
+  end
+
+  it 'rewrites ifs with compound clauses' do
+    greeter_rewrite_should_work :greet_block
+  end
+end

data/lib/spec/keyword_rewriter_spec.rb

@@ -2,100 +2,8 @@ require 'spec_helper'
 
 describe 'KeywordRewriter' do
   before :each do
-    @sexp_processor = SexpProcessor.new
-
-    def method_to_sexp(klass, method)
-      @sexp_processor.process(ParseTree.translate(klass, method))
-    end
-
-    @greeter = Greeter.new true
-    @and_user = AndUser.new false
-    @or_user = OrUser.new true
-    @operator_user = OperatorUser.new false
-
-    @greet_if_else_sexp = method_to_sexp(Greeter, :greet_if_else)
-    @greet_if_without_else_sexp = method_to_sexp(Greeter,
-                                                 :greet_if_without_else)
-    @greet_postfix_if_sexp = method_to_sexp(Greeter, :greet_postfix_if)
-    @greet_if_then_else_sexp = method_to_sexp(Greeter, :greet_if_then_else)
-    @greet_if_then_no_else_sexp = method_to_sexp(Greeter,
-                                                 :greet_if_then_no_else)
-    @greet_unless_sexp = method_to_sexp(Greeter, :greet_unless)
-    @greet_unless_else_sexp = method_to_sexp(Greeter, :greet_unless_else)
-    @greet_postfix_unless_sexp = method_to_sexp(Greeter, :greet_postfix_unless)
-    @greet_all_sexp = method_to_sexp(Greeter, :greet_all)
-    @greet_nested_sexp = method_to_sexp(Greeter, :greet_nested)
-
-
-    @method_with_and_sexp = method_to_sexp(AndUser, :method_with_and)
-    @if_with_and_sexp = method_to_sexp(AndUser, :if_with_and)
-
-    @method_with_or_sexp = method_to_sexp(OrUser, :method_with_or)
-    @if_with_or_sexp = method_to_sexp(OrUser, :if_with_or)
-
-    @symbolic_and_sexp = method_to_sexp(OperatorUser, :symbolic_and)
-
-    @greet_changed_sexp = method_to_sexp(Greeter, :greet_changed)
-    @method_with_and_result_sexp = method_to_sexp(AndUser,
-                                                  :method_with_and_result)
-    @symbolic_and_result_sexp = method_to_sexp(OperatorUser,
-                                               :symbolic_and_result)
-
-
-    @if_rewriter = VirtualKeywords::IfRewriter.new
-    @and_rewriter = VirtualKeywords::AndRewriter.new
-    @or_rewriter = VirtualKeywords::OrRewriter.new
-
-    @my_if_calls = 0
-    def increment_my_if_calls
-      @my_if_calls += 1
-    end
-
-    @my_and_calls = 0
-    def increment_my_and_calls
-      @my_and_calls += 1
-    end
-    @my_or_calls = 0
-    def increment_my_or_calls
-      @my_or_calls += 1
-    end
-    $my_symbolic_and_calls = 0
-
-    spec = self
-    my_if = lambda { |condition, then_do, else_do|
-      increment_my_if_calls()
-      if condition.call 
-        then_do.call
-      else 
-        else_do.call
-      end
-    }
-    my_and = lambda { |first, second|
-      increment_my_and_calls()
-      first.call and second.call
-    }
-    my_or = lambda { |first, second|
-      increment_my_or_calls()
-      first.call or second.call
-    }
-  
-    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
-        @greeter, :if, my_if)
-    
-    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
-        @and_user, :and, my_and)
-
-    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
-        @and_user, :if, my_if)
-
-    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
-        @or_user, :or, my_or)
-
-    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
-        @or_user, :if, my_if)
-
-    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
-        @operator_user, :and, my_and)
+    #@while_count_sexp = method_to_sexp(WhileUser, :while_count_to_value)
+    #@while_result_sexp = method_to_sexp(WhileUser, :while_result)
   end
 
   # These two "specs" produce sexps that I used to figure out how
@@ -140,108 +48,14 @@ describe 'KeywordRewriter' do
     #p @symbolic_and_result_sexp
     #puts ''
   #end
-  #
-  def do_rewrite(sexp, method_name, object, verbose = false)
-    result1 = @if_rewriter.process sexp
-    result2 = @and_rewriter.process result1
-    result = @or_rewriter.process result2
-    stringifier = VirtualKeywords::SexpStringifier.new
-
-    # Visually inspecting this result, it appears to be right
-    code_result = stringifier.stringify result
-    if verbose
-      puts code_result
-    end
-
-    # my_* are  dummy methods that do not change behavior, so both the
-    # old and new code should produce the same result,
-    # except that @my_*_calls is incremented
-    old_result = object.send method_name
-    VirtualKeywords::ClassReflection.install_method_on_instance(object, code_result)
-    new_result = object.send method_name
-
-    new_result.should eql old_result
-  end
-
-  def greeter_rewrite_should_work(sexp, method_name,
-                                  required_calls = 1, verbose = false)
-    do_rewrite(sexp, method_name, @greeter, verbose = verbose)
-    @my_if_calls.should eql required_calls
-  end
-
-  it 'rewrites greet with if and else' do
-    greeter_rewrite_should_work(@greet_if_else_sexp, :greet_if_else)
-  end
-
-  it 'rewrites greet with if without else' do
-    # We don't need to do anything special for if without else
-    # They use the same sexp as if with else, with an empty block for the
-    # else clause
-    greeter_rewrite_should_work(@greet_if_without_else_sexp,
-                                :greet_if_without_else)
-  end
 
-  it 'rewrites greet with postfix if' do
-    # Again, we don't need to do anything special - they turn into the same sexp
-    greeter_rewrite_should_work(@greet_postfix_if_sexp, :greet_postfix_if)
-  end
-
-  it 'rewrites greet with if then else on one line' do
-    greeter_rewrite_should_work(@greet_if_then_else_sexp,
-                                :greet_if_then_else)
-  end
-
-  it 'rewrites greet with if then but no else on one line' do
-    greeter_rewrite_should_work(@greet_if_then_no_else_sexp,
-                                :greet_if_then_no_else)
-  end
-
-  it 'rewrites greet with unless' do
-    greeter_rewrite_should_work(@greet_unless_sexp, :greet_unless)    
-  end
-
-  it 'rewrites greet with unless and else' do
-    greeter_rewrite_should_work(@greet_unless_else_sexp, :greet_unless_else)
-  end
-
-  it 'rewrites greet with postfix unless' do
-    greeter_rewrite_should_work(@greet_postfix_unless_sexp,
-                                :greet_postfix_unless)
-  end
-
-  it 'combines ifs without interference' do
-    greeter_rewrite_should_work(@greet_all_sexp, :greet_all, required_calls = 5)
-  end
-
-  it 'handles nested ifs' do
-    greeter_rewrite_should_work(@greet_nested_sexp, :greet_nested,
-                                required_calls = 2)
-  end
-
-  it 'rewrites "and" statements' do
-    do_rewrite(@method_with_and_sexp, :method_with_and, @and_user)
-    @my_and_calls.should eql 1
-  end
-
-  it 'handles ifs with "and"s in the predicate' do
-    do_rewrite(@if_with_and_sexp, :if_with_and, @and_user)
-    @my_and_calls.should eql 1
-    @my_if_calls.should eql 1
-  end
-
-  it 'rewrites "or" statements' do
-    do_rewrite(@method_with_or_sexp, :method_with_or, @or_user)
-    @my_or_calls.should eql 1
-  end
-
-  it 'handles ifs with "or"s in the predicate' do
-    do_rewrite(@if_with_or_sexp, :if_with_or, @or_user)
-    @my_or_calls.should eql 1
-    @my_if_calls.should eql 1
-  end
-
-  it 'rewrites &&' do
-    do_rewrite(@symbolic_and_sexp, :symbolic_and, @operator_user)
-    @my_and_calls.should eql 1
-  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
 end

data/lib/spec/or_rewriter_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe 'OrRewriter' do
+  include TrackIfs, TrackOrs, DoRewrite
+
+  before :each do
+    @or_user = OrUser.new true
+    @methods = sexpify_instance_methods OrUser
+    @if_rewriter = VirtualKeywords::IfRewriter.new
+    @or_rewriter = VirtualKeywords::OrRewriter.new
+
+    @my_if_calls = 0
+    @my_or_calls = 0
+
+    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
+        @or_user, :or, my_or)
+    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
+        @or_user, :if, my_if)
+  end
+
+  def rewriters
+    [@if_rewriter, @or_rewriter]
+  end
+
+  it 'rewrites "or" statements' do
+    do_rewrite(:method_with_or, @or_user)
+    @my_or_calls.should eql 1
+  end
+
+  it 'handles ifs with "or"s in the predicate' do
+    do_rewrite(:if_with_or, @or_user)
+    @my_or_calls.should eql 1
+    @my_if_calls.should eql 1
+  end
+end

data/lib/spec/spec_helper.rb

@@ -149,6 +149,20 @@ class Greeter < ApplicationController
     end
   end
 
+  def greet_block
+    # Multiple statements in the if/else clauses
+    if @hello
+      value = 5
+      value += 5
+
+      value
+    else
+      thing = 9
+
+      thing
+    end
+  end
+
   def count_to_ten
     [1..10].each do |index|
       puts index
@@ -212,7 +226,176 @@ class OperatorUser < ActiveRecord::Base
   end
 end
 
-RSpec.configure do |config|
-  config.color_enabled = true
-  config.formatter = 'documentation'
+class WhileUser < ApplicationController
+  def initialize(value)
+    @value = value
+    @i = 0
+    @counts = []
+  end
+
+  def while_count_to_value
+    while @i < @value
+      @counts << @i
+      @i += 1
+    end
+
+    @counts
+  end
+
+  def while_result
+    my_while(
+      lambda { @i < value },
+      lambda do
+        @counts << @i
+        @i += 1
+      end
+    )
+  end
+end
+
+class CaseWhenUser < ApplicationController
+  def initialize(value)
+    @value = value
+  end
+
+  def describe_value
+    case @value
+      when 1
+        :one
+      when 3..5
+        :three_to_five
+      when 7, 9
+        :seven_or_nine
+      when value * 10 < 90
+        :passes_multiplication_test
+      else
+        :something_else
+    end
+  end
+end
+
+# Helper classes and functions for rewriter specs
+
+# Given a class and a method name, return a sexpified method.
+def method_to_sexp(klass, method)
+  SexpProcessor.new.process(ParseTree.translate(klass, method))
+end
+
+# Sexpify all non-inherited instance methods of a class and return them in
+# a hash mapping names to sexps.
+def sexpify_instance_methods klass
+  sexps = {}
+  klass.instance_methods(false).each do |method_name|
+    sexps[method_name.to_sym] = method_to_sexp(klass, method_name.to_sym)
+  end
+
+  sexps
+end
+
+module TrackIfs
+  @my_if_calls = 0 # Don't forget to reset this before each spec!
+
+  def increment_my_if_calls
+    @my_if_calls += 1
+  end
+
+  def my_if
+    # Dummy if that increments @my_if_calls, then runs as normal
+    @my_if ||= lambda { |condition, then_do, else_do|
+      increment_my_if_calls
+      if condition.call 
+        then_do.call
+      else 
+        else_do.call
+      end
+    }
+  end
+end
+
+module TrackAnds
+  @my_and_calls = 0
+
+  def increment_my_and_calls
+    @my_and_calls += 1
+  end
+
+  def my_and
+    # Dummy if that increments @my_if_calls, then runs as normal
+    @my_and ||= lambda { |first, second|
+      increment_my_and_calls
+      first.call and second.call
+    }
+  end
+end
+
+module TrackOrs
+  @my_or_calls = 0
+
+  def increment_my_or_calls
+    @my_or_calls += 1
+  end
+
+  def my_or
+    @my_or ||= lambda { |first, second|
+      increment_my_or_calls
+      first.call or second.call
+    }
+  end
+end
+
+module TrackWhiles
+  @my_while_calls = 0
+
+  def increment_my_while_calls
+    @my_while_calls += 1
+  end
+
+  def my_while
+    @my_while ||= lambda { |condition, body|
+      increment_my_while_calls
+      while condition.call
+        body.call
+      end
+    }
+  end
+end
+
+class Abstract < StandardError
+end
+
+module DoRewrite
+  # Override this and return a list of rewriters, in order, so do_rewrite
+  # can call them
+  def rewriters
+    raise Abstract
+  end
+
+  def do_rewrite(method_name, object, verbose = false)
+    sexp = @methods[method_name]
+    result = sexp
+    rewriters.each do |rewriter|
+      result = rewriter.process result 
+    end
+    stringifier = VirtualKeywords::SexpStringifier.new
+
+    # Visually inspecting this result, it appears to be right
+    code_result = stringifier.stringify result
+    if verbose
+      puts code_result
+    end
+
+    # my_* are  dummy methods that do not change behavior, so both the
+    # old and new code should produce the same result,
+    # except that @my_*_calls is incremented
+    old_result = object.send method_name
+    VirtualKeywords::ClassReflection.install_method_on_instance(object, code_result)
+    new_result = object.send method_name
+
+    new_result.should eql old_result
+  end
+end
+
+RSpec.configure do |configuration|
+  configuration.color_enabled = true
+  configuration.formatter = 'documentation'
 end

data/lib/spec/virtualizer_spec.rb

@@ -113,12 +113,25 @@ describe 'Virtualizer' do
       end
     end
 
+    class Counter
+      def run
+        a = []
+        i = 0
+        while i <= 10
+          a << i
+        end
+
+        a
+      end
+    end
+
     @my_class = MyClass.new
     @another_class = AnotherClass.new
     @yet_another_class = YetAnotherClass.new
     @operator_user = OperatorUser.new false
+    @counter = Counter.new
     @virtualizer = VirtualKeywords::Virtualizer.new(
-        :for_instances => [@greeter, @my_class]
+        :for_instances => [@greeter, @my_class, @counter]
     )
     @class_virtualizer = VirtualKeywords::Virtualizer.new(
         :for_classes => [AnotherClass]
@@ -178,4 +191,14 @@ describe 'Virtualizer' do
     @another_class.quux.should eql :right
     @yet_another_class.quux.should eql :if_modified
   end
+
+  it 'virtualizes "while" on instances' do
+    @virtualizer.virtual_while do |condition, body|
+      # call the body once, regardless of condition
+      body.call      
+    end
+
+    result = @counter.run
+    result.should eql [0]
+  end
 end

data/lib/spec/while_rewriter_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'WhileRewriter' do
+  include TrackWhiles, DoRewrite
+
+  before :each do
+    @while_user = WhileUser.new 10
+    @methods = sexpify_instance_methods WhileUser
+    @while_rewriter = VirtualKeywords::WhileRewriter.new
+
+    @my_while_calls = 0
+
+    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
+        @while_user, :while, my_while)
+  end
+
+  def rewriters
+    [@while_rewriter]
+  end
+ 
+  it 'rewrites "while" expressions' do
+    do_rewrite(:while_count_to_value, @while_user) 
+    @my_while_calls.should eql 1
+  end
+end

data/lib/virtual_keywords/keyword_rewriter.rb

@@ -1,4 +1,7 @@
 module VirtualKeywords
+  # SexpProcessor subclass that rewrites "if" expressions.
+  # Calls VirtualKeywords::REWRITTEN_KEYWORDS.call_if and lets it pick a
+  # virtual implementation.
   class IfRewriter < SexpProcessor
     # Initialize an IfRewriter (self.strict is false)
     def initialize
@@ -25,6 +28,9 @@ module VirtualKeywords
       then_do = expression[2]
       else_do = expression[3]
 
+      # This ugly sexp turns into the following Ruby code:
+      # VirtualKeywords::REWRITTEN_KEYWORDS.call_if(
+      #     self, lambda { condition }, lambda { then_do }, lambda { else_do })
       s(:call,
         s(:colon2,
           s(:const, :VirtualKeywords),
@@ -45,11 +51,11 @@ module VirtualKeywords
   #
   # Arguments:
   #   method_name: (Symbol) the name of the REWRITTEN_KEYWORDS method that
-  #                should be called in the sexp.
+  #       should be called in the sexp.
   #   first: (Sexp) the first argument to the method, which should be
-  #          wrapped in a lambda then passed to REWRITTEN_KEYWORDS. 
+  #       wrapped in a lambda then passed to REWRITTEN_KEYWORDS. 
   #   second: (Sexp) the second argument to the method, which should be
-  #            wrapped in a lambda then passed to REWRITTEN_KEYWORDS. 
+  #       wrapped in a lambda then passed to REWRITTEN_KEYWORDS. 
   def self.call_operator_replacement(function_name, first, second)
     s(:call,
       s(:colon2,
@@ -64,6 +70,7 @@ module VirtualKeywords
     )
   end
 
+  # SexpProcessor subclass that rewrites "and" expressions.
   class AndRewriter < SexpProcessor
     def initialize
       super
@@ -85,6 +92,7 @@ module VirtualKeywords
     end
   end
 
+  # SexpProcessor subclass that rewrites "or" expressions.
   class OrRewriter < SexpProcessor
     def initialize
       super
@@ -105,4 +113,39 @@ module VirtualKeywords
       VirtualKeywords.call_operator_replacement(:call_or, first, second)
     end
   end
+
+  class UnexpectedSexp < StandardError
+  end
+
+  class WhileRewriter < SexpProcessor
+    def initialize
+      super
+      self.strict = false
+    end
+
+    def rewrite_while(expression)
+      condition = expression[1]
+      body = expression[2]
+      
+      # This was a true in the example I checked (in sexps_while.txt)
+      # but I'm not sure what it's for.
+      third = expression[3]
+      if third != true # Should be true, not just a truthy object
+        raise UnexpectedSexp, 'Expected true as the 3rd element in a while, ' +
+            "but got #{third}, this is probably a bug."
+      end
+
+      s(:call,
+        s(:colon2,
+          s(:const, :VirtualKeywords),
+          :REWRITTEN_KEYWORDS
+        ), :call_while,
+        s(:array,
+          s(:self),
+          s(:iter, s(:fcall, :lambda), nil, condition),
+          s(:iter, s(:fcall, :lambda), nil, body)
+        )
+      )
+    end
+  end
 end

data/lib/virtual_keywords/rewritten_keywords.rb

@@ -17,10 +17,9 @@ module VirtualKeywords
     # Arguments:
     #   A Hash with the following key:
     #   predicates_to_blocks: (Hash[Proc, Proc]) a hash mapping predicates that
-    #                         take ObjectAndKeywords and return true for matches
-    #                         to the lambdas that should be called in place of
-    #                         the keyword in the object's methods
-    #                         (optional, an empty Hash is the default).
+    #       take ObjectAndKeywords and return true for matches to the lambdas
+    #       that should be called in place of the keyword in the object's
+    #       methods (optional, an empty Hash is the default).
     def initialize(input)
       @predicates_to_blocks = input[:predicates_to_blocks] || {}
     end
@@ -72,7 +71,7 @@ module VirtualKeywords
     def lambda_or_raise(caller_object, keyword)
       object_and_keyword = ObjectAndKeyword.new(caller_object, keyword)
       matching = @predicates_to_blocks.keys.find { |predicate|
-        predicate.call(object_and_keyword)
+        predicate.call object_and_keyword
       }
 
       if matching.nil?
@@ -90,11 +89,11 @@ module VirtualKeywords
     # Arguments:
     #   caller_object: (Object) the object whose method this is being called in.
     #   condition: (Proc) The condition of the if statement, wrapped in a
-    #              lambda.
+    #       lambda.
     #   then_do: (Proc) the lambda to execute if the condition is true (but
-    #            the user-supplied block may do something else)
+    #       the user-supplied block may do something else)
     #   else_do: (Proc) the lambda to execute if the condition is false (but
-    #            the user-supplied block may do something else)
+    #       the user-supplied block may do something else)
     #
     # Raises:
     #   RewriteLambdaNotProvided if no "if" lambda is available.
@@ -130,6 +129,21 @@ module VirtualKeywords
       or_lambda = lambda_or_raise(caller_object, :or)
       or_lambda.call(first, second)
     end
+
+    # Call a "while" virtual block in place of an "while" expression.
+    #
+    # Arguments:
+    #   caller_object: (Object) the object whose method this is being called in.
+    #   condition: (Proc) The condition of the while expression.
+    #   body: (Proc) The body of the while expression (which is normally
+    #       executed repeatedly)
+    #   
+    # Raises:
+    #   RewriteLambdaNotProvided if no "while" lambda is available.
+    def call_while(caller_object, condition, body)
+      while_lambda = lambda_or_raise(caller_object, :while)
+      while_lambda.call(condition, body)
+    end
   end
 
 

data/lib/virtual_keywords/version.rb

@@ -1,3 +1,3 @@
 module VirtualKeywords
-  VERSION = '0.0.0'
+  VERSION = '0.1.0'
 end

data/lib/virtual_keywords/virtualizer.rb

@@ -58,9 +58,9 @@ module VirtualKeywords
     # Arguments:
     #   klass: (Class) the class which should be modified.
     #   method_code: (String) the code for the method to install, of the format:
-    #                def method_name(args)
-    #                  ...
-    #                end
+    #       def method_name(args)
+    #         ...
+    #       end
     def self.install_method_on_class(klass, method_code)
       klass.class_eval method_code
     end
@@ -76,9 +76,9 @@ module VirtualKeywords
     # Arguments:
     #   object: (Object) the object instance that should be modified.
     #   method_code: (String) the code for the method to install, of the format:
-    #                def method_name(args)
-    #                  ...
-    #                end
+    #       def method_name(args)
+    #         ...
+    #       end
     def self.install_method_on_instance(object, method_code)
       object.instance_eval method_code
     end
@@ -102,33 +102,36 @@ module VirtualKeywords
     # Arguments:
     #   A Hash with the following arguments (all optional):
     #   for_classes: (Array[Class]) an array of classes. All methods of objects
-    #                created from the given classes will be virtualized
-    #                (optional, the default is an empty Array).
+    #       created from the given classes will be virtualized (optional, the
+    #       default is an empty Array).
     #   for_instances: (Array[Object]) an array of object. All of these objects'
-    #                  methods will be virtualized
-    #                  (optional, the default is an empty Array).
+    #       methods will be virtualized
+    #       (optional, the default is an empty Array).
     #   for subclasses_of: (Array[Class]) an array of classes. All methods of
-    #                      objects created from the given classes' subclasses
-    #                      (but NOT those from the given classes) will be
-    #                      virtualized.
+    #       objects created from the given classes' subclasses (but NOT those
+    #       from the given classes) will be virtualized.
     #   if_rewriter: (IfRewriter) the SexpProcessor descendant that
-    #                rewrites "if"s in methods (optional, the default is
-    #                IfRewriter.new).
+    #       rewrites "if"s in methods (optional, the default is
+    #       IfRewriter.new).
     #   and_rewriter: (AndRewriter) the SexpProcessor descendant that
-    #                 rewrites "and"s in methods (optional, the default is
-    #                 AndRewriter.new).
+    #       rewrites "and"s in methods (optional, the default is
+    #       AndRewriter.new).
     #   or_rewriter: (OrRewriter) the SexpProcessor descendant that
-    #                 rewrites "or"s in methods (optional, the default is
-    #                 OrRewriter.new).
+    #       rewrites "or"s in methods (optional, the default is
+    #       OrRewriter.new).
+    #   while_rewriter: (WhileRewriter) the SexpProcessor descendant that
+    #       rewrites "while"s in methods (optional, the default is
+    #       WhileRewriter.new).
     #   sexp_processor: (SexpProcessor) the sexp_processor that can turn
-    #                   ParseTree results into sexps (optional, the default is
-    #                   SexpProcessor.new).
+    #       ParseTree results into sexps (optional, the default is
+    #       SexpProcessor.new).
     #   sexp_stringifier: (SexpStringifier) an object that can turn sexps
-    #                     back into Ruby code (optional, the default is
-    #                     SexpStringifier.new).
+    #       back into Ruby code (optional, the default is
+    #       SexpStringifier.new).
     #   rewritten_keywords: (RewrittenKeywords) a repository for keyword
-    #                       replacement lambdas (optional, the default is
-    #                       REWRITTEN_KEYWORDS).
+    #       replacement lambdas (optional, the default is REWRITTEN_KEYWORDS).
+    #   class_reflection: (Class) an object that provides methods to modify the
+    #       methods of classes (optional, the default is ClassReflection).
     def initialize(input_hash)
       @for_classes = input_hash[:for_classes] || []
       @for_instances = input_hash[:for_instances] || []
@@ -136,19 +139,21 @@ module VirtualKeywords
       @if_rewriter = input_hash[:if_rewriter] || IfRewriter.new
       @and_rewriter = input_hash[:and_rewriter] || AndRewriter.new
       @or_rewriter = input_hash[:or_rewriter] || OrRewriter.new
+      @while_rewriter = input_hash[:while_rewriter] || WhileRewriter.new
       @sexp_processor = input_hash[:sexp_processor] || SexpProcessor.new
       @sexp_stringifier = input_hash[:sexp_stringifier] || SexpStringifier.new
       @rewritten_keywords =
           input_hash[:rewritten_keywords] || REWRITTEN_KEYWORDS
+      @class_reflection = input_hash[:class_reflection] || ClassReflection
     end
 
     # Helper method to rewrite code.
     #
     # Arguments:
     #   translated: (Array) the output of ParseTree.translate on the original
-    #               code
+    #       code
     #   rewriter: (SexpProcessor) the object that will rewrite the sexp, to
-    #             virtualize the keywords.
+    #       virtualize the keywords.
     def rewritten_code(translated, rewriter)
       sexp = @sexp_processor.process(
           VirtualKeywords.deep_copy_array(translated))
@@ -166,10 +171,10 @@ module VirtualKeywords
     def rewrite_methods_of_instance(instance, keyword, rewriter, block)
       @rewritten_keywords.register_lambda_for_object(instance, keyword, block)
 
-      methods = ClassReflection.instance_methods_of instance.class
+      methods = @class_reflection.instance_methods_of instance.class
       methods.each do |name, translated|
         new_code = rewritten_code(translated, rewriter)
-        ClassReflection.install_method_on_instance(instance, new_code)
+        @class_reflection.install_method_on_instance(instance, new_code)
       end
     end
 
@@ -181,12 +186,12 @@ module VirtualKeywords
     #   rewriter: (SexpProcessor) the object that will do the rewriting.
     #   block: (Proc) the lambda that will replace the keyword.
     def rewrite_methods_of_class(klass, keyword, rewriter, block)
-      @rewritten_keywords.register_lambda_for_class(klass, keyword, block)        
+      @rewritten_keywords.register_lambda_for_class(klass, keyword, block)
 
-      methods = ClassReflection.instance_methods_of klass
+      methods = @class_reflection.instance_methods_of klass
       methods.each do |name, translated|
         new_code = rewritten_code(translated, rewriter)
-        ClassReflection.install_method_on_class(klass, new_code)
+        @class_reflection.install_method_on_class(klass, new_code)
       end
     end
 
@@ -205,7 +210,7 @@ module VirtualKeywords
         rewrite_methods_of_class(klass, keyword, rewriter, block)
       end
 
-      subclasses = ClassReflection.subclasses_of_classes @for_subclasses_of
+      subclasses = @class_reflection.subclasses_of_classes @for_subclasses_of
       subclasses.each do |subclass|
         rewrite_methods_of_class(subclass, keyword, rewriter, block)
       end
@@ -215,7 +220,7 @@ module VirtualKeywords
     #
     # Arguments:
     #   &block: The block that will replace "if"s in the objects being
-    #           virtualized
+    #       virtualized
     def virtual_if(&block)
       virtualize_keyword(:if, @if_rewriter, block)
     end
@@ -224,7 +229,7 @@ module VirtualKeywords
     #
     # Arguments:
     #   &block: The block that will replace "and"s in the objects being
-    #           virtualized
+    #       virtualized
     def virtual_and(&block)
       virtualize_keyword(:and, @and_rewriter, block)
     end
@@ -233,9 +238,18 @@ module VirtualKeywords
     #
     # Arguments:
     #   &block: The block that will replace "or"s in the objects being
-    #           virtualized
+    #       virtualized
     def virtual_or(&block)
       virtualize_keyword(:or, @or_rewriter, block)
     end
+
+    # Rewrite "while" expressions.
+    #
+    # Arguments:
+    #   &block: The block that will replace "while"s in the objects being
+    #       virtualized
+    def virtual_while(&block)
+      virtualize_keyword(:while, @while_rewriter, block)
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: virtual_keywords
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 27
   prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 0
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Rahul Rajagopalan
@@ -88,17 +88,23 @@ files:
 - lib/virtual_keywords/keyword_rewriter.rb
 - lib/virtual_keywords/version.rb
 - lib/virtual_keywords/virtualizer.rb
+- lib/sexps/sexps_while.txt
 - lib/sexps/count_to_ten_sexp.txt
 - lib/sexps/sexps_and.txt
 - lib/sexps/sexps_symbolic_and.txt
+- lib/sexps/sexps_case_when.txt
 - lib/sexps/sexps_rewritten_keywords.txt
 - lib/sexps/sexps_greet.txt
 - lib/virtual_keywords.rb
 - lib/spec/virtualizer_spec.rb
+- lib/spec/while_rewriter_spec.rb
+- lib/spec/and_rewriter_spec.rb
+- lib/spec/if_rewriter_spec.rb
 - lib/spec/rewritten_keywords_spec.rb
 - lib/spec/keyword_rewriter_spec.rb
 - lib/spec/class_mirrorer_spec.rb
 - lib/spec/spec_helper.rb
+- lib/spec/or_rewriter_spec.rb
 - lib/Rakefile
 homepage: http://github.com/rahulraj/virtual_keywords
 licenses: []