Implement String prepend

include/natalie/string_object.hpp

@@ -161,6 +161,7 @@ class StringObject : public Object {
     Value match(Env *, Value);
     Value mul(Env *, Value) const;
     Value ord(Env *);
+    Value prepend(Env *, size_t, Value *);
     Value ref(Env *, Value);
     Value reverse(Env *);
     Value rstrip(Env *) const;

lib/natalie/compiler/binding_gen.rb

@@ -812,6 +812,7 @@ def generate_name
   gen.binding('String', 'lstrip', 'StringObject', 'lstrip', argc: 0, pass_env: true, pass_block: false, return_type: :Object)
   gen.binding('String', 'lstrip!', 'StringObject', 'lstrip_in_place', argc: 0, pass_env: true, pass_block: false, return_type: :Object)
   gen.binding('String', 'match', 'StringObject', 'match', argc: 1, pass_env: true, pass_block: false, return_type: :Object)
+  gen.binding('String', 'prepend', 'StringObject', 'prepend', argc: :any, pass_env: true, pass_block: false, return_type: :Object)
   gen.binding('String', 'ord', 'StringObject', 'ord', argc: 0, pass_env: true, pass_block: false, return_type: :Object)
   gen.binding('String', 'reverse', 'StringObject', 'reverse', argc: 0, pass_env: true, pass_block: false, return_type: :Object)
   gen.binding('String', 'rstrip', 'StringObject', 'rstrip', argc: 0, pass_env: true, pass_block: false, return_type: :Object)

spec/core/string/prepend_spec.rb

@@ -0,0 +1,64 @@
+require_relative '../../spec_helper'
+require_relative 'fixtures/classes'
+
+describe "String#prepend" do
+  it "prepends the given argument to self and returns self" do
+    str = "world"
+    str.prepend("hello ").should equal(str)
+    str.should == "hello world"
+  end
+
+  it "converts the given argument to a String using to_str" do
+    obj = mock("hello")
+    obj.should_receive(:to_str).and_return("hello")
+    a = " world!".prepend(obj)
+    a.should == "hello world!"
+  end
+
+  it "raises a TypeError if the given argument can't be converted to a String" do
+    -> { "hello ".prepend [] }.should raise_error(TypeError)
+    -> { 'hello '.prepend mock('x') }.should raise_error(TypeError)
+  end
+
+  it "raises a FrozenError when self is frozen" do
+    a = "hello"
+    a.freeze
+
+    -> { a.prepend "" }.should raise_error(FrozenError)
+    -> { a.prepend "test" }.should raise_error(FrozenError)
+  end
+
+  it "works when given a subclass instance" do
+    a = " world"
+    a.prepend StringSpecs::MyString.new("hello")
+    a.should == "hello world"
+  end
+
+  ruby_version_is ''...'2.7' do
+    it "taints self if other is tainted" do
+      x = "x"
+      x.prepend("".taint).tainted?.should be_true
+
+      x = "x"
+      x.prepend("y".taint).tainted?.should be_true
+    end
+  end
+
+  it "takes multiple arguments" do
+    str = " world"
+    str.prepend "he", "", "llo"
+    str.should == "hello world"
+  end
+
+  it "prepends the initial value when given arguments contain 2 self" do
+    str = "hello"
+    str.prepend str, str
+    str.should == "hellohellohello"
+  end
+
+  it "returns self when given no arguments" do
+    str = "hello"
+    str.prepend.should equal(str)
+    str.should == "hello"
+  end
+end

src/string_object.cpp

@@ -344,6 +344,40 @@ Value StringObject::ord(Env *env) {
     return Value::integer(code);
 }
 
+Value StringObject::prepend(Env *env, size_t argc, Value *args) {
+    assert_not_frozen(env);
+
+    StringObject *original = new StringObject(*this);
+
+    auto to_str = "to_str"_s;
+    String appendable;
+    for (size_t i = 0; i < argc; i++) {
+        auto arg = args[i];
+
+        if (arg == this)
+            arg = original;
+
+        StringObject *str_obj;
+        if (arg->is_string()) {
+            str_obj = arg->as_string();
+        } else if (arg->is_integer() && arg->as_integer()->to_nat_int_t() < 0) {
+            env->raise("RangeError", "less than 0");
+        } else if (arg->is_integer()) {
+            str_obj = arg.send(env, "chr"_s)->as_string();
+        } else if (arg->respond_to(env, to_str)) {
+            str_obj = arg.send(env, to_str)->as_string();
+        } else {
+            env->raise("TypeError", "cannot call to_str", arg->inspect_str(env));
+        }
+
+        str_obj->assert_type(env, Object::Type::String, "String");
+        appendable.append(str_obj->c_str());
+    }
+    m_string.prepend(appendable.c_str());
+
+    return this;
+}
+
 Value StringObject::bytes(Env *env) const {
     ArrayObject *ary = new ArrayObject { length() };
     for (size_t i = 0; i < length(); i++) {