virtual_keywords 0.3.0 → 0.3.1

data/lib/spec/class_mirrorer_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'ClassMirrorer' do
+  before :each do
+    @stub_parser = double 'parser'
+    @mirrorer = VirtualKeywords::ClassMirrorer.new :parser => @stub_parser
+  end
+
+  it 'mirrors given classes' do
+    @stub_parser.stub(:translate_instance_method).and_return :translated
+    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/micro_sql_dsl_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe 'micro SQL DSL rewriting' do
+  include TrackIfs, TrackAnds, TrackOrs, DoRewrite
+
+  before :each do
+    # Here, MicroSqlUser is the consumer of the DSL.
+    @user = MicroSqlUser.new
+
+    @methods = sexpify_instance_methods MicroSqlUser
+    @if_rewriter = VirtualKeywords::IfRewriter.new
+    @and_rewriter = VirtualKeywords::AndRewriter.new
+    @or_rewriter = VirtualKeywords::OrRewriter.new
+
+    @my_if_calls = 0
+    @my_and_calls = 0
+    @my_or_calls = 0
+
+    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
+        @user, :if, my_if)
+    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
+        @user, :and, my_and)
+    VirtualKeywords::REWRITTEN_KEYWORDS.register_lambda_for_object(
+        @user, :or, my_or)
+  end
+
+  def rewriters
+    [@if_rewriter, @and_rewriter, @or_rewriter]
+  end
+
+  it 'rewrites postfix if in the SQL DSL' do
+    do_rewrite(:select_with_where, @user, verbose = false,
+        old_and_new_are_same = false)
+    @my_if_calls.should eql 1
+  end
+
+  it 'rewrites if with or in the SQL DSL' do
+    do_rewrite(:select_with_or, @user, verbose = false,
+        old_and_new_are_same = false)
+    @my_if_calls.should eql 1 
+    @my_or_calls.should eql 1
+  end
+
+  it 'rewrites complex conditionals in the SQL DSL' do
+    do_rewrite(:select_complex, @user, verbose = false,
+        old_and_new_are_same = false)
+    @my_if_calls.should eql 1 
+    @my_and_calls.should eql 1
+    @my_or_calls.should eql 1
+  end
+end
+
+describe 'micro SQL DSL virtualizing' do
+  before :each do
+    # Here, MicroSqlUser is the consumer of the DSL.
+    @user = MicroSqlUser.new
+    Sql.dslify @user
+  end
+
+  it 'generates basic select statements' do
+    result_sql = @user.simple_select
+    result_sql.should eql 'select (name,post_ids) from users'
+  end
+
+  it 'generates select-where statements' do
+    result_sql = @user.select_with_where
+
+    result_sql.should eql 'select (name,post_ids) from users where name="rahul"'
+  end
+
+  it 'generates select-where with "or" statements' do
+    result_sql = @user.select_with_or
+    result_sql.should eql 'select (name,post_ids) from users where ' +
+        'name="rahul" or name="Rahul Rajagopalan"'
+  end
+end

data/lib/spec/spec_helper.rb

@@ -16,6 +16,7 @@ require 'virtualizees/operator_user'
 require 'virtualizees/while_user'
 require 'virtualizees/until_user'
 require 'virtualizees/case_when_user'
+require 'virtualizees/micro_sql_dsl'
 
 require 'rspec'
 
@@ -120,10 +121,11 @@ module DoRewrite
   # Override this and return a list of rewriters, in order, so do_rewrite
   # can call them
   def rewriters
-    raise Abstract
+    raise Abstract, 'Must provide rewriters!'
   end
 
