borx 0.0.1.alpha1

data/lib/borx.rb

@@ -0,0 +1,6 @@
+module Borx
+
+end
+
+require 'borx/environment'
+require 'borx/rewriter'

data/lib/borx/code.rb

@@ -0,0 +1,22 @@
+# A simple class to tell the difference between rewritten and raw code.
+class Borx::Code
+
+  attr :code
+
+  def initialize(code)
+    @code = code
+  end
+
+  def hash
+    code.hash
+  end
+
+  def eql?(other)
+    code.eql?(other.code)
+  end
+
+  def inspect
+    "#<Borx::Code #{code.inspect}>"
+  end
+
+end

data/lib/borx/environment.rb

@@ -0,0 +1,108 @@
+base = Class.new do
+
+  def get_constant(binding, name, house = nil)
+    raise Borx::Environment::NotImplemented::GetConstant
+  end
+
+  def set_constant(binding, name, house = nil, value)
+    raise Borx::Environment::NotImplemented::SetConstant
+  end
+
+  def call_method(binding, receiver, name, *args, &block)
+    raise Borx::Environment::NotImplemented::CallMethod
+  end
+
+  def get_variable(binding, name)
+    raise Borx::Environment::NotImplemented::GetVariable
+  end
+
+  def set_variable(binding, name, value)
+    raise Borx::Environment::NotImplemented::SetVariable
+  end
+
+end
+
+class Borx::Environment < base
+
+  Base = superclass
+
+  module GetVariable
+
+    def get_variable(binding, name)
+      binding.eval(name)
+    end
+
+  end
+
+  module SetVariable
+
+    def set_variable(binding, name, value)
+      binding.eval("#{name} = nil ; lambda{|_x| #{name} = _x}").call(value)
+    end
+
+  end
+
+  module GetSetVariable
+    include GetVariable
+    include SetVariable
+  end
+
+  module CallPublicMethod
+    def call_method(binding, receiver, name ,*args, &block)
+      receiver.__send__(name, *args, &block)
+    end
+  end
+
+  module CallPrivateMethod
+    def call_private_method(binding, receiver, name ,*args, &block)
+      receiver.__send__(name, *args, &block)
+    end
+  end
+
+  module CallMethod
+    include CallPublicMethod
+    include CallPrivateMethod
+  end
+
+  module GetConstant
+    def get_constant(binding, name, house = Object)
+      house.const_get(name)
+    end
+  end
+
+  module GetSetConstant
+    include GetConstant
+  end
+
+  include GetSetVariable
+  include GetSetConstant
+  include CallMethod
+
+  class NotImplemented < StandardError
+    class GetConstant < self
+    end
+    class SetConstant < self
+    end
+    class CallMethod < self
+    end
+    class GetVariable < self
+    end
+    class SetVariable < self
+    end
+  end
+
+  def eval(code, bin_ding = nil)
+    bin_ding ||= proc{}.binding
+    eval_code( Borx::Rewriter.rewrite(code), bin_ding)
+  end
+
+private
+  def eval_code(code, binding, file = '(eval)', line = 0)
+    old_borx, setter = binding.eval('__borx__ ||= nil ; [__borx__, lambda{|v| __borx__ = v}]')
+    setter.call(self)
+    binding.eval(code.code, file, line)
+  ensure
+    setter.call(old_borx) if setter
+  end
+
+end

data/lib/borx/rewriter.rb

