virtual_keywords 0.0.0

data/lib/spec/virtualizer_spec.rb

@@ -0,0 +1,181 @@
+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
+
+    class MyClass
+      def foo
+        if (2 + 2) == 4 and false
+          :tampered_and
+        else
+          :original
+        end
+      end
+
+      def bar
+        if (2 + 2) == 4 or false        
+          :original
+        else
+          :tampered_or
+        end
+      end
+    end
+
+    class AnotherClass
+      def quux
+        if true then :right else :if_modified end
+      end
+    end
+
+    class YetAnotherClass < AnotherClass
+      def quux
+        if false then :if_modified else :right end
+      end
+    end
+
+    @my_class = MyClass.new
+    @another_class = AnotherClass.new
+    @yet_another_class = YetAnotherClass.new
+    @operator_user = OperatorUser.new false
+    @virtualizer = VirtualKeywords::Virtualizer.new(
+        :for_instances => [@greeter, @my_class]
+    )
+    @class_virtualizer = VirtualKeywords::Virtualizer.new(
+        :for_classes => [AnotherClass]
+    )
+    @subclass_virtualizer = VirtualKeywords::Virtualizer.new(
+        :for_subclasses_of => [AnotherClass]
+    )
+    @rails_subclass_virtualizer = VirtualKeywords::Virtualizer.new(
+        :for_subclasses_of =>  [ActiveRecord::Base, ApplicationController]
+    )
+  end 
+
+  it 'virtualizes "if" on instances' do
+    @virtualizer.virtual_if do |condition, then_do, else_do|
+      :clobbered_if 
+    end
+    result = @greeter.greet_if_else
+    result.should eql :clobbered_if
+  end
+
+  it 'virtualizes "and" on instances' do
+    @virtualizer.virtual_and do |first, second|
+      first.call or second.call
+    end
+    @my_class.foo.should eql :tampered_and
+  end
+
+  it 'virtualizes "or" on instances' do
+    @virtualizer.virtual_or do |first, second|
+      first.call and second.call
+    end
+    @my_class.bar.should eql :tampered_or
+  end
+
+  it 'virtualizes "if" on classes' do
+    @class_virtualizer.virtual_if do |condition, then_do, else_do|
+      if not condition.call   
+        then_do.call
+      else
+        else_do.call
+      end
+    end  
+
+    @another_class.quux.should eql :if_modified
+  end
+
+  it 'virtualizes "if" on subclasses of given classes' do
+    @subclass_virtualizer.virtual_if do |condition, then_do, else_do|
+      if not condition.call   
+        then_do.call
+      else
+        else_do.call
+      end
+    end  
+
+    # AnotherClass shouldn't be modified, it's not a subclass of itself
+    @another_class.quux.should eql :right
+    @yet_another_class.quux.should eql :if_modified
+  end
+end

data/lib/virtual_keywords/class_mirrorer.rb

@@ -0,0 +1,39 @@
+module VirtualKeywords
+  # Simple data object holding a Class and the name of one of its methods
+  ClassAndMethodName = Struct.new(:klass, :method_name)
+
+  # Class that takes classes and "mirrors" them, by parsing their methods
+  # and storing the results.
+  class ClassMirrorer
+    # Initialize a ClassMirrorer
+    #
+    # Arguments:
+    #   parser: (Class) an object with a method translate, that takes a class
+    #           and method name, and returns a syntax tree that can be
+    #           sexpified (optional, uses ParseTree by default).
+    def initialize(parser = ParseTree)
+      @parser = parser
+    end
+
+    # Map ClassAndMethodNames to outputs of parser.translate
+    #
+    # Arguments:
+    #   klasses: (Array[Class]) the classes to mirror.
+    #
+    # Returns:
+    #   (Hash[ClassAndMethodName, Array]) a hash mapping every method of every
+    #   class to parsed output.
+    def mirror(klasses)
+      methods = {}
+      klasses.each do |klass|
+        klass.instance_methods.each do |method_name|
+          key = ClassAndMethodName.new(klass, method_name)
+          translated = @parser.translate(klass, method_name)
+          methods[key] = translated
+        end 
+      end
+
+      methods
+    end
+  end
+end

data/lib/virtual_keywords/keyword_rewriter.rb