-  def do_rewrite(method_name, object, verbose = false)
+  def do_rewrite(method_name, object, verbose = false,
+                 old_and_new_are_same = true)
     sexp = @methods[method_name]
     # Run all rewriters on the sexp
     result = rewriters.reduce(sexp) { |rewritee, rewriter|
@@ -141,11 +143,14 @@ module DoRewrite
     # old and new code should produce the same result,
     # except that @my_*_calls is incremented
     old_result = object.send method_name
-    VirtualKeywords::ClassReflection.new.install_method_on_instance(
-        object, code_result)
+    object.instance_eval code_result
+    #VirtualKeywords::ClassReflection.new.install_method_on_instance(
+         #object, code_result)
     new_result = object.send method_name
 
-    new_result.should eql old_result
+    if old_and_new_are_same
+      new_result.should eql old_result
+    end
   end
 end
 

data/lib/spec/virtualizees/micro_sql_dsl.rb

@@ -0,0 +1,110 @@
+class Sql
+  def self.select(columns, options)
+    column_names = columns.join ','
+    table_name = options[:from]
+
+    "select (#{column_names}) from #{table_name}"
+  end
+
+  def self.dslify object
+    virtualizer = VirtualKeywords::Virtualizer.new :for_instances => [object]
+
+    virtualizer.virtual_if do |condition, then_do, else_do|
+      # In this DSL, all "if"s are postfix and have no else clause.
+      "#{then_do.call} where #{condition.call}"
+    end
+
+    virtualizer.virtual_or do |first, second|
+      "#{first.call} or #{second.call}"
+    end
+  end
+end
+
+class MicroSqlUser
+  # First version, just using built-in syntatic sugar: optional parentheses
+  # and braces around hashes.
+  def simple_select
+    # Limitation: the parser can't handle the new hash syntax
+    # (so here we use the old one)
+    Sql::select [:name, :post_ids], :from => :users
+  end
+
+  # Ok, now mix in some VirtualKeywords!
+  # Use postfix "if" to stand in for "where" clauses. It should look
+  # gramatically similar to SQL, just with "if" instead of "where".
+  #
+  # Calling virtual_if should turn this method into:
+  #
+  # name_is_rahul = 'name="rahul"' 
+  # VirtualKeywords::REWRITTEN_KEYWORDS.call_if(
+  #     self,
+  #     lambda { Sql::select [:name, :post_ids], :from=> :users },
+  #     lambda { name_is_rahul },
+  #     lambda {}
+  # )
+  def select_with_where
+    # Limitation: 'name="rahul"' is in quotes (we can't actually get
+    # AST nodes because virtual_keywords hides them.)
+    
+    # Using the string literal directly is valid Ruby, but produces
+    # an annoying warning.
+    name_is_rahul = 'name="rahul"' 
+    Sql::select [:name, :post_ids], :from => :users if name_is_rahul
+  end
+
+  # Should turn into:
+  # def select_with_or
+  #   name_is_rahul = "name=\"rahul\""
+  #   is_full_name = "name=\"Rahul Rajagopalan\""
+  #   VirtualKeywords::REWRITTEN_KEYWORDS.call_if(
+  #      self,
+  #      lambda do
+  #        VirtualKeywords::REWRITTEN_KEYWORDS.call_or(
+  #            self,
+  #            lambda { name_is_rahul },
+  #            lambda { is_full_name }
+  #        )
+  #      end,
+  #      lambda { Sql.select([:name, :post_ids], :from => :users) },
+  #      lambda { }
+  #  )
+  # end
+  def select_with_or
+    name_is_rahul = 'name="rahul"' 
+    is_full_name = 'name="Rahul Rajagopalan"'
+    Sql::select [:name, :post_ids], :from => :users if
+        name_is_rahul or is_full_name
+  end
+
+  # Should turn into:
+  # def select_complex
+  #   name_is_rahul = "name=\"rahul\""
+  #   right_id = "id=5"
+  #   is_full_name = "name=\"Rahul Rajagopalan\""
+  #   VirtualKeywords::REWRITTEN_KEYWORDS.call_if(
+  #       self,
+  #       lambda do
+  #         VirtualKeywords::REWRITTEN_KEYWORDS.call_or(
+  #             self,
+  #             lambda do
+  #               VirtualKeywords::REWRITTEN_KEYWORDS.call_and(
+  #                   self,
+  #                   lambda { name_is_rahul },
+  #                   lambda { right_id }
+  #               )
+  #             end,
+  #             lambda { is_full_name }
+  #         )
+  #       end,
+  #       lambda { Sql.select([:name, :post_ids], :from => :users) },
+  #       lambda { }
+  #   )
+  # end
+  def select_complex
+    name_is_rahul = 'name="rahul"' 
+    right_id = 'id=5'
+    is_full_name = 'name="Rahul Rajagopalan"'
+    Sql::select [:name, :post_ids], :from => :users if
+        name_is_rahul and right_id or is_full_name
+  end
+end

data/lib/spec/virtualizer_spec.rb

@@ -164,4 +164,20 @@ describe 'Virtualizer' do
     result = @inverter.run true
     result.should be_true
   end
+
+  it 'virtualizes multiple keywords in the same method' do
+    if_calls = 0
+    and_calls = 0
+    @virtualizer.virtual_if do |condition, then_do, else_do|
+      if_calls += 1
+      if condition.call then then_do.call else else_do.call end
+    end
+    @virtualizer.virtual_and do |first, second|
+      and_calls += 1
+      first.call and second.call
+    end
+    @my_class.foo
+    if_calls.should eql 1
+    and_calls.should eql 1
+  end
 end

data/lib/virtual_keywords.rb

@@ -12,6 +12,7 @@ require 'ruby2ruby'
 
 if RUBY_VERSION.start_with? '1.8'
   require 'virtual_keywords/deep_copy_array'
+  require 'virtual_keywords/class_mirrorer'
   require 'virtual_keywords/parser_strategy'
   require 'virtual_keywords/sexp_stringifier'
   require 'virtual_keywords/class_reflection'
@@ -20,6 +21,7 @@ if RUBY_VERSION.start_with? '1.8'
   require 'virtual_keywords/rewritten_keywords'
 else
   require_relative 'virtual_keywords/deep_copy_array'
+  require_relative 'virtual_keywords/class_mirrorer'
   require_relative 'virtual_keywords/parser_strategy'
   require_relative 'virtual_keywords/sexp_stringifier'
   require_relative 'virtual_keywords/class_reflection'

data/lib/virtual_keywords/class_mirrorer.rb

@@ -0,0 +1,37 @@
+module VirtualKeywords
+  # Simple data object holding a Class and the name of one of its methods
+  ClassAndMethodName = Struct.new(:klass, :method_name)
+
+  # ClassMirrorer that uses ParseTree (Ruby 1.8)
+  class ClassMirrorer
+    # Initialize a ParseTreeClassMirrorer
+    #
+    # Arguments:
+    #   An options Hash with the following key
+    #     parser: (ParserStrategy) an object with a method translate, that takes
+    #         a class and method name, and returns a syntax tree that can be
+    #         sexpified (optional, the default is ParserStrategy.new)
+    def initialize options
+      @parser = options[:parser] || ParserStrategy.new
+    end
+
+    # Map ClassAndMethodNames to sexps
+    #
+    # Arguments:
+    #   klass: (Class) the class to mirror.
+    #
+    # Returns:
+    #   (Hash[ClassAndMethodName, Sexp]) a hash mapping every method of the
+    #   class to parsed output.
+    def mirror klass
+      methods = {}
+      klass.instance_methods(false).each do |method_name|
+        key = ClassAndMethodName.new(klass, method_name)
+        translated = @parser.translate_instance_method(klass, method_name)
+        methods[key] = translated
+      end
+
+      methods
+    end
+  end
+end

data/lib/virtual_keywords/class_reflection.rb

@@ -2,6 +2,10 @@ module VirtualKeywords
   # Object used to inspect the class hierarchy, and to view
   # and modify methods of classes.
   class ClassReflection
+    # Create a new ClassReflection
+    # Arguments:
+    #   parser_strategy: (ParserStrategy) the strategy object to use to parse
+    #       methods. (Optional, the default value is ParserStrategy.new)
     def initialize(parser_strategy = ParserStrategy.new)
       @parser_strategy = parser_strategy
     end
@@ -27,7 +31,7 @@ module VirtualKeywords
     #
     # Returns:
     #   (Array) All classes that are subclasses of one of the classes in klasses,
-    #           in a flattened array.
+    #       in a flattened array.
     def subclasses_of_classes(klasses)
       klasses.map { |klass|
         subclasses_of_class klass

data/lib/virtual_keywords/keyword_rewriter.rb

@@ -114,12 +114,20 @@ module VirtualKeywords
     end
   end
 
+  # SexpProcessor subclass that rewrites "not" expressions.
   class NotRewriter < SexpProcessor
     def initialize
       super
       self.strict = false
     end
 
+    # Rewrite "not" expressions (automatically called by SexpProcessor#process)
+    #
+    # Arguments:
+    #   expression: (Sexp) the :not sexp to rewrite.
+    #
+    # Returns:
+    #   (Sexp): a sexp that instead calls REWRITTEN_KEYWORDS.call_not
     def rewrite_not(expression)
       value = expression[1]
 
@@ -136,15 +144,24 @@ module VirtualKeywords
     end
   end
 
+  # Raised if a rewriter encounters an unexpected sexp, indicating a bug.
   class UnexpectedSexp < StandardError
   end
 
+  # SexpProcessor subclass that rewrites "while" expressions.
   class WhileRewriter < SexpProcessor
     def initialize
       super
       self.strict = false
     end
 
+    # Rewrite "while" expressions (automatically called by SexpProcessor#process)
+    #
+    # Arguments:
+    #   expression: (Sexp) the :while sexp to rewrite.
+    #
+    # Returns:
+    #   (Sexp): a sexp that instead calls REWRITTEN_KEYWORDS.call_while
     def rewrite_while(expression)
       condition = expression[1]
       body = expression[2]
@@ -171,12 +188,20 @@ module VirtualKeywords
     end
   end
 
+  # SexpProcessor subclass that rewrites "until" expressions.
   class UntilRewriter < SexpProcessor
     def initialize
       super
       self.strict = false
     end
 
+    # Rewrite "until" expressions (automatically called by SexpProcessor#process)
+    #
+    # Arguments:
+    #   expression: (Sexp) the :until sexp to rewrite.
+    #
+    # Returns:
+    #   (Sexp): a sexp that instead calls REWRITTEN_KEYWORDS.call_until
     def rewrite_until(expression)
       condition = expression[1]
       body = expression[2]

data/lib/virtual_keywords/parser_strategy.rb

@@ -10,6 +10,7 @@ module VirtualKeywords
       end
     end
   end
+
   # One problem that needs to be solved is that of converting source code form
   # files into sexps.
 
@@ -17,22 +18,48 @@ module VirtualKeywords
   # 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.
+
+  # Parser strategy that uses ParseTree
   class ParseTreeStrategy
+    # Initialize a ParseTreeStrategy
+    #
+    # Arguments:
+    #   parse_tree: (Class) an instance of the ParseTree singleton, that
+    #       translates code into ParseTree output.
+    #   sexp_processor: (SexpProcessor) an object that translates ParseTree
+    #       output into rewriteable sexps.
     def initialize(parse_tree, sexp_processor)
       @parse_tree = parse_tree
       @sexp_processor = sexp_processor
     end
 
+    # Translate an instance method of a class.
+    # 
+    # Arguments:
+    #   klass: (Class) the class.
+    #   method_name: (String) the name of the method to translate.
+    #
+    # Returns:
+    #   (Sexp) the method, turned into a sexp.
     def translate_instance_method(klass, method_name)
       @sexp_processor.process(@parse_tree.translate(klass, method_name))
     end
   end
 
+  # Parser strategy that uses ruby_parser
   class RubyParserStrategy
     def initialize ruby_parser
       @ruby_parser = ruby_parser
     end
 
+    # Translate an instance method of a class.
+    # 
+    # Arguments:
+    #   klass: (Class) the class.
+    #   method_name: (String) the name of the method to translate.
+    #
+    # Returns:
+    #   (Sexp) the method, turned into a sexp.
     def translate_instance_method(klass, method_name)
       @ruby_parser.parse(klass.instance_method(method_name).source)
     end

data/lib/virtual_keywords/rewritten_keywords.rb

@@ -130,7 +130,7 @@ module VirtualKeywords
       or_lambda.call(first, second)
     end
 
-    # Call a "while" virtual block in place of an "while" expression.
+    # Call a "while" virtual block in place of a "while" expression.
     #
     # Arguments:
     #   caller_object: (Object) the object whose method this is being called in.
@@ -145,16 +145,35 @@ module VirtualKeywords
       while_lambda.call(condition, body)
     end
 
+    # Call an "until" virtual block in place of an "until" expression.
     # 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.
+    #
+    # Arguments:
+    #   caller_object: (Object) the object whose method this is being called in.
+    #   condition: (Proc) The condition of the until expression.
+    #   body: (Proc) The body of the until expression (which is normally
+    #       executed repeatedly)
+    #   
+    # Raises:
+    #   RewriteLambdaNotProvided if no "until" lambda is available.
     def call_until(caller_object, condition, body)
       until_lambda = lambda_or_raise(caller_object, :until)
       until_lambda.call(condition, body)
     end
 
+    # Call a "not" virtual block in place of a "not" expression.
+    #
+    # Arguments:
+    #   caller_object: (Object) the object whose method this is being called in.
+    #   value: (Proc) The operand of the not operator, which would normally be
+    #       inverted.
+    #   
+    # Raises:
+    #   RewriteLambdaNotProvided if no "not" lambda is available.
     def call_not(caller_object, value)
       not_lambda = lambda_or_raise(caller_object, :not)
       not_lambda.call value

data/lib/virtual_keywords/sexp_stringifier.rb

@@ -13,6 +13,7 @@ module VirtualKeywords
     end
 
     # Turn a sexp into a string of Ruby code.
+    # Makes a copy first so the inputted sexp is not emptied.
     #
     # Arguments:
     #   sexp: (Sexp) the sexp to be stringified.
@@ -20,7 +21,8 @@ module VirtualKeywords
     # Returns:
     #   (String) Ruby code equivalent to the sexp.
     def stringify sexp
-      @ruby2ruby.process(@unifier.process(sexp))
+      sexp_copy = VirtualKeywords.deep_copy_array sexp
+      @ruby2ruby.process(@unifier.process(sexp_copy))
     end
   end
 end

data/lib/virtual_keywords/version.rb

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

data/lib/virtual_keywords/virtualizer.rb

@@ -1,11 +1,18 @@
 # Parent module containing all variables defined as part of virtual_keywords
 module VirtualKeywords
+
+  class NoSuchInstance < StandardError
+  end
+
+  class NoSuchClass < StandardError
+  end
+
   # Object that virtualizes keywords.
   class Virtualizer
     # Initialize a Virtualizer
     # 
     # Arguments:
-    #   A Hash with the following arguments (all optional):
+    #   A Hash with the following key-value pairs (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).
@@ -54,6 +61,34 @@ module VirtualKeywords
       @rewritten_keywords =
           input_hash[:rewritten_keywords] || REWRITTEN_KEYWORDS
       @class_reflection = input_hash[:class_reflection] || ClassReflection.new
+      @class_mirrorer = input_hash[:class_mirrorer] || ClassMirrorer.new({})
+
+      @sexps_for_classes = {}
+      @sexps_for_instances = {}
+      # TODO Refactor out work in the constructor
+      # and maybe move the sexp storage elsewhere.
+      parse_all_the_classes
+    end
+
+    def parse_all_the_classes
+      # Well, not _all_, just the ones provided in the constructor..
+      @for_classes.each do |klass|
+        @sexps_for_classes[klass] = @class_mirrorer.mirror klass
+      end
+      @for_instances.each do |instance|
+        @sexps_for_instances[instance] = @class_mirrorer.mirror instance.class
+      end
+      @for_subclasses_of.each do |klass|
+        subclasses = @class_reflection.subclasses_of_class klass
+        subclasses.each do |subclass|
+          @sexps_for_classes[subclass] = @class_mirrorer.mirror subclass
+        end
+      end
+    end
+
+    def rewritten_sexp(sexp, rewriter)
+      sexp_copy = VirtualKeywords.deep_copy_array sexp
+      rewriter.process sexp_copy 
     end
 
     # Helper method to rewrite code.
@@ -78,11 +113,20 @@ module VirtualKeywords
     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, sexp|
-        new_code = rewritten_code(sexp, rewriter)
+      if not @sexps_for_instances.include? instance
+        raise NoSuchInstance, "Tried to rewrite methods of #{instance}," +
+            "but it's not there!"
+      end
+      mirror_hash = @sexps_for_instances[instance]
+      new_mirror_hash = {}
+      mirror_hash.each do |class_and_method_name, sexp|
+        new_sexp = rewritten_sexp(sexp, rewriter)
+        new_code = @sexp_stringifier.stringify new_sexp
         @class_reflection.install_method_on_instance(instance, new_code)
+        # Save the modified sexp for the next go
+        new_mirror_hash[class_and_method_name] = new_sexp
       end
+      @sexps_for_instances[instance] = new_mirror_hash
     end
 
     # Helper method to rewrite all methods of objects from a class.
@@ -95,11 +139,19 @@ module VirtualKeywords
     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, sexp|
-        new_code = rewritten_code(sexp, rewriter)
+      if not @sexps_for_classes.include? klass
+        raise NoSuchInstance, "Tried to rewrite methods of #{klass}," +
+            "but it's not there!"
+      end
+      mirror_hash = @sexps_for_classes[klass]
+      new_mirror_hash = {}
+      mirror_hash.each do |class_and_method_name, sexp|
+        new_sexp = rewritten_sexp(sexp, rewriter)
+        new_code = @sexp_stringifier.stringify new_sexp
         @class_reflection.install_method_on_class(klass, new_code)
+        new_mirror_hash[class_and_method_name] = new_sexp
       end
+      @sexps_for_classes[klass] = new_mirror_hash
     end
 
     # Helper method to virtualize a keyword (rewrite with the given block)
@@ -150,6 +202,15 @@ module VirtualKeywords
       virtualize_keyword(:or, @or_rewriter, block)
     end
 
+    # Rewrite "not" expressions.
+    #
+    # Arguments:
+    #   &block: The block that will replace "not"s in the objects being
+    #       virtualized
+    def virtual_not(&block)
+      virtualize_keyword(:not, @not_rewriter, block)
+    end
+
     # Rewrite "while" expressions.
     #
     # Arguments:
@@ -159,12 +220,13 @@ module VirtualKeywords
       virtualize_keyword(:while, @while_rewriter, block)
     end
 
+    # Rewrite "until" expressions.
+    #
+    # Arguments:
+    #   &block: The block that will replace "until"s in the objects being
+    #       virtualized
     def virtual_until(&block)
       virtualize_keyword(:until, @until_rewriter, block)
     end
-
-    def virtual_not(&block)
-      virtualize_keyword(:not, @not_rewriter, block)
-    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: virtual_keywords
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &4909200 !ruby/object:Gem::Requirement
+  requirement: &10217980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *4909200
+  version_requirements: *10217980
 - !ruby/object:Gem::Dependency
   name: sexp_processor
-  requirement: &4908420 !ruby/object:Gem::Requirement
+  requirement: &10216740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *4908420
+  version_requirements: *10216740
 - !ruby/object:Gem::Dependency
   name: ParseTree
-  requirement: &4907600 !ruby/object:Gem::Requirement
+  requirement: &10216300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *4907600
+  version_requirements: *10216300
 - !ruby/object:Gem::Dependency
   name: ruby2ruby
-  requirement: &4906840 !ruby/object:Gem::Requirement
+  requirement: &10215780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *4906840
+  version_requirements: *10215780
 - !ruby/object:Gem::Dependency
   name: method_source
-  requirement: &4906180 !ruby/object:Gem::Requirement
+  requirement: &10215360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *4906180
+  version_requirements: *10215360
 - !ruby/object:Gem::Dependency
   name: ruby_parser
-  requirement: &5415440 !ruby/object:Gem::Requirement
+  requirement: &10214920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,13 +76,14 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *5415440
+  version_requirements: *10214920
 description: Replace keyword implementations with your own functions, for DSLs
 email: rahulrajago@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/virtual_keywords/class_mirrorer.rb
 - lib/virtual_keywords/class_reflection.rb
 - lib/virtual_keywords/sexp_stringifier.rb
 - lib/virtual_keywords/rewritten_keywords.rb
@@ -137,11 +138,14 @@ files:
 - lib/spec/virtualizees/until_user.rb
 - lib/spec/virtualizees/not_user.rb
 - lib/spec/virtualizees/greeter.rb
+- lib/spec/virtualizees/micro_sql_dsl.rb
 - lib/spec/not_rewriter_spec.rb
 - lib/spec/keyword_rewriter_spec.rb
+- lib/spec/class_mirrorer_spec.rb
 - lib/spec/spec_helper.rb
 - lib/spec/class_reflection_spec.rb
 - lib/spec/or_rewriter_spec.rb
+- lib/spec/micro_sql_dsl_spec.rb
 - lib/Rakefile
 homepage: http://github.com/rahulraj/virtual_keywords
 licenses: []