@@ -0,0 +1,193 @@
+begin
+  require 'ripper'
+rescue NotFound
+  raise NotFound, "Ripper extension not found. Please add it to your bundle."
+end
+require 'sorcerer'
+require 'borx/code'
+class Borx::Rewriter < Ripper::SexpBuilder
+
+  # @api private
+  ARGS_NEW = [:args_new].freeze
+
+  def self.rewrite(code, options = {})
+    tree = self.new(code).parse
+    code = Sorcerer.source(tree, options)
+    return Borx::Code.new(code)
+  end
+
+private
+
+  def on_top_const_ref(*args)
+    ref = super
+    return call_borx('get_constant',
+                       [:args_add,
+                         [:args_add, ARGS_NEW, ident_to_string(ref[1])],
+                         [:@const, "Object", [0,0]]])
+  end
+
+
+  def on_const_path_ref(*args)
+    path = super
+    return call_borx('get_constant',[:args_add, [:args_add, ARGS_NEW, ident_to_string(path[2])], path[1]])
+  end
+
+  def on_method_add_arg(*x)
+    name, call, args, block = super
+    inject_binding = true
+    if call[0] ==  :fcall
+      args = args[1][1] unless args == ARGS_NEW
+      brgs = push_args(args,[:var_ref, [:@kw, "self", [0, 0]]],ident_to_string(call[1]))
+      return call_borx('call_private_method', brgs)
+    elsif call[0] == :method_add_arg
+      # this case doesn't show up in the wild
+      # it exists because of the way we rewrite calls
+      inject_binding = false
+      brgs = push_args(args[1][1], call[2][1][1])
+    else
+      # :nocov:
+      raise "Unknown call type #{call}. This is bug. Please report it"
+      # :nocov:
+    end
+    return call_borx('call_method', brgs, binding: inject_binding)
+  end
+
+  def on_call(*args)
+    call = super
+    return call_borx('call_method',
+                     [:args_add,
+                       [:args_add,[:args_new],call[1]],
+                       ident_to_string(call[3])])
+  end
+
+  def on_vcall(vcall)
+    s = super
+    return call_borx('get_variable', [:args_add, [:args_new], ident_to_string(s[1])])
+  end
+
+  def on_var_ref(x)
+    var = super
+    fun = case(var[1][0])
+            when :@const then 'get_constant'
+            when :@gvar  then 'get_global_variable'
+            when :@cvar  then 'get_class_variable'
+            when :@ivar  then 'get_instance_variable'
+            when :@ident then 'get_variable'
+            when :@kw    then 'get_magic'
+            # :nocov:
+            else
+              raise "Unknown var_ref type in #{var[1]}, this is a bug, please report it"
+            # :nocov:
+          end
+    return call_borx(fun, [:args_add, [:args_new], ident_to_string(var[1])])
+  end
+
+  def on_assign(field, value)
+    assign, field, value = super
+    if field[0] == :var_field
+      fun = case(field[1][0])
+              when :@const then 'set_constant'
+              when :@gvar  then 'set_global_variable'
+              when :@cvar  then 'set_class_variable'
+              when :@ivar  then 'set_instance_variable'
+              when :@ident then 'set_variable'
+              # :nocov:
+              else
+                raise "Unknown var_field type in #{var[1]}, this is a bug, please report it"
+              # :nocov:
+            end
+      return call_borx(fun,
+                        [:args_add,
+                          [:args_add, [:args_new],
+                            ident_to_string(field[1])], value])
+    elsif field[0] == :field
+      return call_borx('call_method',
+                            [:args_add,
+                              [:args_add,
+                                [:args_add,[:args_new],field[1]], 
+                                [:string_literal,[:string_add,[:string_content],[:@tstring_content,field[3][1]+"=",field[3][2]]] ]
+                              ], value
+                            ])
+    elsif field[0] == :const_path_field
+      return call_borx('set_constant',
+                            [:args_add,
+                              [:args_add,
+                                [:args_add,[:args_new],ident_to_string(field[2])], 
+                                field[1]
+                              ], value
+                            ])
+    elsif field[0] == :top_const_field
+      return call_borx('set_constant',
+                            [:args_add,
+                              [:args_add,
+                                [:args_add, [:args_new],
+                                  ident_to_string(field[1])],
+                                  [:@const, 'Object',[0,0]]
+                              ], value])
+    end
+    # :nocov:
+    raise "Unknown assign type #{field}. This is a bug. Please report it"
+    # :nocov:
+  end
+
+  def on_xstring_literal(x)
+    x = super
+    return call_borx('execute', [:args_add, [:args_new], xstring_to_string(x)])
+  end
+
+  def on_stmts_new
+    return [:stmts_add, [:stmts_new], [:assign,
+            [:var_field, [:@ident, "__borx_binding__", [1, 0]]],
+              [:vcall, [:@ident, "binding", [1, 17]]]]]
+  end
+
+  def xstring_to_string(x)
+    if x[0] == :xstring_literal
+      return [:string_literal, xstring_to_string(x[1]), *x[2..-1]]
+    elsif x[0] == :xstring_add
+      return [:string_add, xstring_to_string(x[1]), *x[2..-1]]
+    elsif x[0] == :xstring_new
+      return [:string_content]
+    else
+      # :nocov:
+      raise "Unknown xstring type #{x}. This is a bug. Please report it."
+      # :nocov:
+    end
+  end
+
+  def call_borx(name,args, options = {})
+    args = push_args(args, binding_args) unless options[:binding] == false
+    return [:method_add_arg,
+      [:call, [:var_ref, [:@ident, "__borx__", [0, 0]]], :'.', [:@ident, name, [0,0]]],
+      [:arg_paren,
+        [:args_add_block,
+         args,
+         options.fetch(:block, false)
+        ]
+      ]
+    ]
+  end
+
+  def binding_args
+    return [:var_field, [:@ident, "__borx_binding__", [1, 0]]]
+  end
+
+  def ident_to_string(ident)
+    [:string_literal,
+      [:string_add,[:string_content],
+        [:@tstring_content, ident[1], ident[2]]]]
+  end
+
+  def push_args(tree, *args)
+    if tree == [:args_new]
+      if args.any?
+        return [:args_add, push_args(tree, *args[0..-2]), args.last]
+      else 
+        return tree
+      end
+    else
+      return [:args_add, push_args(tree[1], *args), tree[2]]
+    end
+  end
+
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: borx
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha1
+  prerelease: 6
+platform: ruby
+authors:
+- Hannes Georg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sorcerer
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.10
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  This plugin parses a piece of ruby code with ripper, rewrites it a bit and converts it back to ruby code.
+  This lets a central object decide what the code is actually doing.
+email: hannes.georg@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/borx/environment.rb
+- lib/borx/code.rb
+- lib/borx/rewriter.rb
+- lib/borx.rb
+homepage: https://github.com/hannesg/borx
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: rewrites ruby code so you can decide what it actually does
+test_files: []
+has_rdoc: