jruby · Jun 20, 2015 · Jun 20, 2015 · Jun 20, 2015
diff --git a/spec/truffle/tags/core/env/assoc_tags.txt b/spec/truffle/tags/core/env/assoc_tags.txt
diff --git a/spec/truffle/tags/core/env/clear_tags.txt b/spec/truffle/tags/core/env/clear_tags.txt
diff --git a/spec/truffle/tags/core/env/delete_if_tags.txt b/spec/truffle/tags/core/env/delete_if_tags.txt
diff --git a/spec/truffle/tags/core/env/delete_tags.txt b/spec/truffle/tags/core/env/delete_tags.txt
diff --git a/spec/truffle/tags/core/env/each_key_tags.txt b/spec/truffle/tags/core/env/each_key_tags.txt
diff --git a/spec/truffle/tags/core/env/each_pair_tags.txt b/spec/truffle/tags/core/env/each_pair_tags.txt
diff --git a/spec/truffle/tags/core/env/each_tags.txt b/spec/truffle/tags/core/env/each_tags.txt
diff --git a/spec/truffle/tags/core/env/each_value_tags.txt b/spec/truffle/tags/core/env/each_value_tags.txt
diff --git a/spec/truffle/tags/core/env/element_reference_tags.txt b/spec/truffle/tags/core/env/element_reference_tags.txt
diff --git a/spec/truffle/tags/core/env/element_set_tags.txt b/spec/truffle/tags/core/env/element_set_tags.txt
@@ -1,8 +1,2 @@
-fails:ENV.[]= deletes the environment variable when the value is nil
-fails:ENV.[]= coerces the key argument with #to_str
-fails:ENV.[]= coerces the value argument with #to_str
-fails:ENV.[]= raises TypeError when the key is not coercible to String
-fails:ENV.[]= raises TypeError when the value is not coercible to String
 fails:ENV.[]= raises Errno::EINVAL when the key contains the '=' character
 fails:ENV.[]= raises Errno::EINVAL when the key is an empty string
-fails:ENV.[]= does nothing when the key is not a valid environment variable key and the value is nil
diff --git a/spec/truffle/tags/core/env/empty_tags.txt b/spec/truffle/tags/core/env/empty_tags.txt
diff --git a/spec/truffle/tags/core/env/fetch_tags.txt b/spec/truffle/tags/core/env/fetch_tags.txt
diff --git a/spec/truffle/tags/core/env/index_tags.txt b/spec/truffle/tags/core/env/index_tags.txt
diff --git a/spec/truffle/tags/core/env/keep_if_tags.txt b/spec/truffle/tags/core/env/keep_if_tags.txt
diff --git a/spec/truffle/tags/core/env/key_tags.txt b/spec/truffle/tags/core/env/key_tags.txt
diff --git a/spec/truffle/tags/core/env/keys_tags.txt b/spec/truffle/tags/core/env/keys_tags.txt
diff --git a/spec/truffle/tags/core/env/length_tags.txt b/spec/truffle/tags/core/env/length_tags.txt
diff --git a/spec/truffle/tags/core/env/rassoc_tags.txt b/spec/truffle/tags/core/env/rassoc_tags.txt
diff --git a/spec/truffle/tags/core/env/reject_tags.txt b/spec/truffle/tags/core/env/reject_tags.txt
@@ -1,11 +1 @@
-fails:ENV.reject! rejects entries based on key
-fails:ENV.reject! rejects entries based on value
-fails:ENV.reject! returns itself or nil
-fails:ENV.reject! returns an Enumerator if called without a block
-fails:ENV.reject! doesn't raise if empty
-fails:ENV.reject rejects entries based on key
-fails:ENV.reject rejects entries based on value
-fails:ENV.reject returns a Hash
-fails:ENV.reject doesn't raise if empty
-fails:ENV.reject! when no block is given returned Enumerator size returns the enumerable size
 fails:ENV.reject when no block is given returned Enumerator size returns the enumerable size
