ruby_box 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 74ee4ebcf60636a60c2307bbb3b84758d6132689
+  data.tar.gz: da737b1c1922db5b821437c806c66dc672ccd8a9
+SHA512:
+  metadata.gz: 91f3c7f353453860a7a160997d002f0fe6b5e8d716221ad16244a8f9b13d8de1d9197bc66ac56ddd17a610d7c171f4f6f38a2c67a50596610b0f2c9de4732f6a
+  data.tar.gz: c428446d7ff6c5ddf170cf0f3425c27968d089f9f0bf51e4019df1750c2a18ff6a4c99d8ec0ec6dbdc3c6ad848ce16ab88a0021396dedbfe75670b8d0dd3f5a4

data/lib/ruby_box/bindings.rb

@@ -0,0 +1,39 @@
+require 'ruby_box'
+
+module RubyBox
+  module Bindings
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def bindings
+        @bindings ||= begin
+          if superclass.respond_to?(:bindings)
+            superclass.bindings.dup
+          else
+            []
+          end
+        end
+      end
+
+      private
+
+      def binds(target, proc = Proc.new)
+        bindings << [target, proc]
+      end
+    end
+
+    def initialize(*)
+      super
+
+      self.class.bindings.each do |target, proc|
+        bind target, proc { |*args| instance_exec(*args, &proc) }
+      end
+    end
+
+    private
+
+    def bind(target, proc = Proc.new)
+       context.attach(target, proc)
+    end
+  end
+end

data/lib/ruby_box/boxed_error.rb

@@ -0,0 +1,15 @@
+require 'ruby_box'
+
+module RubyBox
+  class BoxedError < Error
+    def self.[](class_name)
+      boxed_class_name = :"Boxed#{class_name}"
+
+      if const_defined?(boxed_class_name) && (klass = const_get(boxed_class_name)) < self
+        klass
+      else
+        const_set(boxed_class_name, Class.new(self))
+      end
+    end
+  end
+end

data/lib/ruby_box/bridging.rb

