script_core 0.1.1 → 0.2.0

data/ext/enterprise_script_service/mruby/mrblib/range.rb

@@ -26,7 +26,7 @@ def each(&block)
       return self
     end
 
-    if val.kind_of?(String) && last.kind_of?(String) # fixnums are special
+    if val.kind_of?(String) && last.kind_of?(String) # strings are special
       if val.respond_to? :upto
         return val.upto(last, exclude_end?, &block)
       else

data/ext/enterprise_script_service/mruby/mrblib/string.rb

@@ -3,24 +3,51 @@
 #
 # ISO 15.2.10
 class String
+  # ISO 15.2.10.3
   include Comparable
+
   ##
   # Calls the given block for each line
   # and pass the respective line.
   #
   # ISO 15.2.10.5.15
-  def each_line(rs = "\n", &block)
-    return to_enum(:each_line, rs, &block) unless block
-    return block.call(self) if rs.nil?
-    rs.__to_str
-    offset = 0
-    rs_len = rs.length
-    this = dup
-    while pos = this.index(rs, offset)
-      block.call(this[offset, pos + rs_len - offset])
-      offset = pos + rs_len
+  def each_line(separator = "\n", &block)
+    return to_enum(:each_line, separator) unless block
+
+    if separator.nil?
+      block.call(self)
+      return self
+    end
+    raise TypeError unless separator.is_a?(String)
+
+    paragraph_mode = false
+    if separator.empty?
+      paragraph_mode = true
+      separator = "\n\n"
+    end
+    start = 0
+    string = dup
+    self_len = length
+    sep_len = separator.length
+    should_yield_subclass_instances = self.class != String
+
+    while (pointer = string.index(separator, start))
+      pointer += sep_len
+      pointer += 1 while paragraph_mode && string[pointer] == "\n"
+      if should_yield_subclass_instances
+        block.call(self.class.new(string[start, pointer - start]))
+      else
+        block.call(string[start, pointer - start])
+      end
+      start = pointer
+    end
+    return self if start == self_len
+
+    if should_yield_subclass_instances
+      block.call(self.class.new(string[start, self_len - start]))
+    else
+      block.call(string[start, self_len - start])
     end
-    block.call(this[offset, this.size - offset]) if this.size > offset
     self
   end
 
@@ -103,18 +130,15 @@ def gsub!(*args, &block)
     self.replace(str)
   end
 
-  ##
-  # Calls the given block for each match of +pattern+
-  # If no block is given return an array with all
-  # matches of +pattern+.
-  #
-  # ISO 15.2.10.5.32
-  def scan(reg, &block)
-    ### *** TODO *** ###
-    unless Object.const_defined?(:Regexp)
-      raise NotImplementedError, "scan not available (yet)"
-    end
-  end
+#  ##
+#  # Calls the given block for each match of +pattern+
+#  # If no block is given return an array with all
+#  # matches of +pattern+.
+#  #
+#  # ISO 15.2.10.5.32
+#  def scan(pattern, &block)
+#    # TODO: String#scan is not implemented yet
+#  end
 
   ##
   # Replace only the first match of +pattern+ with
@@ -165,21 +189,10 @@ def sub!(*args, &block)
     self.replace(str)
   end
 
-  ##
-  # Call the given block for each character of
-  # +self+.
-  def each_char(&block)
-    pos = 0
-    while pos < self.size
-      block.call(self[pos])
-      pos += 1
-    end
-    self
-  end
-
   ##
   # Call the given block for each byte of +self+.
   def each_byte(&block)
+    return to_enum(:each_byte, &block) unless block
     bytes = self.bytes
     pos = 0
     while pos < bytes.size
@@ -189,86 +202,16 @@ def each_byte(&block)
     self
   end
 
