class VirtualModule::Builder

Constants

ProxyObjectTransmitter

Public Class Methods

new(option) click to toggle source
# File lib/virtual_module.rb, line 71
def initialize(option)
  @provider = instance_eval("#{option[:lang].capitalize}SourceProvider").new(self, option[:pkgs], option[:transpiler])
  @ipc = instance_eval("#{option[:ipc].to_s.capitalize}IpcInterface").new(@provider)
end

Private Class Methods

___proxy_object_transmitter() click to toggle source
# File lib/virtual_module.rb, line 133
def self.___proxy_object_transmitter
  @transmitter
end
method_missing(key, *args, &block) click to toggle source
# File lib/virtual_module.rb, line 130
def self.method_missing(key, *args, &block)
  @vm_builder.send(:call, @receiver, key, *args)
end
to_a() click to toggle source
# File lib/virtual_module.rb, line 139
def self.to_a
  @vm_builder.send(:call, nil, @provider.to_a, self)
end
to_s() click to toggle source
# File lib/virtual_module.rb, line 136
def self.to_s
  @vm_builder.send(:call, nil, @provider.to_s, self)
end
vclass() click to toggle source
# File lib/virtual_module.rb, line 142
def self.vclass
  @vm_builder.send(:call, nil, @provider.to_s,
    @vm_builder.send(:call, nil, @provider.vclass, self)
  )
end
virtual_module_eval(*args) click to toggle source
# File lib/virtual_module.rb, line 127
def self.virtual_module_eval(*args)
  @vm_builder.send(:virtual_module_eval, @receiver, *args)
end
vmethods() click to toggle source
# File lib/virtual_module.rb, line 147
def self.vmethods
  @vm_builder.send(:call, nil, @provider.vmethods, self)
end

Public Instance Methods

add(methods="") click to toggle source
# File lib/virtual_module.rb, line 76
def add(methods="")
  @provider.source << methods
  @provider.compile
  @ipc.reset @provider
end
build() click to toggle source
# File lib/virtual_module.rb, line 82
def build
  @vm = new_vm(nil)
  @vm
end
call(receiver, name, *args) click to toggle source
# File lib/virtual_module.rb, line 87
def call(receiver, name, *args)
  if args.last.class==Hash
    kwargs = args.pop
  else
    kwargs = {}
  end
  begin
    @ipc.call(receiver, name, *args, **kwargs)
  rescue => e
    new_vm(e.message)
  rescue RuntimeException => e
    raise e.message
  end
end
serialize(object_lookup_id) click to toggle source
# File lib/virtual_module.rb, line 102
def serialize(object_lookup_id)
  @ipc.serialize(object_lookup_id)
end
virtual_eval(receiver, script, auto_binding=true)
Alias for: virtual_module_eval
virtual_instance_eval(receiver, script, auto_binding=true)
Alias for: virtual_module_eval
virtual_module_eval(receiver, script, auto_binding=true) click to toggle source
# File lib/virtual_module.rb, line 106
def virtual_module_eval(receiver, script, auto_binding=true)
  vars, type_info, params = inspect_local_vars(binding.of_caller(2), script)
  @provider.compile(vars, type_info, params, script, auto_binding)
  @ipc.reset @provider
  evaluated = self.call(receiver, :vm_builtin_eval_func, [params, type_info])

  if auto_binding
    binding.of_caller(2).eval(evaluated[1].map{|k,v| "#{k}=#{v};" if !v.nil? }.join)
  end

  return evaluated[0]
end

Private Instance Methods

inspect_local_vars(context, script) click to toggle source
# File lib/virtual_module.rb, line 165
      def inspect_local_vars(context, script)
        vars = (args = extract_args(Ripper.sexp(script))).nil? ? [] : args.split(",").uniq.map{|e| e.to_sym} & context.eval("local_variables")

        type_info = {}
        type_info[:params] = context.eval("Hash[ *#{vars}.collect { |e| [ e, eval(e.to_s).class.to_s ] }.flatten ]").select{|k,v| ["FloatArray", "IntArray"].include?(v)}

        params = context.eval(<<EOS)
require 'msgpack'
___params = {}
___params = local_variables.map{|e| [e, eval(e.to_s)]}.each{|e| ___params[e[0]]=e[1] if #{vars}.include?(e[0])}[0][1]
___params
EOS
        [vars, type_info, params]
      end
new_vm(receiver) click to toggle source
# File lib/virtual_module.rb, line 123
def new_vm(receiver)
  vm_builder, provider, transmitter = [self, @provider, ProxyObjectTransmitter.new(self, receiver)]
  vm = Module.new{
    @vm_builder, @provider, @transmitter, @receiver = [vm_builder, provider, transmitter, receiver]
    def self.virtual_module_eval(*args)
      @vm_builder.send(:virtual_module_eval, @receiver, *args)
    end
    def self.method_missing(key, *args, &block)
      @vm_builder.send(:call, @receiver, key, *args)
    end
    def self.___proxy_object_transmitter
      @transmitter
    end
    def self.to_s
      @vm_builder.send(:call, nil, @provider.to_s, self)
    end
    def self.to_a
      @vm_builder.send(:call, nil, @provider.to_a, self)
    end
    def self.vclass
      @vm_builder.send(:call, nil, @provider.to_s,
        @vm_builder.send(:call, nil, @provider.vclass, self)
      )
    end
    def self.vmethods
      @vm_builder.send(:call, nil, @provider.vmethods, self)
    end
  }
  includables = (
    (defs = extract_defs(Ripper.sexp(@provider.source.join(";")))).nil? ? [] : defs.split(",")  +
    provider.pkgs.map{|e| e.class==Hash ? e.values : e}.flatten
  )
  includables.each{|e|
    vm.class_eval {
      define_method e.to_sym, Proc.new { |*args|
        vm_builder.call(receiver, e.to_sym, *args)
      }
    }
  } if !includables.nil?
  vm
end