virtual_keywords 0.1.0 → 0.3.0

data/lib/spec/virtualizees/while_user.rb

@@ -0,0 +1,16 @@
+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
+end

data/lib/spec/virtualizer_spec.rb

@@ -1,84 +1,5 @@
 require 'spec_helper'
 
-describe 'instance_methods_of' do
-  it 'retrieves the instance methods of a class' do
-    method_names = VirtualKeywords::ClassReflection.instance_methods_of(
-        Fizzbuzzer).keys
-    method_names.should include 'fizzbuzz'
-  end
-end
-
-describe 'subclasses_of_classes' do
-  it 'finds the subclasses of classes and flattens the result' do
-    rails_classes = [ActiveRecord::Base, ApplicationController]
-    subclasses = VirtualKeywords::ClassReflection.
-        subclasses_of_classes rails_classes
-
-    subclasses.should include Fizzbuzzer
-    subclasses.should include Greeter
-  end
-end
-
-describe 'install_method_on_class' do
-  before :each do
-    class MyClass
-      def foo
-        :hello
-      end
-    end
-    @object = MyClass.new
-  end
-  
-  it 'installs methods on classes' do
-    VirtualKeywords::ClassReflection.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
-    VirtualKeywords::ClassReflection.install_method_on_class(
-        MyClass, 'def foo; @bar = :bar; :goodbye; end')
-    VirtualKeywords::ClassReflection.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
-    VirtualKeywords::ClassReflection.install_method_on_class(
-        MyClass, 'def foo; $thing = :new; end')
-    
-    @object.foo()
-    $thing.should eql :new
-  end
-end
-
-describe 'install_method_on_instance' do
-  before :each do
-    class MyClass
-      def foo
-        :hello
-      end
-    end
-    @object1 = MyClass.new
-    @object2 = MyClass.new
-  end
-
-  it 'installs methods on specific instances' do
-    VirtualKeywords::ClassReflection.install_method_on_instance(
-        @object1, 'def foo; :goodbye; end')
-    @object1.foo.should eql :goodbye
-    @object2.foo.should eql :hello
-  end
-end
-
 describe 'Virtualizer' do
   before :each do
     @greeter = Greeter.new false
@@ -113,7 +34,7 @@ describe 'Virtualizer' do
       end
     end
 
-    class Counter
+    class WhileCounter
       def run
         a = []
         i = 0
@@ -125,13 +46,34 @@ describe 'Virtualizer' do
       end
     end
 
+    class UntilCounter
+      def run
+        a = []
+        i = 0
+        until i > 10
+          a << i
+        end
+
+        a
+      end
+    end
+
+    class Inverter
+      def run value
+        not value
+      end
+    end
+
     @my_class = MyClass.new
     @another_class = AnotherClass.new
     @yet_another_class = YetAnotherClass.new
     @operator_user = OperatorUser.new false