-  ##
-  # Modify +self+ by replacing the content of +self+.
-  # The portion of the string affected is determined using the same criteria as +String#[]+.
-  def []=(*args)
-    anum = args.size
-    if anum == 2
-      pos, value = args
-      case pos
-      when String
-        posnum = self.index(pos)
-        if posnum
-          b = self[0, posnum.to_i]
-          a = self[(posnum + pos.length)..-1]
-          self.replace([b, value, a].join(''))
-        else
-          raise IndexError, "string not matched"
-        end
-      when Range
-        head = pos.begin
-        tail = pos.end
-        tail += self.length if tail < 0
-        unless pos.exclude_end?
-          tail += 1
-        end
-        return self[head, tail-head]=value
-      else
-        pos += self.length if pos < 0
-        if pos < 0 || pos > self.length
-          raise IndexError, "index #{args[0]} out of string"
-        end
-        b = self[0, pos.to_i]
-        a = self[pos + 1..-1]
-        self.replace([b, value, a].join(''))
-      end
-      return value
-    elsif anum == 3
-      pos, len, value = args
-      pos += self.length if pos < 0
-      if pos < 0 || pos > self.length
-        raise IndexError, "index #{args[0]} out of string"
-      end
-      if len < 0
-        raise IndexError, "negative length #{len}"
-      end
-      b = self[0, pos.to_i]
-      a = self[pos + len..-1]
-      self.replace([b, value, a].join(''))
-      return value
-    else
-      raise ArgumentError, "wrong number of arguments (#{anum} for 2..3)"
-    end
-  end
-
+  # those two methods requires Regexp that is optional in mruby
   ##
   # ISO 15.2.10.5.3
-  def =~(re)
-    re =~ self
-  end
+  #def =~(re)
+  # re =~ self
+  #end
 
   ##
   # ISO 15.2.10.5.27
-  def match(re, &block)
-    if String === re
-      if Object.const_defined?(:Regexp)
-        r = Regexp.new(re)
-        r.match(self, &block)
-      else
-        raise NotImplementedError, "String#match needs Regexp class"
-      end
-    else
-      re.match(self, &block)
-    end
-  end
-end
-
-##
-# String is comparable
-#
-# ISO 15.2.10.3
-module Comparable; end
-class String
-  include Comparable
+  #def match(re, &block)
+  #  re.match(self, &block)
+  #end
 end

data/ext/enterprise_script_service/mruby/mruby-source.gemspec

@@ -10,7 +10,7 @@
 
   spec.summary       = %q{MRuby source code wrapper.}
   spec.description   = %q{MRuby source code wrapper for use with Ruby libs.}
-  spec.homepage      = "http://www.mruby.org/"
+  spec.homepage      = "https://mruby.org"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")

data/ext/enterprise_script_service/mruby/oss-fuzz/config/mruby.dict

@@ -0,0 +1,105 @@
+keyword___ENCODING__="__ENCODING__"
+keyword___FILE__="__FILE__"
+keyword___LINE__="__LINE__"
+keyword_BEGIN="BEGIN"
+keyword_END="END"
+keyword_alias="alias"
+keyword_and="and"
+keyword_begin="begin"
+keyword_break="break"
+keyword_case="case"
+keyword_class="class"
+keyword_def="def"
+keyword_do="do"
+keyword_else="else"
+keyword_elsif="elsif"
+keyword_end="end"
+keyword_ensure="ensure"
+keyword_false="false"
+keyword_for="for"
+keyword_if="if"
+keyword_in="in"
+keyword_module="module"
+keyword_next="next"
+keyword_nil="nil"
+keyword_not="not"
+keyword_or="or"
+keyword_redo="redo"
+keyword_rescue="rescue"
+keyword_retry="retry"
+keyword_return="return"
+keyword_self="self"
+keyword_super="super"
+keyword_then="then"
+keyword_true="true"
+keyword_undef="undef"
+keyword_unless="unless"
+keyword_until="until"
+keyword_when="when"
+keyword_while="while"
+keyword_yield="yield"
+
+operator_a=" !"
+operator_b=" ~"
+operator_c=" +"
+operator_d=" -"
+operator_e=" []"
+operator_f=" []="
+operator_g=" *"
+operator_h=" /"
+operator_i=" %"
+operator_j=" +-"
+operator_k=" >>"
+operator_l=" <<"
+operator_m=" &"
+operator_n=" ^"
+operator_o=" |"
+operator_p=" <="
+operator_q=" <>"
+operator_r=" >="
+operator_s=" <=>"
+operator_t=" =="
+operator_u=" ==="
+operator_v=" !="
+operator_w=" =~"
+operator_x=" !~"
+operator_y=" &&"
+operator_z=" ||"
+operator_aa=" .."
+operator_ab=" ..."
+operator_ac=" ?"
+operator_ad=" :"
+operator_ae=" ="
+operator_af=" %="
+operator_ag=" /="
+operator_ah=" -="
+operator_ai=" +="
+operator_aj=" |="
+operator_ak=" &="
+operator_al=" >>="
+operator_am=" <<="
+operator_an=" *="
+operator_ao=" &&="
+operator_ap=" ||="
+operator_aq=" **="
+operator_ar=" ^="
+operator_as=" not"
+operator_at=" or"
+operator_au=" and"
+operator_av=" if"
+operator_aw=" unless"
+operator_ax=" while"
+operator_ay=" until"
+operator_az=" begin"
+operator_ba=" end"
+
+snippet_1eq1=" 1=1"
+snippet_dollar=" $1"
+snippet_at=" @a"
+snippet_symbol=" :a"
+snippet_array=" [1,2]"
+snippet_block=" 1.times{|x| x}"
+snippet_multi=" 1*1"
+
+string_single_q=" 'a'"
+string_dbl_q=" \"a\""