@@ -0,0 +1,108 @@
+module VirtualKeywords
+  class IfRewriter < SexpProcessor
+    # Initialize an IfRewriter (self.strict is false)
+    def initialize
+      super
+      self.strict = false
+    end
+
+    # Rewrite an :if sexp. SexpProcessor#process is a template method that will
+    # call this method every time it encounters an :if.
+    #
+    # Arguments:
+    #   expression: (Sexp) the :if sexp to be rewritten.
+    #
+    # Returns:
+    #   (Sexp) A rewritten sexp that calls
+    #   VirtualKeywords::REWRITTEN_KEYWORDS.call_if with the condition,
+    #   then clause, and else clause as arguments, all wrapped in lambdas.
+    #   It must also pass self to call_if, so REWRITTEN_KEYWORDS can decide
+    #   which of the lambdas registered with it should be called.
+    def rewrite_if(expression)
+      # The sexp for the condition passed to if is inside expression[1]
+      # We can further process this sexp if it has and/or in it.
+      condition = expression[1]
+      then_do = expression[2]
+      else_do = expression[3]
+
+      s(:call,
+        s(:colon2,
+          s(:const, :VirtualKeywords),
+          :REWRITTEN_KEYWORDS
+        ), :call_if,
+        s(:array,
+          s(:self),
+          s(:iter, s(:fcall, :lambda), nil, condition),
+          s(:iter, s(:fcall, :lambda), nil, then_do),
+          s(:iter, s(:fcall, :lambda), nil, else_do)
+        )
+      )
+    end
+  end
+
+  # Helper method. Call a 2-argument function used to replace an operator
+  # (like "and" or "or")
+  #
+  # Arguments:
+  #   method_name: (Symbol) the name of the REWRITTEN_KEYWORDS method that
+  #                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. 
+  #   second: (Sexp) the second argument to the method, which should be
+  #            wrapped in a lambda then passed to REWRITTEN_KEYWORDS. 
+  def self.call_operator_replacement(function_name, first, second)
+    s(:call,
+      s(:colon2,
+        s(:const, :VirtualKeywords),
+        :REWRITTEN_KEYWORDS
+      ), function_name,
+      s(:array,
+        s(:self),
+        s(:iter, s(:fcall, :lambda), nil, first),
+        s(:iter, s(:fcall, :lambda), nil, second)
+      )
+    )
+  end
+
+  class AndRewriter < SexpProcessor
+    def initialize
+      super
+      self.strict = false
+    end
+
+    # Rewrite "and" expressions (automatically called by SexpProcessor#process)
+    #
+    # Arguments:
+    #   expression: (Sexp) the :and sexp to rewrite.
+    #
+    # Returns:
+    #   (Sexp): a sexp that instead calls REWRITTEN_KEYWORDS.call_and
+    def rewrite_and(expression)
+      first = expression[1]
+      second = expression[2]
+
+      VirtualKeywords.call_operator_replacement(:call_and, first, second)
+    end
+  end
+
+  class OrRewriter < SexpProcessor
+    def initialize
+      super
+      self.strict = false
+    end
+  
+    # Rewrite "or" expressions (automatically called by SexpProcessor#process)
+    #
+    # Arguments:
+    #   expression: (Sexp) the :or sexp to rewrite.
+    #
+    # Returns:
+    #   (Sexp): a sexp that instead calls REWRITTEN_KEYWORDS.call_or
+    def rewrite_or(expression)
+      first = expression[1]
+      second = expression[2]
+
+      VirtualKeywords.call_operator_replacement(:call_or, first, second)
+    end
+  end
+end

data/lib/virtual_keywords/rewritten_keywords.rb