-    @counter = Counter.new
+    @while_counter = WhileCounter.new
+    @until_counter = UntilCounter.new
+    @inverter = Inverter.new
     @virtualizer = VirtualKeywords::Virtualizer.new(
-        :for_instances => [@greeter, @my_class, @counter]
+        :for_instances => [@greeter, @my_class,
+            @while_counter, @until_counter, @inverter]
     )
     @class_virtualizer = VirtualKeywords::Virtualizer.new(
         :for_classes => [AnotherClass]
@@ -198,7 +140,28 @@ describe 'Virtualizer' do
       body.call      
     end
 
-    result = @counter.run
+    result = @while_counter.run
     result.should eql [0]
   end
+
+  it 'virtualizes "until" on instances' do
+    @virtualizer.virtual_until do |condition, body|
+      # flip it into a while
+      while condition.call
+        body.call
+      end
+    end
+    
+    result = @until_counter.run
+    result.should eql []
+  end
+
+  it 'virtualizes "not" on instances' do
+    @virtualizer.virtual_not do |value|
+      value.call
+    end
+
+    result = @inverter.run true
+    result.should be_true
+  end
 end

data/lib/virtual_keywords/class_reflection.rb

@@ -0,0 +1,88 @@
+module VirtualKeywords
+  # Object used to inspect the class hierarchy, and to view
+  # and modify methods of classes.
+  class ClassReflection
+    def initialize(parser_strategy = ParserStrategy.new)
+      @parser_strategy = parser_strategy
+    end
+
+    # Get the subclasses of a given class.
+    #
+    # Arguments:
+    #   parent: (Class) the class whose subclasses to find.
+    #
+    # Returns:
+    #   (Array) all classes which are subclasses of parent.
+    def subclasses_of_class(parent)
+      ObjectSpace.each_object(Class).select { |klass|
+        klass < parent
+      }
+    end
+
+    # Given an array of base classes, return a flat array of all their
+    # subclasses.
+    #
+    # Arguments:
+    #   klasses: (Array[Class]) an array of classes
+    #
+    # Returns:
+    #   (Array) All classes that are subclasses of one of the classes in klasses,
+    #           in a flattened array.
+    def subclasses_of_classes(klasses)
+      klasses.map { |klass|
+        subclasses_of_class klass
+      }.flatten
+    end
+
+    # Get the instance_methods of a class.
+    #
+    # Arguments:
+    #   klass: (Class) the class.
+    #
+    # Returns:
+    #   (Hash[Symbol, Array]) A hash, mapping method names to the results of
+    #                         ParseTree.translate.
+    def instance_methods_of(klass)
+      methods = {}
+      klass.instance_methods(false).each do |method_name|
+        translated = @parser_strategy.translate_instance_method(klass, method_name)
+        methods[method_name.to_sym] = translated
+      end
+
+      methods
+    end
+
+    # Install a method on a class. When object.method_name is called
+    # (for objects in the class), have them run the given code.
+    # TODO Should it be possible to recover the old method?
+    # How would that API look?
+    #
+    # 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 install_method_on_class(klass, method_code)
+      klass.class_eval method_code
+    end
+
+    # Install a method on an object. When object.method_name is called,
+    # runs the given code.
+    #
+    # This function can also be used for classmethods. For example, if you want
+    # to rewrite Klass.method_name (a method on Klass, a singleton Class),
+    # call this method (NOT install_method_on_class, that will modifiy objects
+    # created through Klass.new!)
+    #
+    # 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 install_method_on_instance(object, method_code)
+      object.instance_eval method_code
+    end
+  end
+end

data/lib/virtual_keywords/deep_copy_array.rb

@@ -0,0 +1,12 @@
+module VirtualKeywords
+  # Deeply copy an array.
+  #
+  # Arguments:
+  #   array: (Array[A]) the array to copy. A is any arbitrary type.
+  #
+  # Returns:
+  #   (Array[A]) a deep copy of the original array.
+  def self.deep_copy_array(array)
+    Marshal.load(Marshal.dump(array))
+  end
+end

data/lib/virtual_keywords/keyword_rewriter.rb

@@ -114,6 +114,28 @@ module VirtualKeywords
     end
   end
 
+  class NotRewriter < SexpProcessor
+    def initialize
+      super
+      self.strict = false
+    end
+
+    def rewrite_not(expression)
+      value = expression[1]
+
+      s(:call,
+        s(:colon2,
+          s(:const, :VirtualKeywords),
+          :REWRITTEN_KEYWORDS
+        ), :call_not,
+        s(:array,
+          s(:self),
+          s(:iter, s(:fcall, :lambda), nil, value)
+        )
+      )
+    end
+  end
+
   class UnexpectedSexp < StandardError
   end
 
@@ -148,4 +170,36 @@ module VirtualKeywords
       )
     end
   end