@@ -0,0 +1,119 @@
+require 'ruby_box'
+
+require 'json'
+require 'active_support/concern'
+
+module RubyBox
+  module Bridging
+    extend ActiveSupport::Concern
+
+    included do
+      requires 'native'
+      requires 'singleton'
+      requires 'json'
+
+      binds('Opal.exit') { |status| raise Error, "Exit with status #{status.inspect}" }
+
+      binds('Opal.STDOUT.write_proc') { |data| stdout << data }
+      binds('Opal.STDERR.write_proc') { |data| stderr << data }
+
+      executes <<-RUBY
+        module RubyBox
+          VERSION = #{VERSION.inspect}
+
+          class CurrentBoxProxy
+            include Singleton
+          end
+
+          def self.boxed?
+            true
+          end
+
+          def self.current
+            CurrentBoxProxy.instance
+          end
+        end
+      RUBY
+    end
+
+    class_methods do
+      def exposes(*method_names)
+        method_names.each do |method_name|
+          handle = "Opal.RubyBox.CurrentBoxProxy.__exposed_method_#{method_name}"
+
+          wrapper = ->(serialized_args) do
+            args = JSON.parse(serialized_args)
+            value = send(method_name, *args)
+            value.to_json
+          end
+
+          binds(handle, wrapper)
+
+          executes <<-RUBY
+            class RubyBox::CurrentBoxProxy
+              define_method(#{method_name.inspect}) do |*args, &block|
+                raise ArgumentError, 'Cannot pass block to bridged method `RubyBox::CurrentBoxProxy##{method_name}`' unless block.nil?
+
+                serialized_args = args.to_json
+                serialized_value = Native(`#{handle}`).call(serialized_args)
+
+                JSON.parse(serialized_value)
+              end
+            end
+          RUBY
+        end
+      end
+    end
+
+    def stdout
+      @stdout ||= []
+    end
+
+    def stderr
+      @stderr ||= []
+    end
+
+    private
+
+    def eval_compiled_source(source)
+      is_caught_value, serialized_value = super(<<-JAVASCRIPT)
+        (function(evaluator, source) {
+          var isCaughtValue = false;
+          var value;
+
+          try{
+            value = evaluator(source);
+
+            if(value && typeof(value.$to_json) === 'function') {
+              value = value.$to_json();
+            }
+          }catch(error){
+            if(error && typeof(error.$class) === 'function' && typeof(error.$message) === 'function') {
+              isCaughtValue = true;
+              value = [error.$class().$name(), error.$message()];
+            }else{
+              throw error;
+            }
+          }
+
+          if(typeof(value) !== 'string') {
+            value = JSON.stringify(value);
+          }
+
+          return [isCaughtValue, value];
+        })(eval, #{source.to_json});
+      JAVASCRIPT
+
+      value = JSON.parse(serialized_value) if serialized_value
+
+      if is_caught_value
+        class_name, message = value
+        raise BoxedError[class_name], message
+      else
+        value
+      end
+    rescue RuntimeError => error
+      raise ExecutionError, error.message
+    end
+  end
+end

data/lib/ruby_box/compilation_error.rb

@@ -0,0 +1,6 @@
+require 'ruby_box'
+
+module RubyBox
+  class CompilationError < Error
+  end
+end

data/lib/ruby_box/error.rb

@@ -0,0 +1,6 @@
+require 'ruby_box'
+
+module RubyBox
+  class Error < StandardError
+  end
+end

data/lib/ruby_box/execution.rb

@@ -0,0 +1,62 @@
+require 'ruby_box'
+
+require 'active_support/concern'
+require 'mini_racer'
+
+module RubyBox
+  module Execution
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def maximum_execution_time
+        @maximum_execution_time ||= begin
+          if superclass.respond_to?(:maximum_execution_time)
+            superclass.maximum_execution_time
+          else
+            nil
+          end
+        end
+      end
+
+      def snapshot
+        @snapshot ||= begin
+          MiniRacer::Snapshot.new snapshot_source
+        end
+      rescue MiniRacer::SnapshotError
+        raise ExecutionError, "The base snapshot for `#{name}` could not be created."
+      end
+
+      private
+
+      def snapshot_source
+        raise NotImplementedError
+      end
+
+      def times_out_in(seconds)
+        @maximum_execution_time = seconds
+      end
+    end
+
+    def maximum_execution_time
+      @maximum_execution_time ||= self.class.maximum_execution_time
+    end
+
+    def maximum_execution_time_ms
+      maximum_execution_time * 1000 if maximum_execution_time
+    end
+
+    private
+
+    def context
+      @context ||= MiniRacer::Context.new(snapshot: self.class.snapshot, timeout: maximum_execution_time_ms)
+    end
+
+    def eval_compiled_source(source)
+      context.eval source
+    rescue MiniRacer::RuntimeError => error
+      raise RuntimeError, error.message
+    rescue MiniRacer::ScriptTerminatedError => error
+      raise TimeoutError, error.message
+    end
+  end
+end

data/lib/ruby_box/execution_error.rb

@@ -0,0 +1,6 @@
+require 'ruby_box'
+
+module RubyBox
+  class ExecutionError < Error
+  end
+end

data/lib/ruby_box/metal.rb

@@ -0,0 +1,15 @@
+require 'ruby_box'
+
+module RubyBox
+  class Metal
+    include Execution
+    include RuntimeEnvironment
+    include Bindings
+    include Bridging
+    include ThreadSafety
+
+    def self.execute(*args, &block)
+      new.execute(*args, &block)
+    end
+  end
+end

data/lib/ruby_box/runtime_environment.rb

@@ -0,0 +1,75 @@
+require 'ruby_box'
+
+require 'active_support/concern'
+require 'opal'
+
+module RubyBox
+  module RuntimeEnvironment
+    extend ActiveSupport::Concern
+
+    included do
+      uses 'opal'
+      requires 'opal'
+    end
+
+    class_methods do
+      def builder
+        @builder ||= begin
+          if superclass.respond_to?(:builder)
+            superclass.builder.dup
+          else
+            Opal::Builder.new compiler_options: { arity_check: true, dynamic_require_severity: :error }
+          end
+        end
+      end
+
+      private
+
+      def uses(*gem_names)
+        gem_names.each { |gem_name| builder.use_gem gem_name }
+      rescue SyntaxError => error
+        raise CompilationError, error.message
+      end
+
+      def requires(*paths)
+        paths.each { |path| builder.build path }
+      rescue SyntaxError => error
+        raise CompilationError, error.message
+      end
+
+      def executes(source)
+        builder.build_str source, '(executes)'
+      rescue SyntaxError => error
+        raise CompilationError, error.message
+      end
+
+      def snapshot_source
+        builder.to_s
+      end
+    end
+
+    def builder
+      @builder ||= self.class.builder.dup
+    end
+
+    def execute(source)
+      execute_newly_processed_dependencies { builder.build_str source, '(execute)' }
+    rescue SyntaxError => error
+      raise CompilationError, error.message
+    end
+
+    private
+
+    def execute_newly_processed_dependencies
+      value = nil
+      capture_newly_processed_dependencies { yield }.each { |dependency| value = eval_compiled_source dependency.source }
+      value
+    end
+
+    def capture_newly_processed_dependencies
+      processed_was = builder.processed.dup
+      yield
+      builder.processed - processed_was
+    end
+  end
+end

data/lib/ruby_box/thread_safety.rb

@@ -0,0 +1,97 @@
+require 'ruby_box'
+
+require 'active_support/concern'
+require 'thread'
+require 'monitor'
+
+module RubyBox
+  module ThreadSafety
+    extend ActiveSupport::Concern
+
+    SEMAPHORE = Mutex.new
+
+    class_methods do
+      def maximum_execution_time
+        synchronize { super }
+      end
+
+      def builder
+        synchronize { super }
+      end
+
+      def snapshot
+        synchronize { super }
+      end
+
+      def bindings
+        synchronize { super }
+      end
+
+      private
+
+      def times_out_in(*)
+        synchronize { super }
+      end
+
+      def uses(*)
+        synchronize { super }
+      end
+
+      def requires(*)
+        synchronize { super }
+      end
+
+      def executes(*)
+        synchronize { super }
+      end
+
+      def binds(*)
+        synchronize { super }
+      end
+
+      def exposes(*)
+        synchronize { super }
+      end
+
+      def synchronize
+        monitor.synchronize { yield }
+      end
+
+      def monitor
+        SEMAPHORE.synchronize { @monitor ||= Monitor.new }
+      end
+    end
+
+    def maximum_execution_time
+      synchronize { super }
+    end
+
+    def builder
+      synchronize { super }
+    end
+
+    def execute(*)
+      synchronize { super }
+    end
+
+    def stdout
+      synchronize { super }
+    end
+
+    def stderr
+      synchronize { super }
+    end
+
+    private
+
+    def synchronize
+      monitor.synchronize { yield }
+    end
+
+    def monitor
+      SEMAPHORE.synchronize { @monitor ||= Monitor.new }
+    end
+  end
+end
+
+

data/lib/ruby_box/timeout_error.rb

@@ -0,0 +1,6 @@
+require 'ruby_box'
+
+module RubyBox
+  class TimeoutError < Error
+  end
+end

data/lib/ruby_box/version.rb

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

data/lib/ruby_box.rb

@@ -0,0 +1,29 @@
+require 'ruby_box/version'
+
+module RubyBox
+  autoload :Bindings, 'ruby_box/bindings'
+  autoload :BoxedError, 'ruby_box/boxed_error'
+  autoload :Bridging, 'ruby_box/bridging'
+  autoload :CompilationError, 'ruby_box/compilation_error'
+  autoload :Error, 'ruby_box/error'
+  autoload :Execution, 'ruby_box/execution'
+  autoload :ExecutionError, 'ruby_box/execution_error'
+  autoload :Metal, 'ruby_box/metal'
+  autoload :RuntimeEnvironment, 'ruby_box/runtime_environment'
+  autoload :ThreadSafety, 'ruby_box/thread_safety'
+  autoload :TimeoutError, 'ruby_box/timeout_error'
+
+  extend self
+
+  def self.boxed?
+    false
+  end
+
+  def self.current
+    nil
+  end
+
+  def execute(*args, &block)
+    Metal.execute(*args, &block)
+  end
+end

data/vendor/gems/mini_racer/ext/mini_racer_extension/extconf.rb

@@ -0,0 +1,54 @@
+require 'mkmf'
+require 'libv8'
+
+have_library('pthread')
+have_library('objc') if RUBY_PLATFORM =~ /darwin/
+$CPPFLAGS += " -Wall" unless $CPPFLAGS.split.include? "-Wall"
+$CPPFLAGS += " -g" unless $CPPFLAGS.split.include? "-g"
+$CPPFLAGS += " -rdynamic" unless $CPPFLAGS.split.include? "-rdynamic"
+$CPPFLAGS += " -fPIC" unless $CPPFLAGS.split.include? "-rdynamic" or RUBY_PLATFORM =~ /darwin/
+$CPPFLAGS += " -std=c++0x"
+$CPPFLAGS += " -fpermissive"
+
+$LDFLAGS.insert 0, " -stdlib=libstdc++ " if RUBY_PLATFORM =~ /darwin/
+
+if ENV['CXX']
+  puts "SETTING CXX"
+  CONFIG['CXX'] = ENV['CXX']
+end
+
+CXX11_TEST = <<EOS
+#if __cplusplus <= 199711L
+#   error A compiler that supports at least C++11 is required in order to compile this project.
+#endif
+EOS
+
+`echo "#{CXX11_TEST}" | #{CONFIG['CXX']} -std=c++0x -x c++ -E -`
+unless $?.success?
+  warn <<EOS
+
+
+WARNING: C++11 support is required for compiling mini_racer. Please make sure
+you are using a compiler that supports at least C++11. Examples of such
+compilers are GCC 4.7+ and Clang 3.2+.
+
+If you are using Travis, consider either migrating your bulid to Ubuntu Trusty or
+installing GCC 4.8. See mini_racer's README.md for more information.
+
+
+EOS
+end
+
+CONFIG['LDSHARED'] = '$(CXX) -shared' unless RUBY_PLATFORM =~ /darwin/
+if CONFIG['warnflags']
+  CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
+  CONFIG['warnflags'].gsub!('-Wimplicit-function-declaration', '')
+end
+
+if enable_config('debug')
+  CONFIG['debugflags'] << ' -ggdb3 -O0'
+end
+
+Libv8.configure_makefile
+
+create_makefile 'mini_racer_extension'