fastruby 0.0.2 → 0.0.3

data/README

@@ -55,8 +55,6 @@ I will stabilize the API and document it for next releases. I promise
 
 == Known Limitations & Issues
 
-* fastruby only can be called from inside a class scope, and only can be used to define instance methods (no class methods)
-* fastruby invokations can't take more than one method
 * monkey patching does not work with fastruby methods
 * calls with blocks to ruby or cruby methods are almost as slow as normal ruby (if the called method is defined by fastruby, the call it's pretty fast)
 * does not support singleton methods (both define & call)

data/Rakefile

@@ -7,7 +7,7 @@ require "rspec/core/rake_task"
 
 spec = Gem::Specification.new do |s|
   s.name = 'fastruby'
-  s.version = '0.0.2'
+  s.version = '0.0.3'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY
@@ -15,7 +15,6 @@ spec = Gem::Specification.new do |s|
   s.homepage = "http://github.com/tario/fastruby"
   s.add_dependency "RubyInline", "= 3.9.0"
   s.add_dependency "ruby_parser", "= 2.0.6"
-  s.add_dependency "sexp_processor", "= 3.0.5"
   s.has_rdoc = true
   s.extra_rdoc_files = [ 'README' ]
 #  s.rdoc_options << '--main' << 'README'

data/TODO

@@ -20,7 +20,6 @@ To improve:
 
 Refactor:
 
-* hashes of methods on builder refactored into an only hash
 * refactor anonoymous methods (tip: use ruby format string for names)
 * Clean of duplicated code
 * Remove ruby inline explicit dependency

data/lib/fastruby/builder.rb

@@ -20,25 +20,33 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 =end
 require "fastruby/translator"
 require "fastruby/inline_extension"
+require "fastruby/method_extension"
 require "fastruby/logging"
 
 module FastRuby
-  module BuilderModule
-    def build(signature, method_name)
-      tree = self.method_tree[method_name]
-      locals = self.method_locals[method_name]
-      options = self.method_options[method_name]
-      mname = "_" + method_name.to_s + signature.map(&:internal_value).map(&:to_s).join
+
+  class Method
+    attr_accessor :tree
+    attr_accessor :locals
+    attr_accessor :options
+
+    def initialize(method_name, owner)
+      @method_name = method_name
+      @owner = owner
+    end
+
+    def build(signature)
+      mname = "_" + @method_name.to_s + signature.map(&:internal_value).map(&:to_s).join
 
       FastRuby.logger.info mname.to_s
 
       begin
-        if (self.instance_method(mname))
-          FastRuby.logger.info "NOT Building #{self}::#{method_name} for signature #{signature.inspect}, it's already done"
+        if (@owner.instance_method(mname))
+          FastRuby.logger.info "NOT Building #{self}::#{@method_name} for signature #{signature.inspect}, it's already done"
           return
         end
       rescue NameError
-        FastRuby.logger.info "Building #{self}::#{method_name} for signature #{signature.inspect}"
+        FastRuby.logger.info "Building #{self}::#{@method_name} for signature #{signature.inspect}"
       end
 
       context = FastRuby::Context.new
@@ -57,41 +65,40 @@ module FastRuby
 
       context.infer_self = signature[0]
 
-      c_code = context.to_c(tree)
+      c_code = context.to_c_method(tree)
 
-      inline :C  do |builder|
-        builder.inc << context.extra_code
-        builder.include "<node.h>"
-        builder.c c_code
+      @owner.class_eval do
+        inline :C  do |builder|
+          builder.inc << context.extra_code
+          builder.include "<node.h>"
+          builder.c c_code
+        end
       end
 
-
-      ret = instance_method(mname)
+      ret = @owner.instance_method(mname)
 
       ret.extend MethodExtent
       ret.yield_signature = context.yield_signature
 
       ret
+
     end
 
     module MethodExtent
       attr_accessor :yield_signature
     end
+  end
 
-    def method_tree
-      @method_tree = Hash.new unless @method_tree
-      @method_tree
-    end
-
-    def method_locals
-      @method_locals = Hash.new unless @method_locals
-      @method_locals
+  module BuilderModule
+    def build(signature, method_name)
+      fastruby_method(method_name.to_sym).build(signature)
     end
 
-    def method_options
-      @method_options = Hash.new unless @method_options
-      @method_options
+    def fastruby_method(mname_)
+      mname = mname_.to_sym
+      @fastruby_method = Hash.new unless @fastruby_method
+      @fastruby_method[mname] = FastRuby::Method.new(mname,self) unless @fastruby_method[mname]
+      @fastruby_method[mname]
     end
-
   end
 end

data/lib/fastruby/getlocals.rb

@@ -19,23 +19,25 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 
 =end
 require "rubygems"
-require "sexp_processor"
 require "set"
 
 module FastRuby
-  class GetLocalsProcessor < SexpProcessor
+  class GetLocalsProcessor
 
     attr_reader :locals
 
     def initialize
-      super()
-      self.require_empty = false
       @locals = Set.new
     end
 
-    def process_lasgn(tree)
+    def process(tree)
+      if tree.node_type == :lasgn
        @locals << tree[1]
-       tree.dup
+      end
+
+      tree.select{|subtree| subtree.instance_of? Sexp}.each do |subtree|
+        process(subtree)
+      end
     end
 
     def self.get_locals(tree)

data/lib/fastruby/method_extension.rb

@@ -0,0 +1,36 @@
+=begin
+
+This file is part of the fastruby project, http://github.com/tario/fastruby
+
+Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+fastruby is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+fastruby is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+module FastRuby
+  module MethodExtension
+    def fastruby
+      owner.fastruby_method(name.to_sym)
+    end
+  end
+end
+
+class Method
+  include FastRuby::MethodExtension
+end
+
+class UnboundMethod
+  include FastRuby::MethodExtension
+end

data/lib/fastruby/object.rb

@@ -21,22 +21,120 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 require "fastruby/translator"
 require "fastruby/builder"
 require "fastruby/getlocals"
+require "fastruby/method_extension"
 require "ruby_parser"
 require "inline"
 
 # clean rubyinline cache
 system("rm -fr #{ENV["HOME"]}/.ruby_inline/*")
 
+$top_level_binding = binding
+
+module FastRuby
+  def self.encapsulate_tree(tree, method_name)
+      generated_tree = tree
+
+      if generated_tree[0] == :scope
+        generated_tree = s(:defn, method_name.to_sym, s(:args),
+                s(:scope, s(:block, generated_tree[1])))
+      elsif generated_tree[0] == :block
+        generated_tree = s(:defn, method_name.to_sym, s(:args),
+                    s(:scope, generated_tree))
+      else
+        generated_tree = s(:defn, method_name.to_sym, s(:args),
+                    s(:scope, s(:block, generated_tree)))
+      end
+
+      generated_tree
+  end
+end
+
 class Object
-  def self.fastruby(rubycode, *options_hashes)
-    tree = RubyParser.new.parse rubycode
+
+  def fastruby(argument, *options_hashes)
+    tree = nil
+
+    if argument.instance_of? Sexp
+      tree = argument
+    elsif argument.instance_of? String
+      tree = RubyParser.new.parse(argument)
+    else
+      raise ArgumentError
+    end
+
+    if tree[0] == :class
+      classname = Object.to_class_name tree[1]
+
+      eval("
+      class #{classname}
+      end
+      ", $top_level_binding)
+
+      klass = eval(classname)
+
+      method_name = "_anonymous_" + rand(100000000000).to_s
+      $generated_tree = FastRuby.encapsulate_tree(tree[3],method_name)
+      $options_hashes = options_hashes
+
+      klass.class_eval do
+        class << self
+           fastruby $generated_tree, *$options_hashes
+        end
+      end
+
+      klass.send(method_name)
+    else
+      method_name = "_anonymous_" + rand(100000000000).to_s
+      Object.fastruby(FastRuby.encapsulate_tree(tree,method_name), *options_hashes)
+      send(method_name)
+    end
+  end
+
+  def self.fastruby(argument,*options_hashes)
+
+    tree = nil
+
+    if argument.instance_of? Sexp
+      tree = argument
+    elsif argument.instance_of? String
+      tree = RubyParser.new.parse(argument)
+    else
+      raise ArgumentError
+    end
+
+    if tree.node_type == :defn
+      fastruby_defn(tree,*options_hashes)
+    else
+       method_name = "_anonymous_" + rand(100000000000).to_s
+      $generated_tree = FastRuby.encapsulate_tree(tree,method_name)
+      $options_hashes = options_hashes
+
+      klass = self
+      klass.class_eval do
+        class << self
+          fastruby_defn($generated_tree,*$options_hashes)
+        end
+      end
+
+      send(method_name)
+    end
+
+  end
+
+  def self.fastruby_defn(tree, *options_hashes)
 
     options_hash = {:validate_lvar_types => true}
     options_hashes.each do |opt|
       options_hash.merge!(opt)
     end
 
-    if tree[0] != :defn
+    if tree[0] == :block
+      (1..tree.size-1).each do |i|
+        fastruby(tree[i], *options_hashes)
+      end
+
+      return
+    elsif tree[0] != :defn
       raise ArgumentError, "Only definition of methods are accepted"
     end
 
@@ -50,7 +148,7 @@ class Object
     locals = Set.new
     locals << :self
 
-    FastRuby::GetLocalsProcessor.get_locals(RubyParser.new.parse(rubycode)).each do |local|
+    FastRuby::GetLocalsProcessor.get_locals(tree).each do |local|
       locals << local
     end
 
@@ -64,9 +162,10 @@ class Object
       end
     end
 
-    self_.method_tree[method_name] = tree
-    self_.method_locals[method_name] = locals
-    self_.method_options[method_name] = options_hash
+    fastrubym = self_.fastruby_method(method_name)
+    fastrubym.tree = tree
+    fastrubym.locals = locals
+    fastrubym.options = options_hash
 
     def hash.build(key)
       @klass.build(key, @method_name)
@@ -159,10 +258,33 @@ class Object
     end
   end
 
+  def internal_value
+    $refered_from_code_array = Array.new unless $refered_from_code_array
+    $refered_from_code_array << self
+
+    internal_value_
+  end
+
   inline :C do |builder|
-    builder.c "VALUE internal_value() {
+    builder.c "VALUE internal_value_() {
       return INT2FIX(self);
     }"
   end
+
+  private
+      def self.to_class_name(argument)
+        if argument.instance_of? Symbol
+          argument.to_s
+        elsif argument.instance_of? Sexp
+          if argument[0] == :colon3
+            "::" + to_class_name(argument[1])
+          elsif argument[0] == :colon2
+            to_class_name(argument[1]) + "::" + to_class_name(argument[2])
+          elsif argument[0] == :const
+            to_class_name(argument[1])
+          end
+        end
+      end
+
 end
 

data/lib/fastruby/translator.rb

@@ -21,6 +21,7 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 require "rubygems"
 require "inline"
 require "set"
+require "fastruby/method_extension"
 
 module FastRuby
   class Context
@@ -133,9 +134,15 @@ module FastRuby
 
         convention = nil
 
-        if recvtype.respond_to? :method_tree and inference_complete
+        if recvtype.respond_to? :fastruby_method and inference_complete
 
-          if recvtype.method_tree[call_tree[2]]
+          method_tree = nil
+          begin
+            method_tree = recvtype.instance_method(call_tree[2]).fastruby.tree
+          rescue NoMethodError
+          end
+
+          if method_tree
             mobject = recvtype.build(signature, call_tree[2])
             yield_signature = mobject.yield_signature
 
@@ -394,25 +401,18 @@ module FastRuby
         to_c(subtree)
       }.join(";")
 