+
+  class UntilRewriter < SexpProcessor
+    def initialize
+      super
+      self.strict = false
+    end
+
+    def rewrite_until(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_until,
+        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/parser_strategy.rb

@@ -0,0 +1,40 @@
+module VirtualKeywords
+  class ParserStrategy
+    # Factory method
+    # Create the appropriate strategy object for the current Ruby version.
+    def self.new
+      if RUBY_VERSION.start_with? '1.8'
+        ParseTreeStrategy.new(ParseTree, SexpProcessor.new)
+      else
+        RubyParserStrategy.new(RubyParser.new)
+      end
+    end
+  end
+  # One problem that needs to be solved is that of converting source code form
+  # files into sexps.
+
+  # In Ruby 1.8, we use ParseTree and then SexpProcessor.
+  # In Ruby 1.9, we use RubyParser.
+  # Note that neither set of libraries seems to work in the other version.
+  # Use the strategy pattern, and initialize whichever class is appropriate.
+  class ParseTreeStrategy
+    def initialize(parse_tree, sexp_processor)
+      @parse_tree = parse_tree
+      @sexp_processor = sexp_processor
+    end
+
+    def translate_instance_method(klass, method_name)
+      @sexp_processor.process(@parse_tree.translate(klass, method_name))
+    end
+  end
+
+  class RubyParserStrategy
+    def initialize ruby_parser
+      @ruby_parser = ruby_parser
+    end
+
+    def translate_instance_method(klass, method_name)
+      @ruby_parser.parse(klass.instance_method(method_name).source)
+    end
+  end
+end

data/lib/virtual_keywords/rewritten_keywords.rb

@@ -144,6 +144,21 @@ module VirtualKeywords
       while_lambda = lambda_or_raise(caller_object, :while)
       while_lambda.call(condition, body)
     end
+
+    # Unlike unless, until IS a node in the AST
+    # (it doesn't turn into while not)
+    # For now, I'm passing this inconsistency through to the client.
+    # A later modification of this gem may fold while and until into one thing
+    # for consistency.
+    def call_until(caller_object, condition, body)
+      until_lambda = lambda_or_raise(caller_object, :until)
+      until_lambda.call(condition, body)
+    end
+
+    def call_not(caller_object, value)
+      not_lambda = lambda_or_raise(caller_object, :not)
+      not_lambda.call value
+    end
   end
 
 

data/lib/virtual_keywords/sexp_stringifier.rb

@@ -1,8 +1,4 @@
-require 'parse_tree'
-require 'ruby2ruby'
-
 module VirtualKeywords
-
   # Class that turns a sexp back into a string of Ruby code.
   class SexpStringifier
     # Initialize the SexpStringifier
@@ -23,7 +19,7 @@ module VirtualKeywords
     #
     # Returns:
     #   (String) Ruby code equivalent to the sexp.
-    def stringify(sexp)
+    def stringify sexp
       @ruby2ruby.process(@unifier.process(sexp))
     end
   end

data/lib/virtual_keywords/version.rb

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

data/lib/virtual_keywords/virtualizer.rb

@@ -1,100 +1,5 @@
 # Parent module containing all variables defined as part of virtual_keywords
 module VirtualKeywords
-
-  # Utility functions used to inspect the class hierarchy, and to view
-  # and modify methods of classes.
-  class ClassReflection
-    # Get the subclasses of a given class.
-    #
-    # Arguments:
-    #   parent: (Class) the class whose subclasses to find.
-    #
-    # Returns:
-    #   (Array) all classes which are subclasses of parent.
-    def self.subclasses_of_class(parent)
-      ObjectSpace.each_object(Class).select { |klass|
-        klass < parent
-      }
-    end
-
-    # Given an array of base classes, return a flat array of all their
-    # subclasses.
-    #
-    # Arguments:
-    #   klasses: (Array[Class]) an array of classes
-    #
-    # Returns:
-    #   (Array) All classes that are subclasses of one of the classes in klasses,
-    #           in a flattened array.
-    def self.subclasses_of_classes(klasses)
-      klasses.map { |klass|
-        subclasses_of_class klass
-      }.flatten
-    end
-
-    # Get the instance_methods of a class.
-    #
-    # Arguments:
-    #   klass: (Class) the class.
-    #
-    # Returns:
-    #   (Hash[Symbol, Array]) A hash, mapping method names to the results of
-    #                         ParseTree.translate.
-    def self.instance_methods_of(klass)
-      methods = {}
-      klass.instance_methods(false).each do |method_name|
-        translated = ParseTree.translate(klass, method_name)
-        methods[method_name] = translated
-      end
-
-      methods
-    end
-
-    # Install a method on a class. When object.method_name is called
-    # (for objects in the class), have them run the given code.
-    # TODO Should it be possible to recover the old method?
-    # How would that API look?
-    #
-    # 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 self.install_method_on_class(klass, method_code)
-      klass.class_eval method_code
-    end
-
-    # Install a method on an object. When object.method_name is called,
-    # runs the given code.
-    #
-    # This function can also be used for classmethods. For example, if you want
-    # to rewrite Klass.method_name (a method on Klass, a singleton Class),
-    # call this method (NOT install_method_on_class, that will modifiy objects
-    # created through Klass.new!)
-    #
-    # 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 self.install_method_on_instance(object, method_code)
-      object.instance_eval method_code
-    end
-  end
-
-  # Deeply copy an array.
-  #
-  # Arguments:
-  #   array: (Array[A]) the array to copy. A is any arbitrary type.
-  #
-  # Returns:
-  #   (Array[A]) a deep copy of the original array.
-  def self.deep_copy_array(array)
-    Marshal.load(Marshal.dump(array))
-  end
-
   # Object that virtualizes keywords.
   class Virtualizer
     # Initialize a Virtualizer
@@ -119,12 +24,15 @@ module VirtualKeywords
     #   or_rewriter: (OrRewriter) the SexpProcessor descendant that
     #       rewrites "or"s in methods (optional, the default is
     #       OrRewriter.new).
+    #   not_rewriter: (NotRewriter) the SexpProcessor descendant that
+    #       rewrites "not"s in methods (optional, the default is
+    #       NotRewriter.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).
+    #   until_rewriter: (UntilRewriter) the SexpProcessor descendant that
+    #       rewrites "until"s in methods (optional, the default is
+    #       UntilRewriter.new).
     #   sexp_stringifier: (SexpStringifier) an object that can turn sexps
     #       back into Ruby code (optional, the default is
     #       SexpStringifier.new).
@@ -139,26 +47,25 @@ 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
+      @not_rewriter = input_hash[:or_rewriter] || NotRewriter.new
       @while_rewriter = input_hash[:while_rewriter] || WhileRewriter.new
-      @sexp_processor = input_hash[:sexp_processor] || SexpProcessor.new
+      @until_rewriter = input_hash[:until_rewriter] || UntilRewriter.new
       @sexp_stringifier = input_hash[:sexp_stringifier] || SexpStringifier.new
       @rewritten_keywords =
           input_hash[:rewritten_keywords] || REWRITTEN_KEYWORDS
-      @class_reflection = input_hash[:class_reflection] || ClassReflection
+      @class_reflection = input_hash[:class_reflection] || ClassReflection.new
     end
 
     # Helper method to rewrite code.
     #
     # Arguments:
-    #   translated: (Array) the output of ParseTree.translate on the original
-    #       code
+    #   translated: (Sexp) the sexp for code
     #   rewriter: (SexpProcessor) the object that will rewrite the sexp, to
     #       virtualize the keywords.
-    def rewritten_code(translated, rewriter)
-      sexp = @sexp_processor.process(
-          VirtualKeywords.deep_copy_array(translated))
+    def rewritten_code(sexp, rewriter)
+      sexp_copy = VirtualKeywords.deep_copy_array sexp
       new_code = @sexp_stringifier.stringify(
-          rewriter.process(sexp))
+          rewriter.process(sexp_copy))
     end
 
     # Helper method to rewrite all methods of an object.