data/ext/enterprise_script_service/mruby/oss-fuzz/config/mruby_fuzzer.options

@@ -0,0 +1,5 @@
+[libfuzzer]
+close_fd_mask = 3
+dict = mruby.dict
+fork = 1
+only_ascii = 1

data/ext/enterprise_script_service/mruby/oss-fuzz/config/mruby_proto_fuzzer.options

@@ -0,0 +1,4 @@
+[libfuzzer]
+close_fd_mask = 3
+dict = mruby.dict
+fork = 1

data/ext/enterprise_script_service/mruby/oss-fuzz/mruby_fuzzer.c

@@ -0,0 +1,18 @@
+#include <stdlib.h>
+#include <string.h>
+#include <mruby.h>
+#include <mruby/compile.h>
+
+int LLVMFuzzerTestOneInput(uint8_t *Data, size_t size) {
+    if (size < 1) {
+        return 0;
+    }
+    char *code = malloc(size+1);
+    memcpy(code, Data, size);
+    code[size] = '\0';
+    mrb_state *mrb = mrb_open();
+    mrb_load_string(mrb, code);
+    mrb_close(mrb);
+    free(code);
+    return 0;
+}

data/ext/enterprise_script_service/mruby/oss-fuzz/mruby_proto_fuzzer.cpp

@@ -0,0 +1,44 @@
+#include <string>
+#include <iostream>
+#include <fstream>
+
+#include <mruby.h>
+#include <mruby/compile.h>
+
+#include "libprotobuf-mutator/src/libfuzzer/libfuzzer_macro.h"
+#include "ruby.pb.h"
+#include "proto_to_ruby.h"
+
+using namespace ruby_fuzzer;
+using namespace std;
+
+int FuzzRB(const uint8_t *Data, size_t size) {
+	mrb_value v;
+	mrb_state *mrb = mrb_open();
+	if (!mrb)
+		return 0;
+
+	char *code = (char *)malloc(size+1);
+	if (!code)
+		return 0;
+	memcpy(code, Data, size);
+	code[size] = '\0';
+
+	if (const char *dump_path = getenv("PROTO_FUZZER_DUMP_PATH")) {
+		// With libFuzzer binary run this to generate an RB file x.rb:
+		// PROTO_FUZZER_DUMP_PATH=x.rb ./a.out proto-input
+		std::ofstream of(dump_path);
+		of.write(code, size);
+	}
+	v = mrb_load_string(mrb, code);
+	mrb_close(mrb);
+
+	free(code);
+	return 0;
+}
+
+DEFINE_PROTO_FUZZER(const Function &function) {
+	protoConverter converter;
+	auto s = converter.FunctionToString(function);
+	(void)FuzzRB((const uint8_t*)s.data(), s.size());
+}

data/ext/enterprise_script_service/mruby/oss-fuzz/proto_to_ruby.cpp