-      if tree[-1][0] != :return
-        str = str + ";last_expression = #{to_c(tree[-1])};"
-      else
-        str = str + ";#{to_c(tree[-1])};"
-      end
+      if tree[-1]
 
-      caller_code = proc { |name| "
-        static VALUE #{name}(VALUE param) {
-          #{@locals_struct} *plocals = (void*)param;
-          VALUE last_expression;
-
-          #{str}
+        if tree[-1][0] != :return
+          str = str + ";last_expression = #{to_c(tree[-1])};"
+        else
+          str = str + ";#{to_c(tree[-1])};"
+        end
+      end
 
-          return last_expression;
-          }
-        "
-      }
+      str << "return last_expression;"
 
-      anonymous_function(caller_code) + "((VALUE)#{locals_pointer})"
+      inline_block str
     end
 
     def to_c_return(tree)
@@ -461,7 +461,52 @@ module FastRuby
       end
     end
 
+    def to_c_scope(tree)
+      if tree[1]
+        to_c(tree[1])
+      else
+        "Qnil"
+      end
+    end
+
+    def to_c_cdecl(tree)
+      if tree[1].instance_of? Symbol
+        inline_block "
+          // set constant #{tree[1].to_s}
+          VALUE val = #{to_c tree[2]};
+          rb_const_set(rb_cObject, #{tree[1].to_i}, val);
+          return val;
+          "
+      elsif tree[1].instance_of? Sexp
+
+        if tree[1].node_type == :colon2
+          inline_block "
+            // set constant #{tree[1].to_s}
+            VALUE val = #{to_c tree[2]};
+            VALUE klass = #{to_c tree[1][1]};
+            rb_const_set(klass, #{tree[1][2].to_i}, val);
+            return val;
+            "
+        elsif tree[1].node_type == :colon3
+          inline_block "
+            // set constant #{tree[1].to_s}
+            VALUE val = #{to_c tree[2]};
+            rb_const_set(rb_cObject, #{tree[1][1].to_i}, val);
+            return val;
+            "
+        end
+      end
+    end
+
+    def to_c_const(tree)
+      "rb_const_get(CLASS_OF(plocals->self), #{tree[1].to_i})"
+    end
+
     def to_c_defn(tree)
+      "rb_funcall(plocals->self,#{:fastruby.to_i},1,(VALUE)#{tree.internal_value})"
+    end
+
+    def to_c_method(tree)
       method_name = tree[1]
       args_tree = tree[2]
 
@@ -501,7 +546,7 @@ module FastRuby
         #{@locals_struct} locals;
         #{@locals_struct} *plocals = (void*)&locals;
         #{@block_struct} *pblock;
-        VALUE last_expression;
+        VALUE last_expression = Qnil;
 
         #{args_tree[1..-1].map { |arg|
           "locals.#{arg} = #{arg};\n"
@@ -546,6 +591,33 @@ module FastRuby
       "_rb_ivar_set(#{locals_accessor}self,#{tree[1].to_i},#{to_c tree[2]})"
     end
 
+    def to_c_colon3(tree)
+      "rb_const_get_from(rb_cObject, #{tree[1].to_i})"
+    end
+    def to_c_colon2(tree)
+      inline_block "
+        VALUE klass = #{to_c tree[1]};
+
+      if (rb_is_const_id(#{tree[2].to_i})) {
+        switch (TYPE(klass)) {
+          case T_CLASS:
+          case T_MODULE:
+            return rb_const_get_from(klass, #{tree[2].to_i});
+            break;
+          default:
+            rb_raise(rb_eTypeError, \"%s is not a class/module\",
+               RSTRING(rb_obj_as_string(klass))->ptr);
+            break;
+        }
+      }
+      else {
+        return rb_funcall(klass, #{tree[2].to_i}, 0, 0);
+      }
+
+        return Qnil;
+      "
+    end
+
     def to_c_lasgn(tree)
       if options[:validate_lvar_types]
         klass = @infer_lvar_map[tree[1]]
@@ -601,31 +673,19 @@ module FastRuby
       condition_tree = tree[1]
       impl_tree = tree[2]
       else_tree = tree[3]
-      code = "if (RTEST(#{to_c condition_tree})) {
-        last_expression = #{to_c impl_tree};
-      }
-      "
-
-      if (else_tree)
-        code = code + " else {
-          last_expression = #{to_c else_tree};
-        }
-        "
-      end
 
-      caller_code = proc { |name| "
-        static VALUE #{name}(VALUE param) {
-          #{@locals_struct} *plocals = (void*)param;
-          VALUE last_expression = Qnil;
-
-          #{code};
-
-          return last_expression;
+      inline_block "
+          if (RTEST(#{to_c condition_tree})) {
+            last_expression = #{to_c impl_tree};
+          }#{else_tree ?
+            " else {
+            last_expression = #{to_c else_tree};
+            }
+            " : ""
           }
-        "
-      }
 
-      anonymous_function(caller_code) + "((VALUE)#{locals_pointer})"
+          return last_expression;
+      "
     end
 
     def to_c_call(tree)
@@ -665,9 +725,15 @@ module FastRuby
 
         convention = nil
 
-        if recvtype.respond_to? :method_tree and inference_complete
+        if recvtype.respond_to? :fastruby_method and inference_complete
 
-          if recvtype.method_tree[tree[2]]
+          method_tree = nil
+          begin
+            method_tree = recvtype.instance_method(tree[2]).fastruby.tree
+          rescue NoMethodError
+          end
+
+          if method_tree
             mobject = recvtype.build(signature, tree[2])
             convention = :fastruby
           else
@@ -773,22 +839,21 @@ module FastRuby
       end
     end
 
-    def to_c_while(tree)
-      caller_code = proc { |name| "
-        static VALUE #{name}(VALUE param) {
-          #{@locals_struct} *plocals = (void*)param;
-          VALUE last_expression;
+    def to_c_class(tree)
+      inline_block("
+        rb_funcall(plocals->self,#{:fastruby.to_i},1,(VALUE)#{tree.internal_value});
+        return Qnil;
+      ")
 
+    end
+
+    def to_c_while(tree)
+      inline_block("
           while (#{to_c tree[1]}) {
             #{to_c tree[2]};
           }
-
           return Qnil;
-          }
-        "
-      }
-
-      anonymous_function(caller_code) + "((VALUE)#{locals_pointer})"
+      ")
     end
 
     def infer_type(recv)
@@ -850,6 +915,20 @@ module FastRuby
       end
     end
 
+    def inline_block(code)
+      caller_code = proc { |name| "
+        static VALUE #{name}(VALUE param) {
+          #{@locals_struct} *plocals = (void*)param;
+          VALUE last_expression = Qnil;
+
+          #{code}
+          }
+        "
+      }
+
+      anonymous_function(caller_code) + "((VALUE)#{locals_pointer})"
+    end
+
     inline :C  do |builder|
       builder.include "<node.h>"
       builder.c "VALUE getaddress(VALUE method) {

data/spec/sugar_spec.rb

@@ -0,0 +1,138 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  it "should compile fastruby code with two methods" do
+    class ::E1
+      fastruby "
+        def foo
+          12
+        end
+
+        def bar
+          15
+        end
+      "
+    end
+
+    e1 = ::E1.new
+    e1.foo.should be == 12
+    e1.bar.should be == 15
+  end
+
+  it "should compile fastruby code with class definition and one method" do
+    fastruby "
+      class ::E2
+        def foo
+          12
+        end
+      end
+    "
+
+    e2 = ::E2.new
+    e2.foo.should be == 12
+  end
+
+  it "should compile fastruby code with class definition and two methods" do
+    fastruby "
+      class ::E3
+        def foo
+          12
+        end
+        def bar
+          15
+        end
+      end
+    "
+
+    e3 = ::E3.new
+    e3.foo.should be == 12
+    e3.bar.should be == 15
+  end
+
+  class ::E4
+    def foo
+    end
+  end
+
+  it "should compile standalone code and execute it inmediatly" do
+    $e4 = ::E4
+    fastruby "
+      require 'fastruby'
+      $e4.new.foo
+    "
+  end
+
+  it "should compile standalone code togheter with classes and execute it inmediatly" do
+    $e4 = ::E4
+    fastruby "
+      require 'fastruby'
+      $e4.new.foo
+
+      class ::E5
+        def foo
+          12
+        end
+        def bar
+          15
+        end
+      end
+
+    "
+
+    e5 = ::E5.new
+    e5.foo.should be == 12
+    e5.bar.should be == 15
+  end
+
+  class ::E6
+    attr_reader :called
+    def foo
+      @called = true
+    end
+  end
+  it "should execute standalone code" do
+    $e6 = ::E6.new
+    fastruby "
+      $e6.foo
+    "
+    $e6.called.should be == true
+  end
+
+  it "should execute standalone code inside a class definition" do
+    $e6_1 = ::E6.new
+    fastruby "
+      class X
+        $e6_1.foo
+      end
+    "
+    $e6_1.called.should be == true
+  end
+
+  it "should allow define multiple classes in only one call to fastruby" do
+    fastruby "
+      class E7X
+      end
+      class E7Y
+      end
+    "
+  end
+
+  it "should allow define multiple classes with methods in only one call to fastruby" do
+    fastruby "
+      class E8X
+        def foo
+          123
+        end
+      end
+      class E8Y
+        def bar
+          456
+        end
+      end
+    "
+
+    E8X.new.foo.should be == 123
+    E8Y.new.bar.should be == 456
+  end
+
+end

data/spec/variable_spec.rb

@@ -60,4 +60,113 @@ describe FastRuby, "fastruby" do
     u4.foo.should be == 88
   end
 
+  class ::U5
+    fastruby "
+      def foo
+        U5C = 11
+      end
+    "
+  end
+
+  it "should write constants" do
+    ::U5.new.foo
+
+    U5C.should be == 11
+  end
+
+  class ::U6
+    fastruby "
+      def foo
+        U6C
+      end
+    "
+  end
+
+  it "should read constants" do
+    ::U6C = 11
+    ::U6.new.foo.should be == 11
+  end
+
+
+  class ::U7
+    class U71
+      fastruby "
+        def foo
+          U7C = 11
+        end
+      "
+    end
+  end
+
+  it "should write nested constants" do
+    ::U7::U71.new.foo
+    ::U7::U71::U7C.should be == 11
+
+    lambda {
+    ::U7::U7C.should be == 11
+    }.should_not raise_error
+  end
+
+  class ::U8
+    class U81
+      fastruby "
+        def foo
+          U8C
+        end
+      "
+    end
+  end
+  it "should read  nested constants" do
+    ::U8::U81::U8C = 11
+    ::U8::U81.new.foo.should be == 11
+  end
+
+  class ::U9
+    fastruby "
+      def foo
+        ::U9C
+      end
+    "
+  end
+  it "should read constant with colon3" do
+    ::U9C = 21
+    ::U9.new.foo.should be == 21
+  end
+
+  it "should write constant with colon3" do
+    class ::U10
+      fastruby "
+        ::U10C = 51
+        def foo
+        end
+      "
+    end
+    ::U10.new.foo
+    ::U10C.should be == 51
+  end
+
+  class ::U11
+    fastruby "
+      def foo
+        ::U11::U11C
+      end
+    "
+  end
+  it "should read constant with colon3 and colon2" do
+    ::U11::U11C = 21
+    ::U11.new.foo.should be == 21
+  end
+
+  it "should write constant with colon3 and colon2" do
+    class ::U12
+      fastruby "
+        ::U12::U12C = 51
+        def foo
+        end
+      "
+    end
+    ::U12.new.foo
+    ::U12::U12C.should be == 51
+  end
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fastruby
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Dario Seminara
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-31 00:00:00 -03:00
+date: 2011-08-03 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,22 +50,6 @@ dependencies:
         version: 2.0.6
   type: :runtime
   version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: sexp_processor
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 3
-        - 0
-        - 5
-        version: 3.0.5
-  type: :runtime
-  version_requirements: *id003
 description: 
 email: robertodarioseminara@gmail.com
 executables: []
@@ -92,12 +76,14 @@ files:
 - lib/fastruby/getlocals.rb
 - lib/fastruby/translator.rb
 - lib/fastruby/object.rb
+- lib/fastruby/method_extension.rb
 - lib/fastruby.rb
 - spec/variable_spec.rb
 - spec/control_spec.rb
 - spec/expression_spec.rb
 - spec/base_spec.rb
 - spec/block_spec.rb
+- spec/sugar_spec.rb
 - spec/literal_spec.rb
 - spec/integrity_spec.rb
 - LICENSE