virtual_keywords 0.0.0

data/lib/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/sexps/count_to_ten_sexp.txt

@@ -0,0 +1,12 @@
+# Sexp for Greeter#count_to_ten
+s(:defn, :count_to_ten,
+  s(:scope,
+    s(:block, s(:args),
+      s(:iter,
+        s(:call, s(:array, s(:lit, 1..10)), :each),
+        s(:dasgn_curr, :index),
+        s(:fcall, :puts, s(:array, s(:dvar, :index)))
+      )
+    )
+  )
+)

data/lib/sexps/sexps_and.txt

@@ -0,0 +1,29 @@
+# Sexps from translating Greeter#method_with_and and
+# Greeter#method_with_and_result (example_classes.rb)
+
+# before
+s(:defn, :method_with_and,
+  s(:scope,
+    s(:block, s(:args),
+      s(:and, s(:ivar, :@hello), s(:true))
+    )
+  )
+)
+
+# after
+s(:defn, :method_with_and_result,
+  s(:scope,
+    s(:block, s(:args),
+      s(:fcall, :my_and,
+        s(:array,
+          s(:iter,
+            s(:fcall, :lambda), nil, s(:ivar, :@hello)
+          ),
+          s(:iter,
+            s(:fcall, :lambda), nil, s(:true)
+          )
+        )
+      )
+    )
+  )
+)

data/lib/sexps/sexps_greet.txt

@@ -0,0 +1,63 @@
+# Sexps gotten from translating Greeter#greet and Greeter#greet_changed
+# from example_classes.rb
+
+# before translation (formatted manually)
+s(:defn, :greet,
+  s(:scope,
+    s(:block, s(:args),
+      s(:if, s(:ivar, :@hello),
+        s(:str, "Hello World!"),
+        s(:str, "Goodbye")
+      )
+    )
+  )
+)
+
+# after translation
+s(:defn, :greet_changed,
+  s(:scope,
+    s(:block, s(:args),
+      s(:fcall, :my_if,
+        s(:array,
+          s(:iter,
+            s(:fcall, :lambda), nil, s(:ivar, :@hello)
+          ),
+          s(:iter,
+            s(:fcall, :lambda), nil, s(:str, "Hello World!")
+          ),
+          s(:iter,
+            s(:fcall, :lambda), nil, s(:str, "Goodbye")
+          )
+        )
+      )
+    )
+  )
+)
+
+# OK, so here's the rule that I'm inferring from this example:
+
+# We start with 
+s(:if, condition, then_do, else_do)
+# Where condition, then_do, and else_do are "variables" containing
+# arbitrary sexps
+
+# Our rewriter should turn this into
+s(:fcall, :my_if,
+  s(:array,
+    s(:iter,
+      s(:fcall, :lambda), nil, ~condition
+    ),
+    s(:iter,
+      s(:fcall, :lambda), nil, ~then_do
+    ),
+    s(:iter,
+      s(:fcall, :lambda), nil, ~else_do
+    )
+  )
+)
+# Where ~condition is the expansion of condition, inserting the
+# sexp it points to, and similar for then_do and else_do
+
+# Question: What does the :iter part mean exactly?
+# Also, how exactly does the call to lambda map to the sexp?
+# It takes a block, so that complicates the syntax.

data/lib/sexps/sexps_rewritten_keywords.txt

@@ -0,0 +1,36 @@
+# before
+s(:defn, :greet_if_else,
+  s(:scope,
+    s(:block, s(:args),
+      s(:if,
+        s(:ivar, :@hello),
+        s(:str, "Hello World! (if else)"),
+        s(:call, s(:str, "Good"), :+, s(:array, s(:str, "bye (if else)")))
+      )
+    )
+  )
+)
+
+#after
+s(:defn, :greet_changed,
+  s(:scope,
+    s(:block, s(:args),
+      s(:call,
+        s(:colon2,
+          s(:const, :VirtualKeywords),
+          :REWRITTEN_KEYWORDS
+        ),
+        :call_if,
+          s(:array,
+            s(:self),
+            s(:iter, s(:fcall, :lambda), nil, s(:ivar, :@hello)),
+            s(:iter, s(:fcall, :lambda), nil, s(:str, "Hello World! (if else)")),
+            s(:iter,
+              s(:fcall, :lambda),
+              nil, s(:call, s(:str, "Good"), :+, s(:array, s(:str, "bye (if else)")))
+            )
+          )
+      )
+    )
+  )
+)

