script_core 0.2.0 → 0.2.5

data/ext/enterprise_script_service/msgpack/test/shared_ptr_cpp11.cpp

@@ -20,8 +20,9 @@ TEST(SHARED_PTR, pack_convert_nil)
     std::stringstream ss;
     std::shared_ptr<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -31,8 +32,9 @@ TEST(SHARED_PTR, pack_convert_int)
     std::stringstream ss;
     std::shared_ptr<int> val1(new int(1));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
     EXPECT_TRUE(*val1 == *val2);
 }
@@ -119,8 +121,9 @@ TEST(SHARED_PTR, pack_convert_nil_no_def_con)
     std::stringstream ss;
     std::shared_ptr<no_def_con> val1(new no_def_con(1));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::shared_ptr<no_def_con> val2 = oh.get().as<std::shared_ptr<no_def_con>>();
     EXPECT_TRUE(*val1 == *val2);
 }

data/ext/enterprise_script_service/msgpack/test/size_equal_only.cpp

@@ -15,7 +15,8 @@ TEST(size_equal_only, array)
     msgpack::type::size_equal_only<int[3]> seo(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     int ret_buf1[3];
     oh.get().convert(ret_buf1);
@@ -58,7 +59,8 @@ TEST(size_equal_only, vector)
     msgpack::type::size_equal_only<std::vector<int> > seo(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     std::vector<int> ret_buf1;
     oh.get().convert(ret_buf1);
@@ -91,7 +93,8 @@ TEST(size_equal_only, msgpack_tuple)
     msgpack::type::size_equal_only<msgpack::type::tuple<int, bool, std::string> > seo(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     msgpack::type::tuple<int, bool, std::string> ret_buf1;
     oh.get().convert(ret_buf1);
@@ -148,7 +151,8 @@ TEST(size_equal_only, tuple)
     auto seo = msgpack::type::make_size_equal_only(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     std::tuple<int, bool, std::string> ret_buf1;
     oh.get().convert(ret_buf1);
@@ -210,7 +214,8 @@ TEST(size_equal_only, custom_class)
     std::stringstream ss;
     foo1 f1(42, true);
     msgpack::pack(ss, f1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     foo2 f2(123, false, "ABC");
     try {

data/ext/enterprise_script_service/msgpack/test/unique_ptr_cpp11.cpp

@@ -20,8 +20,9 @@ TEST(UNIQUE_PTR, pack_convert_nil)
     std::stringstream ss;
     std::unique_ptr<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::unique_ptr<int> val2 = oh.get().as<std::unique_ptr<int>>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -31,8 +32,9 @@ TEST(UNIQUE_PTR, pack_convert_int)
     std::stringstream ss;
     std::unique_ptr<int> val1(new int(1));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::unique_ptr<int> val2 = oh.get().as<std::unique_ptr<int>>();
     EXPECT_TRUE(*val1 == *val2);
 }
@@ -119,8 +121,9 @@ TEST(UNIQUE_PTR, pack_convert_nil_no_def_con)
     std::stringstream ss;
     std::unique_ptr<no_def_con> val1(new no_def_con(1));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::unique_ptr<no_def_con> val2 = oh.get().as<std::unique_ptr<no_def_con>>();
     EXPECT_TRUE(*val1 == *val2);
 }

data/ext/enterprise_script_service/msgpack/test/visitor.cpp

@@ -98,7 +98,8 @@ TEST(visitor, json_like)
     std::string json_like;
     json_like_visitor v(json_like);
     std::size_t off = 0;
-    bool ret = msgpack::parse(ss.str().data(), ss.str().size(), off, v);
+    std::string const& str = ss.str();
+    bool ret = msgpack::parse(str.data(), str.size(), off, v);
     EXPECT_TRUE(ret);
     EXPECT_EQ("{\"key\":[42,null,true]}", json_like);
 }

data/lib/script_core/engine.rb

@@ -21,15 +21,34 @@ def initialize(bin_path = ScriptCore::DEFAULT_BIN_PATH,
       @instructions = File.exist?(preload_instructions_path) ? File.binread(preload_instructions_path) : nil
     end
 
-    def eval(sources, input: nil, instruction_quota_start: nil, environment_variables: {})
+    def eval(
+      sources, input: {}, environment_variables: {},
+      instruction_quota: nil, instruction_quota_start: nil, memory_quota: nil, timeout: nil
+    )
       @executable.run(
-        input: input || {},
+        input: input,
         sources: sources,
         instructions: @instructions,
-        timeout: @timeout,
-        instruction_quota: @instruction_quota,
+        timeout: timeout || @timeout,
+        instruction_quota: instruction_quota || @instruction_quota,
         instruction_quota_start: instruction_quota_start || @instruction_quota_start,
-        memory_quota: @memory_quota,
+        memory_quota: memory_quota || @memory_quota,
+        environment_variables: environment_variables
+      )
+    end
+
+    def eval_mrb(
+      binary_mrb, input: {}, environment_variables: {},
+      instruction_quota: nil, instruction_quota_start: nil, memory_quota: nil, timeout: nil
+    )
+      @executable.run(
+        input: input,
+        sources: [],
+        instructions: binary_mrb,
+        timeout: timeout || @timeout,
+        instruction_quota: instruction_quota || @instruction_quota,
+        instruction_quota_start: instruction_quota_start || @instruction_quota_start,
+        memory_quota: memory_quota || @memory_quota,
         environment_variables: environment_variables
       )
     end

data/lib/script_core/executable.rb

@@ -12,9 +12,10 @@ def initialize(executable_path)
       @executable_path = executable_path.to_s
     end
 
-    def run(input: {}, sources:, instructions: nil,
-            timeout: 1, instruction_quota: 100_000, instruction_quota_start: 0, memory_quota: 8 << 20,
-            environment_variables: {})
+    def run(
+      input: {}, environment_variables: {}, sources:, instructions: nil,
+      timeout: 1, instruction_quota: 100_000, instruction_quota_start: 0, memory_quota: 8 << 20
+    )
       packer = ScriptCore::Protocol.packer_factory.packer
 
       payload = { input: input, sources: sources }

data/lib/script_core/result.rb

@@ -1,11 +1,7 @@
 # frozen_string_literal: true
 
 module ScriptCore
-  Result = Struct.new(:output, :stdout, :stat, :measurements, :errors) do
-    def initialize(output:, stdout:, stat:, measurements:, errors:)
-      super(output, stdout, stat, measurements, errors)
-    end
-
+  Result = Struct.new(:output, :stdout, :stat, :measurements, :errors, keyword_init: true) do
     def success?
       errors.empty?
     end

data/lib/script_core/service_channel.rb

@@ -13,6 +13,7 @@ def write(buffer)
       in_writer.write(buffer)
       nil
     rescue Errno::EPIPE
+      nil
     end
 
     def read(*args)

data/lib/script_core/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ScriptCore
-  VERSION = "0.2.0"
+  VERSION = "0.2.5"
 end

data/lib/tasks/script_core.rake

@@ -63,7 +63,9 @@
       end
 
       Dir.chdir(SCRIPT_CORE_ROOT.join("ext/enterprise_script_service")) do
-        sh("#{env_vars} #{Rails.root.join('bin', 'bundle')} exec rake")
+        bundle_stub_path = Rails.root.join("bin", "bundle")
+        bundle_cmd = File.exist?(bundle_stub_path) ? bundle_stub_path : "bundle"
+        sh("#{env_vars} #{bundle_cmd} exec rake")
       end
     end
 

data/script_core.gemspec

@@ -35,13 +35,11 @@
   spec.extensions = ["ext/enterprise_script_service/Rakefile"]
   spec.homepage = "https://github.com/rails-engine/script_core"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.4"
+  spec.required_ruby_version = ">= 2.5"
 
   spec.add_dependency("msgpack", "~> 1.0")
   spec.add_dependency("rake-compiler", "~> 1.0")
 
-  spec.add_development_dependency("pry", "~> 0.11")
-  spec.add_development_dependency("pry-byebug", "~> 3.4")
-  spec.add_development_dependency("rake", "~> 12.0")
+  spec.add_development_dependency("rake", "~> 12")
   spec.add_development_dependency("rspec", "~> 3.5")
 end

data/spec/dummy/app/lib/script_engine.rb

@@ -2,11 +2,43 @@
 
 module ScriptEngine
   class << self
+    ENGINE_PATH = Rails.root.join("mruby")
+
     def engine
-      @engine ||= ScriptCore::Engine.new Rails.root.join("mruby/bin")
+      @engine ||= ScriptCore::Engine.new ENGINE_PATH.join("bin")
     end
 
-    def run(string, payload: nil, instruction_quota_start: nil)
+    def precompile(code, with_lib: true)
+      wrapped_code =
+        if with_lib
+          "prepare; Output.value = class Object\n#{code}\nend; pack_output"
+        else
+          code
+        end
+
+      mrbc_executable = ENGINE_PATH.join("bin/mrbc").realpath
+      tmp_dir = Rails.root.join("tmp")
+      lib_files = with_lib ? Dir[ENGINE_PATH.join("lib/**/*.rb").to_s] : []
+
+      code_sha = Digest::SHA2.hexdigest(wrapped_code)
+      tmp_rb = tmp_dir.join("#{code_sha}.rb")
+      tmp_output = tmp_dir.join("#{code_sha}.mrb")
+      cmd = "#{mrbc_executable} --remove-lv -o #{tmp_output} #{lib_files.join(' ')} #{tmp_rb}"
+
+      File.write tmp_rb, wrapped_code
+      system(cmd, exception: true)
+
+      compiled = File.binread tmp_output
+
+      FileUtils.rm([tmp_rb, tmp_output])
+
+      compiled
+    end
+
+    def run(
+      string, payload: nil,
+      instruction_quota: nil, instruction_quota_start: nil, memory_quota: nil, timeout: nil
+    )
       sources = [
         %w[preparing prepare],
         ["user", string],
@@ -20,14 +52,41 @@ def run(string, payload: nil, instruction_quota_start: nil)
                     },
                     payload: payload
                   },
+                  environment_variables: { "TZ" => Time.zone.name },
+                  instruction_quota: instruction_quota,
                   instruction_quota_start: instruction_quota_start,
-                  environment_variables: { "TZ" => Time.zone.name }
+                  memory_quota: memory_quota,
+                  timeout: timeout
     end
 
-    def run_inline(string, payload: nil, instruction_quota_start: nil)
-      run "Output.value = module Main\n#{string}\nend",
+    def run_inline(
+      string, payload: nil,
+      instruction_quota: nil, instruction_quota_start: nil, memory_quota: nil, timeout: nil
+    )
+      run "Output.value = class Object\n#{string}\nend",
           payload: payload,
-          instruction_quota_start: instruction_quota_start
+          instruction_quota: instruction_quota,
+          instruction_quota_start: instruction_quota_start,
+          memory_quota: memory_quota,
+          timeout: timeout
+    end
+
+    def run_precompiled(
+      binary_mrb, payload: nil,
+      instruction_quota: nil, instruction_quota_start: nil, memory_quota: nil, timeout: nil
+    )
+      engine.eval_mrb binary_mrb,
+                      input: {
+                        configuration: {
+                          time_zone_offset: Time.zone.formatted_offset(false)
+                        },
+                        payload: payload
+                      },
+                      environment_variables: { "TZ" => Time.zone.name },
+                      instruction_quota: instruction_quota,
+                      instruction_quota_start: instruction_quota_start,
+                      memory_quota: memory_quota,
+                      timeout: timeout
     end
   end
 end

data/spec/dummy/app/models/concerns/enum_attribute_localizable.rb

@@ -26,7 +26,7 @@ def human_enum_value(attribute, value, options = {})
       defaults << value.to_s.humanize
 
       options[:default] = defaults
-      I18n.translate(defaults.shift, options)
+      I18n.translate(defaults.shift, **options)
     end
   end
 end

data/spec/dummy/bin/bundle

@@ -1,5 +1,114 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-load Gem.bin_path("bundler", "bundle")
+#
+# This file was generated by Bundler.
+#
+# The application 'bundle' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "rubygems"
+
+m = Module.new do
+  module_function
+
+  def invoked_as_script?
+    File.expand_path($0) == File.expand_path(__FILE__)
+  end
+
+  def env_var_version
+    ENV["BUNDLER_VERSION"]
+  end
+
+  def cli_arg_version
+    return unless invoked_as_script? # don't want to hijack other binstubs
+    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
+    bundler_version = nil
+    update_index = nil
+    ARGV.each_with_index do |a, i|
+      if update_index && update_index.succ == i && a =~ Gem::Version::ANCHORED_VERSION_PATTERN
+        bundler_version = a
+      end
+      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
+      bundler_version = $1
+      update_index = i
+    end
+    bundler_version
+  end
+
+  def gemfile
+    gemfile = ENV["BUNDLE_GEMFILE"]
+    return gemfile if gemfile && !gemfile.empty?
+
+    File.expand_path("../../Gemfile", __FILE__)
+  end
+
+  def lockfile
+    lockfile =
+      case File.basename(gemfile)
+      when "gems.rb" then gemfile.sub(/\.rb$/, gemfile)
+      else "#{gemfile}.lock"
+      end
+    File.expand_path(lockfile)
+  end
+
+  def lockfile_version
+    return unless File.file?(lockfile)
+    lockfile_contents = File.read(lockfile)
+    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
+    Regexp.last_match(1)
+  end
+
+  def bundler_version
+    @bundler_version ||=
+      env_var_version || cli_arg_version ||
+        lockfile_version
+  end
+
+  def bundler_requirement
+    return "#{Gem::Requirement.default}.a" unless bundler_version
+
+    bundler_gem_version = Gem::Version.new(bundler_version)
+
+    requirement = bundler_gem_version.approximate_recommendation
+
+    return requirement unless Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.7.0")
+
+    requirement += ".a" if bundler_gem_version.prerelease?
+
+    requirement
+  end
+
+  def load_bundler!
+    ENV["BUNDLE_GEMFILE"] ||= gemfile
+
+    activate_bundler
+  end
+
+  def activate_bundler
+    gem_error = activation_error_handling do
+      gem "bundler", bundler_requirement
+    end
+    return if gem_error.nil?
+    require_error = activation_error_handling do
+      require "bundler/version"
+    end
+    return if require_error.nil? && Gem::Requirement.new(bundler_requirement).satisfied_by?(Gem::Version.new(Bundler::VERSION))
+    warn "Activating bundler (#{bundler_requirement}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_requirement}'`"
+    exit 42
+  end
+
+  def activation_error_handling
+    yield
+    nil
+  rescue StandardError, LoadError => e
+    e
+  end
+end
+
+m.load_bundler!
+
+if m.invoked_as_script?
+  load Gem.bin_path("bundler", "bundle")
+end