@@ -168,12 +75,12 @@ module VirtualKeywords
     #   keyword: (Symbol) the keyword to virtualize.
     #   rewriter: (SexpProcessor) the object that will do the rewriting.
     #   block: (Proc) the lambda that will replace the keyword.
-    def rewrite_methods_of_instance(instance, keyword, rewriter, block)
+    def rewrite_all_methods_of_instance(instance, keyword, rewriter, block)
       @rewritten_keywords.register_lambda_for_object(instance, keyword, block)
 
       methods = @class_reflection.instance_methods_of instance.class
-      methods.each do |name, translated|
-        new_code = rewritten_code(translated, rewriter)
+      methods.each do |name, sexp|
+        new_code = rewritten_code(sexp, rewriter)
         @class_reflection.install_method_on_instance(instance, new_code)
       end
     end
@@ -185,12 +92,12 @@ module VirtualKeywords
     #   keyword: (Symbol) the keyword to virtualize.
     #   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)
+    def rewrite_all_methods_of_class(klass, keyword, rewriter, block)
       @rewritten_keywords.register_lambda_for_class(klass, keyword, block)
 
       methods = @class_reflection.instance_methods_of klass
-      methods.each do |name, translated|
-        new_code = rewritten_code(translated, rewriter)
+      methods.each do |name, sexp|
+        new_code = rewritten_code(sexp, rewriter)
         @class_reflection.install_method_on_class(klass, new_code)
       end
     end