data/lib/sexps/sexps_symbolic_and.txt

@@ -0,0 +1,25 @@
+s(:defn, :symbolic_and,
+  s(:scope,
+    s(:block, s(:args),
+      s(:and, s(:ivar, :@value), s(:false))
+    )
+  )
+)
+
+# after
+s(:defn, :symbolic_and_result,
+  s(:scope,
+    s(:block, s(:args),
+      s(:fcall, :my_conditional_and,
+        s(:array,
+          s(:iter,
+            s(:fcall, :lambda), nil, s(:ivar, :@value)
+          ),
+          s(:iter,
+            s(:fcall, :lambda), nil, s(:false)
+          )
+        )
+      )
+    )
+  )
+)

data/lib/spec/class_mirrorer_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'ClassMirrorer' do
+  before :each do
+    @stub_parser = double('parser')
+  end
+
+  it 'mirrors given classes' do
+    @stub_parser.stub(:translate).and_return('translated') 
+    mirrorer = VirtualKeywords::ClassMirrorer.new @stub_parser
+    result = mirrorer.mirror [Fizzbuzzer]
+    
+    class_and_method = VirtualKeywords::ClassAndMethodName.new(
+        Fizzbuzzer, 'fizzbuzz')
+    result.keys.should include class_and_method
+    result[class_and_method].should eql 'translated'
+  end
+end

data/lib/spec/keyword_rewriter_spec.rb

@@ -0,0 +1,247 @@
+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)
+  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
+  #
+  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
+end

data/lib/spec/rewritten_keywords_spec.rb

@@ -0,0 +1,28 @@
+describe 'RewrittenKeywords' do
+  before :each do
+    @rewritten_keywords = VirtualKeywords::RewrittenKeywords.new({}) 
+  end
+
+  it 'has no lambdas initially' do
+    lambda { @rewritten_keywords.lambda_or_raise(4, :if) }.
+        should raise_error VirtualKeywords::RewriteLambdaNotProvided
+  end
+
+  it 'registers lambdas for objects' do
+    number = 5 
+    keyword = :if
+    the_lambda = lambda {}
+    @rewritten_keywords.register_lambda_for_object(number, keyword, the_lambda)
+    @rewritten_keywords.lambda_or_raise(number, keyword).should eql the_lambda
+  end
+
+  it 'registers lambdas for classes' do
+    class MyClass
+    end
+    my_class = MyClass.new
+    keyword = :if
+    the_lambda = lambda {}
+    @rewritten_keywords.register_lambda_for_class(MyClass, keyword, the_lambda)
+    @rewritten_keywords.lambda_or_raise(my_class, keyword).should eql the_lambda
+  end
+end

data/lib/spec/spec_helper.rb