diff --git a/spec/truffle/tags/core/env/replace_tags.txt b/spec/truffle/tags/core/env/replace_tags.txt
diff --git a/spec/truffle/tags/core/env/select_tags.txt b/spec/truffle/tags/core/env/select_tags.txt
diff --git a/spec/truffle/tags/core/env/shift_tags.txt b/spec/truffle/tags/core/env/shift_tags.txt
@@ -1,4 +1,3 @@
-fails:ENV.shift returns a pair and deletes it
 fails:ENV.shift returns nil if ENV.empty?
 fails:ENV.shift uses the locale encoding if Encoding.default_internal is nil
 fails:ENV.shift transcodes from the locale encoding to Encoding.default_internal if set
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java
@@ -76,24 +76,32 @@ public abstract class KernelNodes {
     @CoreMethod(names = "`", isModuleFunction = true, needsSelf = false, required = 1)
     public abstract static class BacktickNode extends CoreMethodArrayArgumentsNode {
 
+        @Child private CallDispatchHeadNode toHashNode;
+
         public BacktickNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
         @Specialization
-        public RubyBasicObject backtick(RubyString command) {
+        public RubyBasicObject backtick(VirtualFrame frame, RubyString command) {
             // Command is lexically a string interoplation, so variables will already have been expanded
 
+            if (toHashNode == null) {
+                CompilerDirectives.transferToInterpreter();
+                toHashNode = insert(DispatchHeadNodeFactory.createMethodCall(getContext()));
+            }
+
             CompilerDirectives.transferToInterpreter();
 
             final RubyContext context = getContext();
 
             final RubyBasicObject env = context.getCoreLibrary().getENV();
+            final RubyBasicObject envAsHash = (RubyBasicObject) toHashNode.call(frame, env, "to_hash", null);
 
             final List<String> envp = new ArrayList<>();
 
             // TODO(CS): cast
-            for (Map.Entry<Object, Object> keyValue : HashNodes.iterableKeyValues(env)) {
+            for (Map.Entry<Object, Object> keyValue : HashNodes.iterableKeyValues(envAsHash)) {
                 envp.add(keyValue.getKey().toString() + "=" + keyValue.getValue().toString());
             }
 
@@ -528,12 +536,19 @@ public Object eval(RubyString source, RubyBasicObject badBinding, NotProvided fi
     @CoreMethod(names = "exec", isModuleFunction = true, required = 1, argumentsAsArray = true)
     public abstract static class ExecNode extends CoreMethodArrayArgumentsNode {
 
+        @Child private CallDispatchHeadNode toHashNode;
+
         public ExecNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
         @Specialization
-        public Object require(Object[] args) {
+        public Object require(VirtualFrame frame, Object[] args) {
+            if (toHashNode == null) {
+                CompilerDirectives.transferToInterpreter();
+                toHashNode = insert(DispatchHeadNodeFactory.createMethodCall(getContext()));
+            }
+
             CompilerDirectives.transferToInterpreter();
 
             final String[] commandLine = new String[args.length];
@@ -542,19 +557,20 @@ public Object require(Object[] args) {
                 commandLine[n] = args[n].toString();
             }
 
-            exec(getContext(), commandLine);
+            final RubyBasicObject env = getContext().getCoreLibrary().getENV();
+            final RubyBasicObject envAsHash = (RubyBasicObject) toHashNode.call(frame, env, "to_hash", null);
+
+            exec(getContext(), envAsHash, commandLine);
 
             return null;
         }
 
         @TruffleBoundary
-        private static void exec(RubyContext context, String[] commandLine) {
+        private static void exec(RubyContext context, RubyBasicObject envAsHash, String[] commandLine) {
             final ProcessBuilder builder = new ProcessBuilder(commandLine);
             builder.inheritIO();
 
-            final RubyBasicObject env = context.getCoreLibrary().getENV();
-
-            for (Map.Entry<Object, Object> keyValue : HashNodes.iterableKeyValues(env)) {
+            for (Map.Entry<Object, Object> keyValue : HashNodes.iterableKeyValues(envAsHash)) {
                 builder.environment().put(keyValue.getKey().toString(), keyValue.getValue().toString());
             }
 
@@ -1804,22 +1820,30 @@ protected RubyString asRubyString(Object arg) {
     @CoreMethod(names = "system", isModuleFunction = true, needsSelf = false, required = 1)
     public abstract static class SystemNode extends CoreMethodArrayArgumentsNode {
 
+        @Child private CallDispatchHeadNode toHashNode;
+
         public SystemNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
         @Specialization
-        public boolean system(RubyString command) {
+        public boolean system(VirtualFrame frame, RubyString command) {
+            if (toHashNode == null) {
+                CompilerDirectives.transferToInterpreter();
+                toHashNode = insert(DispatchHeadNodeFactory.createMethodCall(getContext()));
+            }
+
             CompilerDirectives.transferToInterpreter();
 
             // TODO(CS 5-JAN-15): very simplistic implementation
 
             final RubyBasicObject env = getContext().getCoreLibrary().getENV();
+            final RubyBasicObject envAsHash = (RubyBasicObject) toHashNode.call(frame, env, "to_hash", null);
 
             final List<String> envp = new ArrayList<>();
 
             // TODO(CS): cast
-            for (Map.Entry<Object, Object> keyValue : HashNodes.iterableKeyValues(env)) {
+            for (Map.Entry<Object, Object> keyValue : HashNodes.iterableKeyValues(envAsHash)) {
                 envp.add(keyValue.getKey().toString() + "=" + keyValue.getValue().toString());
             }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/PosixNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/PosixNodes.java
@@ -20,12 +20,14 @@
 import org.jruby.truffle.nodes.core.CoreMethod;
 import org.jruby.truffle.nodes.core.CoreMethodArrayArgumentsNode;
 import org.jruby.truffle.nodes.core.StringNodes;
+import org.jruby.truffle.nodes.core.array.ArrayNodes;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.RubyBasicObject;
 import org.jruby.truffle.runtime.core.RubyString;
 
 import java.nio.charset.StandardCharsets;
+import java.util.Map;
 
 @CoreClass(name = "Rubinius::FFI::Platform::POSIX")
 public abstract class PosixNodes {
@@ -87,6 +89,19 @@ public int dup(int descriptor) {
 
     }
 
+    @CoreMethod(names = "environ", isModuleFunction = true)
+    public abstract static class EnvironNode extends CoreMethodArrayArgumentsNode {
+
+        public EnvironNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @Specialization
+        public RubyBasicObject environ() {
+            return PointerNodes.createPointer(getContext().getCoreLibrary().getRubiniusFFIPointerClass(), posix().environ());
+        }
+    }
+
     @CoreMethod(names = "fchmod", isModuleFunction = true, required = 2)
     public abstract static class FchmodNode extends CoreMethodArrayArgumentsNode {
 
@@ -145,6 +160,27 @@ public int getEGID() {
 
     }
 
+    @CoreMethod(names = "getenv", isModuleFunction = true, required = 1)
+    public abstract static class GetenvNode extends CoreMethodArrayArgumentsNode {
+
+        public GetenvNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @Specialization(guards = "isRubyString(name)")
+        public RubyBasicObject getenv(RubyBasicObject name) {
+            final String nameString = RubyEncoding.decodeUTF8(StringNodes.getByteList(name).getUnsafeBytes(), StringNodes.getByteList(name).getBegin(), StringNodes.getByteList(name).getRealSize());
+
+            Object result = posix().getenv(nameString);
+
+            if (result == null) {
+                return nil();
+            }
+
+            return StringNodes.createString(getContext().getCoreLibrary().getStringClass(), (String) result);
+        }
+    }
+
     @CoreMethod(names = "geteuid", isModuleFunction = true)
     public abstract static class GetEUIDNode extends CoreMethodArrayArgumentsNode {
 
@@ -257,6 +293,20 @@ public RubyBasicObject memset(RubyBasicObject pointer, int c, long length) {
 
     }
 
+    @CoreMethod(names = "putenv", isModuleFunction = true, required = 1)
+    public abstract static class PutenvNode extends CoreMethodArrayArgumentsNode {
+
+        public PutenvNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @Specialization(guards = "isRubyString(nameValuePair)")
+        public int putenv(RubyBasicObject nameValuePair) {
+            throw new UnsupportedOperationException("Not yet implemented in jnr-posix");
+        }
+
+    }
+
     @CoreMethod(names = "readlink", isModuleFunction = true, required = 3)
     public abstract static class ReadlinkNode extends CoreMethodArrayArgumentsNode {
 
@@ -279,6 +329,23 @@ public int readlink(RubyString path, RubyBasicObject pointer, int bufsize) {
 
     }
 
+    @CoreMethod(names = "setenv", isModuleFunction = true, required = 3)
+    public abstract static class SetenvNode extends CoreMethodArrayArgumentsNode {
+
+        public SetenvNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @Specialization(guards = { "isRubyString(name)", "isRubyString(value)" })
+        public int setenv(RubyBasicObject name, RubyBasicObject value, int overwrite) {
+            final String nameString = RubyEncoding.decodeUTF8(StringNodes.getByteList(name).getUnsafeBytes(), StringNodes.getByteList(name).getBegin(), StringNodes.getByteList(name).getRealSize());
+            final String valueString = RubyEncoding.decodeUTF8(StringNodes.getByteList(value).getUnsafeBytes(), StringNodes.getByteList(value).getBegin(), StringNodes.getByteList(value).getRealSize());
+
+            return posix().setenv(nameString, valueString, overwrite);
+        }
+
+    }
+
     @CoreMethod(names = "link", isModuleFunction = true, required = 2)
     public abstract static class LinkNode extends CoreMethodArrayArgumentsNode {
 
@@ -323,6 +390,22 @@ public int umask(int mask) {
 
     }
 
+    @CoreMethod(names = "unsetenv", isModuleFunction = true, required = 1)
+    public abstract static class UnsetenvNode extends CoreMethodArrayArgumentsNode {
+
+        public UnsetenvNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @Specialization(guards = "isRubyString(name)")
+        public int unsetenv(RubyBasicObject name) {
+            final String nameString = RubyEncoding.decodeUTF8(StringNodes.getByteList(name).getUnsafeBytes(), StringNodes.getByteList(name).getBegin(), StringNodes.getByteList(name).getRealSize());
+
+            return posix().unsetenv(nameString);
+        }
+
+    }
+
     @CoreMethod(names = "utimes", isModuleFunction = true, required = 2)
     public abstract static class UtimesNode extends CoreMethodArrayArgumentsNode {