@@ -203,16 +110,16 @@ module VirtualKeywords
     #   block: (Proc) the lambda that will replace the keyword.
     def virtualize_keyword(keyword, rewriter, block)
       @for_instances.each do |instance|
-        rewrite_methods_of_instance(instance, keyword, rewriter, block)  
+        rewrite_all_methods_of_instance(instance, keyword, rewriter, block)  
       end 
 
       @for_classes.each do |klass|
-        rewrite_methods_of_class(klass, keyword, rewriter, block)
+        rewrite_all_methods_of_class(klass, keyword, rewriter, block)
       end
 
       subclasses = @class_reflection.subclasses_of_classes @for_subclasses_of
       subclasses.each do |subclass|
-        rewrite_methods_of_class(subclass, keyword, rewriter, block)
+        rewrite_all_methods_of_class(subclass, keyword, rewriter, block)
       end
     end
 
@@ -251,5 +158,13 @@ module VirtualKeywords
     def virtual_while(&block)
       virtualize_keyword(:while, @while_rewriter, block)
     end
+
+    def virtual_until(&block)
+      virtualize_keyword(:until, @until_rewriter, block)
+    end
+
+    def virtual_not(&block)
+      virtualize_keyword(:not, @not_rewriter, block)
+    end
   end
 end

data/lib/virtual_keywords.rb

@@ -1,8 +1,32 @@
-require 'virtual_keywords/sexp_stringifier'
-require 'virtual_keywords/class_mirrorer'
-require 'virtual_keywords/virtualizer'
-require 'virtual_keywords/keyword_rewriter'
-require 'virtual_keywords/rewritten_keywords'
+begin
+  require 'parse_tree' # 1.8
+rescue LoadError
+  # 1.9
+  require 'method_source'
+  require 'ruby_parser'
+  # HACK: parse_tree complains if I try to require it, but I do need the Unifier
+  # class from it. So, grab it from a local copy.
+  require_relative 'parsetree/lib/unified_ruby'
+end
+require 'ruby2ruby'
+
+if RUBY_VERSION.start_with? '1.8'
+  require 'virtual_keywords/deep_copy_array'
+  require 'virtual_keywords/parser_strategy'
+  require 'virtual_keywords/sexp_stringifier'
+  require 'virtual_keywords/class_reflection'
+  require 'virtual_keywords/virtualizer'
+  require 'virtual_keywords/keyword_rewriter'
+  require 'virtual_keywords/rewritten_keywords'
+else
+  require_relative 'virtual_keywords/deep_copy_array'
+  require_relative 'virtual_keywords/parser_strategy'
+  require_relative 'virtual_keywords/sexp_stringifier'
+  require_relative 'virtual_keywords/class_reflection'
+  require_relative 'virtual_keywords/virtualizer'
+  require_relative 'virtual_keywords/keyword_rewriter'
+  require_relative 'virtual_keywords/rewritten_keywords'
+end
 
 module VirtualKeywords
   class Foo
@@ -16,6 +40,8 @@ module VirtualKeywords
   end
 
   def self.sanity_test
+    # TODO See if there's a way to run the specs instead of this, when
+    # building the gem and requiring it
     virtualizer = Virtualizer.new(
         :for_classes => [Foo]
     )