@@ -0,0 +1,218 @@
+require 'sexp_processor'
+require 'parse_tree'
+require 'ruby2ruby'
+
+require 'virtual_keywords/sexp_stringifier'
+require 'virtual_keywords/class_mirrorer'
+require 'virtual_keywords/virtualizer'
+require 'virtual_keywords/keyword_rewriter'
+require 'virtual_keywords/rewritten_keywords'
+
+require 'rspec'
+
+# Classes the specs should use.
+module ActiveRecord
+  class Base
+  end
+end
+
+class ApplicationController
+end
+
+class Fizzbuzzer < ActiveRecord::Base
+  def fizzbuzz(n)
+    (1..n).map { |i|
+      if i % 3 == 0 and i % 5 == 0
+        "fizzbuzz"
+      elsif i % 3 == 0
+        "fizz"
+      elsif i  % 5 == 0
+        "buzz"
+      else
+        i.to_s
+      end
+    }
+  end
+end
+
+class Greeter < ApplicationController
+  def initialize(hello)
+    @hello = hello
+  end
+
+  # The following two methods are before/after examples. The rewriter
+  # should turn greet's body into greet_changed's. Running ParseTree over
+  # them, I got two sexps (in sexps_greet.txt), which I read to
+  # reverse-engineer the format. There may be edge cases (Ruby's grammar
+  # is much more complex than Lisp's!)
+  #
+  # spec/if_processor_spec runs a test over greet
+
+  # An example conditional: if and else
+  def greet_if_else
+    if @hello
+      'Hello World! (if else)'
+    else
+      # Compound expressions should be preserved
+      # (i.e. not evaluated too early or in the wrong context)
+      'Good' + 'bye (if else)'
+    end
+  end
+
+  # If without else
+  def greet_if_without_else
+    if @hello
+      'Hello World! (if without else)'
+    end
+  end
+
+  # Postfix if
+  def greet_postfix_if
+    'Hello World! (postfix if)' if @hello
+  end
+
+  # If, then, else
+  def greet_if_then_else
+    if @hello then 'Hello World! (if then else)' else 'Goodbye (if then else)' end
+  end
+
+  # If, then, no else
+  def greet_if_then_no_else
+    if @hello then 'Hello World! (if then)' end
+  end
+
+  # Unless
+  def greet_unless
+    unless @hello
+      'Goodbye (unless)'
+    end
+  end
+
+  # Unless, then else
+  def greet_unless_else
+    unless @hello
+      'Goodbye (unless else)'
+    else
+      'Hello World! (unless else)'
+    end
+  end
+
+  # Postfix unless
+  def greet_postfix_unless
+    'Goodbye (postfix unless)' unless @hello
+  end
+
+  # What the conditional in greet should look like after processing
+  def greet_changed
+    VirtualKeywords::REWRITTEN_KEYWORDS.call_if(
+        self, lambda { @hello }, lambda { 'Hello World! (if else)' },
+        lambda { 'Good' + 'bye (if else)' })
+  end
+
+  # All together now
+  def greet_all
+    result = ''
+    # 1
+    if @hello
+      result = 'Hello'
+    else
+      result = 'Goodbye'
+    end
+    # 2
+    if 2 + 2 == 4
+      result += '\nMath is right'
+    end
+    # 3
+    result += '\nThis is supposed to look like English' if false
+    # 4
+    unless 2 + 9 == 10
+      result += '\nMath should work in unless too'
+    end
+    # 5
+    result += '\nWorld!' unless true
+
+    result
+  end
+
+  def greet_nested
+    if true
+      # This if should be processed, even though it never happens!
+      if 2 + 2 == 4
+        'Math is right'
+      else
+        'Weird'
+      end
+    else
+      # This if should be expanded, but NOT evaluated!
+      puts 'hi there' if true
+      'The false case'
+    end
+  end
+
+  def count_to_ten
+    [1..10].each do |index|
+      puts index
+    end
+  end
+end
+
+class AndUser < ActiveRecord::Base
+  def initialize(value)
+    @value = value
+  end
+
+  def method_with_and
+    @value and true
+  end
+
+  def if_with_and
+    if @value and true
+      'Both @value and true were true (the latter is no surprise)'
+    else
+      '@value must have been false, I doubt true was false!'
+    end
+  end
+
+  def method_with_and_result
+    my_and(lambda { @value }, lambda { true })
+  end
+end
+
+class OrUser < ApplicationController
+  def initialize(value)
+    @value = value
+  end
+
+  def method_with_or
+    @value or false
+  end
+
+  def if_with_or
+    if @value or true
+      'Both @value or true were true (the latter is no surprise)'
+    else
+      "This can't happen!"
+    end
+  end
+end
+
+# Ruby also lets you use the && and || operators
+# I think they have different precedence rules
+class OperatorUser < ActiveRecord::Base
+  def initialize(value)
+    @value = value
+  end
+
+  def symbolic_and
+    @value && false
+  end
+
+  def symbolic_and_result
+    my_conditional_and(lambda { @value }, lambda { false })
+  end
+end
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter = 'documentation'
+end