@@ -0,0 +1,455 @@
+#include "proto_to_ruby.h"
+
+using namespace ruby_fuzzer;
+
+std::string protoConverter::removeSpecial(const std::string &x)
+{
+	std::string tmp(x);
+	if (!tmp.empty())
+		tmp.erase(std::remove_if(tmp.begin(), tmp.end(),
+		                         [](char c) { return !(std::isalpha(c) || std::isdigit(c)); } ), tmp.end());
+	return tmp;
+}
+
+void protoConverter::visit(ArrType const& x)
+{
+	if (x.elements_size() > 0) {
+		int i = x.elements_size();
+		m_output << "[";
+		for (auto &e : x.elements()) {
+			i--;
+			if (i == 0) {
+				visit(e);
+			} else {
+				visit(e);
+				m_output << ", ";
+			}
+		}
+		m_output << "]";
+	} else {
+		m_output << "[1]";
+	}
+}
+
+void protoConverter::visit(Array const& x)
+{
+	switch (x.arr_func()) {
+		case Array::FLATTEN:
+			visit(x.arr_arg());
+			m_output << ".flatten";
+			break;
+		case Array::COMPACT:
+			visit(x.arr_arg());
+			m_output << ".compact";
+			break;
+		case Array::FETCH:
+			visit(x.arr_arg());
+			m_output << ".fetch";
+			break;
+		case Array::FILL:
+			visit(x.arr_arg());
+			m_output << ".fill";
+			break;
+		case Array::ROTATE:
+			visit(x.arr_arg());
+			m_output << ".rotate";
+			break;
+		case Array::ROTATE_E:
+			visit(x.arr_arg());
+			m_output << ".rotate!";
+			break;
+		case Array::DELETEIF:
+			visit(x.arr_arg());
+			m_output << ".delete_if";
+			break;
+		case Array::INSERT:
+			visit(x.arr_arg());
+			m_output << ".insert";
+			break;
+		case Array::BSEARCH:
+			visit(x.arr_arg());
+			m_output << ".bsearch";
+			break;
+		case Array::KEEPIF:
+			visit(x.arr_arg());
+			m_output << ".keep_if";
+			break;
+		case Array::SELECT:
+			visit(x.arr_arg());
+			m_output << ".select";
+			break;
+		case Array::VALUES_AT:
+			visit(x.arr_arg());
+			m_output << ".values_at";
+			break;
+		case Array::BLOCK:
+			visit(x.arr_arg());
+			m_output << ".index";
+			break;
+		case Array::DIG:
+			visit(x.arr_arg());
+			m_output << ".dig";
+			break;
+		case Array::SLICE:
+			visit(x.arr_arg());
+			m_output << ".slice";
+			break;
+		case Array::PERM:
+			visit(x.arr_arg());
+			m_output << ".permutation";
+			break;
+		case Array::COMB:
+			visit(x.arr_arg());
+			m_output << ".combination";
+			break;
+		case Array::ASSOC:
+			visit(x.arr_arg());
+			m_output << ".assoc";
+			break;
+		case Array::RASSOC:
+			visit(x.arr_arg());
+			m_output << ".rassoc";
+			break;
+	}
+	m_output << "(";
+	visit(x.val_arg());
+	m_output << ")";
+}
+
+void protoConverter::visit(AssignmentStatement const& x)
+{
+	m_output << "var_" << m_numLiveVars << " = ";
+	visit(x.rvalue());
+	m_numVarsPerScope.top()++;
+	m_numLiveVars++;
+	m_output << "\n";
+}
+
+void protoConverter::visit(BinaryOp const& x)
+{
+	m_output << "(";
+	visit(x.left());
+	switch (x.op()) {
+		case BinaryOp::ADD: m_output << " + "; break;
+		case BinaryOp::SUB: m_output << " - "; break;
+		case BinaryOp::MUL: m_output << " * "; break;
+		case BinaryOp::DIV: m_output << " / "; break;
+		case BinaryOp::MOD: m_output << " % "; break;
+		case BinaryOp::XOR: m_output << " ^ "; break;
+		case BinaryOp::AND: m_output << " and "; break;
+		case BinaryOp::OR: m_output << " or "; break;
+		case BinaryOp::EQ: m_output << " == "; break;
+		case BinaryOp::NE: m_output << " != "; break;
+		case BinaryOp::LE: m_output << " <= "; break;
+		case BinaryOp::GE: m_output << " >= "; break;
+		case BinaryOp::LT: m_output << " < "; break;
+		case BinaryOp::GT: m_output << " > "; break;
+		case BinaryOp::RS: m_output << " >> "; break;
+	}
+	visit(x.right());
+	m_output << ")";
+}
+
+void protoConverter::visit(BuiltinFuncs const& x)
+{
+	switch (x.bifunc_oneof_case()) {
+		case BuiltinFuncs::kOs:
+			visit(x.os());
+			break;
+		case BuiltinFuncs::kTime:
+			visit(x.time());
+			break;
+		case BuiltinFuncs::kArr:
+			visit(x.arr());
+			break;
+		case BuiltinFuncs::kMops:
+			visit(x.mops());
+			break;
+		case BuiltinFuncs::BIFUNC_ONEOF_NOT_SET:
+			m_output << "1";
+			break;
+	}
+	m_output << "\n";
+}
+
+void protoConverter::visit(Const const& x)
+{
+	switch (x.const_oneof_case()) {
+		case Const::kIntLit:
+			m_output << "(" << (x.int_lit() % 13) << ")";
+			break;
+		case Const::kBoolVal:
+			m_output << "(" << x.bool_val() << ")";
+			break;
+		case Const::CONST_ONEOF_NOT_SET:
+			m_output << "1";
+			break;
+	}
+}
+
+void protoConverter::visit(Function const& x)
+{
+	m_output << "def foo()\nvar_0 = 1\n";
+	visit(x.statements());
+	m_output << "end\n";
+	m_output << "foo\n";
+}
+
+void protoConverter::visit(HashType const& x)
+{
+	if (x.keyval_size() > 0) {
+		int i = x.keyval_size();
+		m_output << "{";
+		for (auto &e : x.keyval()) {
+			i--;
+			if (i == 0) {
+				visit(e);
+			}
+			else {
+				visit(e);
+				m_output << ", ";
+			}
+		}
+		m_output << "}";
+	}
+}
+
+void protoConverter::visit(IfElse const& x)
+{
+	m_output << "if ";
+	visit(x.cond());
+	m_output << "\n";
+	visit(x.if_body());
+	m_output << "\nelse\n";
+	visit(x.else_body());
+	m_output << "\nend\n";
+}
+
+void protoConverter::visit(KVPair const& x)
+{
+	m_output << "\"" << removeSpecial(x.key()) << "\"";
+	m_output << " => ";
+	m_output << "\"" << removeSpecial(x.val()) << "\"";
+}
+
+void protoConverter::visit(MathConst const& x)
+{
+	switch (x.math_const()) {
+		case MathConst::PI:
+			m_output << "Math::PI";
+			break;
+		case MathConst::E:
+			m_output << "Math::E";
+			break;
+	}
+}
+
+void protoConverter::visit(MathOps const& x)
+{
+	switch (x.math_op()) {
+		case MathOps::CBRT:
+			m_output << "Math.cbrt(";
+			visit(x.math_arg());
+			m_output << ")";
+			break;
+		case MathOps::COS:
+			m_output << "Math.cos(";
+			visit(x.math_arg());
+			m_output << ")";
+			break;
+		case MathOps::ERF:
+			m_output << "Math.erf(";
+			visit(x.math_arg());
+			m_output << ")";
+			break;
+		case MathOps::ERFC:
+			m_output << "Math.erfc(";
+			visit(x.math_arg());
+			m_output << ")";
+			break;
+		case MathOps::LOG:
+			m_output << "Math.log(";
+			visit(x.math_arg());
+			m_output << ")";
+			break;
+		case MathOps::LOG10:
+			m_output << "Math.log10(";
+			visit(x.math_arg());
+			m_output << ")";
+			break;
+		case MathOps::LOG2:
+			m_output << "Math.log2(";
+			visit(x.math_arg());
+			m_output << ")";
+			break;
+		case MathOps::SIN:
+			m_output << "Math.sin(";
+			visit(x.math_arg());
+			m_output << ")";
+			break;
+		case MathOps::SQRT:
+			m_output << "Math.sqrt(";
+			visit(x.math_arg());
+			m_output << ")";
+			break;
+		case MathOps::TAN:
+			m_output << "Math.tan(";
+			visit(x.math_arg());
+			m_output << ")";
+			break;
+	}
+}
+
+void protoConverter::visit(MathType const& x)
+{
+	switch (x.math_arg_oneof_case()) {
+		case MathType::kMathRval:
+			visit(x.math_rval());
+			break;
+		case MathType::kMathConst:
+			visit(x.math_const());
+			break;
+		case MathType::MATH_ARG_ONEOF_NOT_SET:
+			m_output << "1";
+			break;
+	}
+}
+
+void protoConverter::visit(ObjectSpace const& x)
+{
+	switch (x.os_func()) {
+		case ObjectSpace::COUNT:
+			m_output << "ObjectSpace.count_objects";
+			break;
+	}
+	m_output << "(";
+	visit(x.os_arg());
+	m_output << ")" << "\n";
+}
+
+void protoConverter::visit(Rvalue const& x)
+{
+	switch (x.rvalue_oneof_case()) {
+		case Rvalue::kVarref:
+			visit(x.varref());
+			break;
+		case Rvalue::kCons:
+			visit(x.cons());
+			break;
+		case Rvalue::kBinop:
+			visit(x.binop());
+			break;
+		case Rvalue::RVALUE_ONEOF_NOT_SET:
+			m_output << "1";
+			break;
+	}
+}
+
+void protoConverter::visit(Statement const& x)
+{
+	switch (x.stmt_oneof_case()) {
+		case Statement::kAssignment:
+			visit(x.assignment());
+			break;
+		case Statement::kIfelse:
+			visit(x.ifelse());
+			break;
+		case Statement::kTernaryStmt:
+			visit(x.ternary_stmt());
+			break;
+		case Statement::kBuiltins:
+			visit(x.builtins());
+			break;
+		case Statement::kBlockstmt:
+			visit(x.blockstmt());
+			break;
+		case Statement::STMT_ONEOF_NOT_SET:
+			break;
+	}
+	m_output << "\n";
+}
+
+void protoConverter::visit(StatementSeq const& x)
+{
+	if (x.statements_size() > 0) {
+		m_numVarsPerScope.push(0);
+		m_output << "@scope ||= begin\n";
+		for (auto &st : x.statements())
+			visit(st);
+		m_output << "end\n";
+		m_numLiveVars -= m_numVarsPerScope.top();
+		m_numVarsPerScope.pop();
+	}
+}
+
+void protoConverter::visit(StringExtNoArg const& x)
+{
+	m_output << "\"" << removeSpecial(x.str_arg()) << "\"";
+	switch (x.str_op()) {
+		case StringExtNoArg::DUMP:
+			m_output << ".dump";
+			break;
+		case StringExtNoArg::STRIP:
+			m_output << ".strip";
+			break;
+		case StringExtNoArg::LSTRIP:
+			m_output << ".lstrip";
+			break;
+		case StringExtNoArg::RSTRIP:
+			m_output << ".rstrip";
+			break;
+		case StringExtNoArg::STRIPE:
+			m_output << ".strip!";
+			break;
+		case StringExtNoArg::LSTRIPE:
+			m_output << ".lstrip!";
+			break;
+		case StringExtNoArg::RSTRIPE:
+			m_output << ".rstrip!";
+			break;
+		case StringExtNoArg::SWAPCASE:
+			m_output << ".swapcase";
+			break;
+		case StringExtNoArg::SWAPCASEE:
+			m_output << ".swapcase!";
+			break;
+		case StringExtNoArg::SQUEEZE:
+			m_output << ".squeeze";
+			break;
+	}
+}
+
+void protoConverter::visit(Ternary const& x)
+{
+	m_output << "(";
+	visit(x.tern_cond());
+	m_output << " ? ";
+	visit(x.t_branch());
+	m_output << " : ";
+	visit(x.f_branch());
+	m_output << ")\n";
+}
+
+void protoConverter::visit(Time const& x)
+{
+	switch (x.t_func()) {
+		case Time::AT:
+			m_output << "Time.at";
+			break;
+		case Time::GM:
+			m_output << "Time.gm";
+			break;
+	}
+	m_output << "(" << (x.t_arg()% 13) << ")" << "\n";
+}
+
+void protoConverter::visit(VarRef const& x)
+{
+	m_output << "var_" << (static_cast<uint32_t>(x.varnum()) % m_numLiveVars);
+}
+
+std::string protoConverter::FunctionToString(Function const& input)
+{
+	visit(input);
+	return m_output.str();
+}