@@ -0,0 +1,141 @@
+module VirtualKeywords
+
+  # Simple data object holding an object and a Ruby keyword (as a symbol)
+  ObjectAndKeyword = Struct.new(:object, :keyword)
+
+  # Exception raised when a client tries to call the rewritten version of a
+  # keyword, but no lambda was provided for the given object and keyword.
+  class RewriteLambdaNotProvided < StandardError
+  end
+
+  # Class holding the lambdas to call in place of keywords.
+  # Different classes can have their own set of "virtualized keywords".
+  class RewrittenKeywords
+
+    # Initialize a RewrittenKeywords
+    #
+    # 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).
+    def initialize(input)
+      @predicates_to_blocks = input[:predicates_to_blocks] || {}
+    end
+
+    # Register (save) a lambda to be called for a specific object.
+    #
+    # Arguments:
+    #   object: (Object) the object whose methods will have their keyword
+    #           virtualized.
+    #   keyword: (Symbol) the keyword that will be virtualized
+    #   a_lambda: (Proc) The lambda to be called in place of the keyword.
+    def register_lambda_for_object(object, keyword, a_lambda)
+      predicate = lambda { |input|
+        input.object == object and input.keyword == keyword
+      }
+      @predicates_to_blocks[predicate] = a_lambda
+    end
+
+    # Register a lambda to be called for all objects created from a class.
+    # The predicate will match for all objects that are initialized with
+    # the class (but not if they are from subclasses)
+    #
+    # Arguments:
+    #   klass: (Class) the class whose objects will have their methods
+    #          virtualized.
+    #   keyword: (Symbol) the keyword that will be virtualized
+    #   a_lambda: (Proc) The lambda to be called in place of the keyword.
+    def register_lambda_for_class(klass, keyword, a_lambda)
+      predicate = lambda { |input|
+        input.object.instance_of?(klass) and input.keyword == keyword
+      }
+      @predicates_to_blocks[predicate] = a_lambda
+    end
+
+    # Get the virtual lambda to call for the given input, or raise an
+    # exception if it's not there.
+    #
+    # Arguments:
+    #   caller_object: (Object) the object part of the ObjectAndKeyword
+    #   keyword: (Symbol) they keyword part of the ObjectAndKeyword
+    #
+    # Returns:
+    #   The lambda to call for that object's keyword, if the object and keyword
+    #   matched any of the predicates.
+    #
+    # Raises:
+    #   RewriteLambdaNotProvided if no predicate returns true for
+    #   ObjectAndKeyword.
+    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)
+      }
+
+      if matching.nil?
+        raise RewriteLambdaNotProvided, 'A rewrite was requested for ' +
+            "#{caller_object}'s #{keyword} expressions, but there's no" +
+            'lambda for it.'
+      end
+
+      @predicates_to_blocks[matching]
+    end
+
+    # Call an if virtual block in place of an actual if expression.
+    # This function locates the lambda registered with the given object.
+    #
+    # 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.
+    #   then_do: (Proc) the lambda to execute if the condition is true (but
+    #            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)
+    #
+    # Raises:
+    #   RewriteLambdaNotProvided if no "if" lambda is available.
+    def call_if(caller_object, condition, then_do, else_do)
+      if_lambda = lambda_or_raise(caller_object, :if)
+      if_lambda.call(condition, then_do, else_do)
+    end
+
+    # Call an "and" virtual block in place of an "and" expression.
+    #
+    # Arguments:
+    #   caller_object: (Object) the object whose method this is being called in.
+    #   first: (Proc) The first operand of the "and", wrapped in a lambda.   
+    #   second: (Proc) The second operand of the "and", wrapped in a lambda.   
+    #   
+    # Raises:
+    #   RewriteLambdaNotProvided if no "and" lambda is available.
+    def call_and(caller_object, first, second)
+      and_lambda = lambda_or_raise(caller_object, :and)
+      and_lambda.call(first, second)
+    end
+
+    # Call an "or" virtual block in place of an "or" expression.
+    #
+    # Arguments:
+    #   caller_object: (Object) the object whose method this is being called in.
+    #   first: (Proc) The first operand of the "or", wrapped in a lambda.   
+    #   second: (Proc) The second operand of the "or", wrapped in a lambda.   
+    #   
+    # Raises:
+    #   RewriteLambdaNotProvided if no "or" lambda is available.
+    def call_or(caller_object, first, second)
+      or_lambda = lambda_or_raise(caller_object, :or)
+      or_lambda.call(first, second)
+    end
+  end
+
+
+  # The global instance of RewrittenKeywords that will be used.
+  # I don't normally like using global variables, but in this case
+  # we need a global point of access, because we can't always control the
+  # scope in which methods are executed.
+  REWRITTEN_KEYWORDS = RewrittenKeywords.new({})
+end

data/lib/virtual_keywords/sexp_stringifier.rb

@@ -0,0 +1,30 @@
+require 'parse_tree'
+require 'ruby2ruby'
+
+module VirtualKeywords
+
+  # Class that turns a sexp back into a string of Ruby code.
+  class SexpStringifier
+    # Initialize the SexpStringifier
+    #
+    # Arguments:
+    #   unifier: (Unifier) a Unifier, used by ParseTree/ruby2ruby (optional)
+    #   ruby2ruby: (Ruby2Ruby) a Ruby2Ruby, used by ParseTree/ruby2ruby
+    #              (optional)
+    def initialize(unifier = Unifier.new, ruby2ruby = Ruby2Ruby.new)
+      @unifier = unifier
+      @ruby2ruby = ruby2ruby
+    end
+
+    # Turn a sexp into a string of Ruby code.
+    #
+    # Arguments:
+    #   sexp: (Sexp) the sexp to be stringified.
+    #
+    # Returns:
+    #   (String) Ruby code equivalent to the sexp.
+    def stringify(sexp)
+      @ruby2ruby.process(@unifier.process(sexp))
+    end
+  end
+end

data/lib/virtual_keywords/version.rb

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