jruby · Apr 17, 2015 · Apr 17, 2015 · Apr 17, 2015 · Apr 17, 2015
diff --git a/truffle/src/main/java/org/jruby/truffle/TruffleBridgeImpl.java b/truffle/src/main/java/org/jruby/truffle/TruffleBridgeImpl.java
@@ -69,7 +69,6 @@ public void init() {
         CoreMethodNodeManager.addCoreMethodNodes(rubyObjectClass, BindingNodesFactory.getFactories());
         CoreMethodNodeManager.addCoreMethodNodes(rubyObjectClass, BignumNodesFactory.getFactories());
         CoreMethodNodeManager.addCoreMethodNodes(rubyObjectClass, ClassNodesFactory.getFactories());
-        CoreMethodNodeManager.addCoreMethodNodes(rubyObjectClass, DirNodesFactory.getFactories());
         CoreMethodNodeManager.addCoreMethodNodes(rubyObjectClass, ExceptionNodesFactory.getFactories());
         CoreMethodNodeManager.addCoreMethodNodes(rubyObjectClass, FalseClassNodesFactory.getFactories());
         CoreMethodNodeManager.addCoreMethodNodes(rubyObjectClass, FiberNodesFactory.getFactories());

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/DirNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/DirNodes.java
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
@@ -25,6 +25,8 @@
 import org.jruby.util.unsafe.UnsafeHolder;
 import sun.misc.Unsafe;
 
+import java.nio.charset.StandardCharsets;
+
 @CoreClass(name = "Rubinius::FFI::Platform::POSIX")
 public abstract class PosixNodes {
 
@@ -187,4 +189,70 @@ public int mkdir(RubyString path, int mode) {
 
     }
 
+    @CoreMethod(names = "chdir", isModuleFunction = true, required = 1)
+    public abstract static class ChdirNode extends PointerPrimitiveNodes.ReadAddressPrimitiveNode {
+
+        public ChdirNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public ChdirNode(ChdirNode prev) {
+            super(prev);
+        }
+
+        @Specialization
+        public int chdir(RubyString path) {
+            final String pathString = path.toString();
+
+            final int result = getContext().getRuntime().getPosix().chdir(pathString);
+
+            if (result == 0) {
+                getContext().getRuntime().setCurrentDirectory(pathString);
+            }
+
+            return result;
+        }
+
+    }
+
+    @CoreMethod(names = "rmdir", isModuleFunction = true, required = 1)
+    public abstract static class RmdirNode extends PointerPrimitiveNodes.ReadAddressPrimitiveNode {
+
+        public RmdirNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public RmdirNode(RmdirNode prev) {
+            super(prev);
+        }
+
+        @Specialization
+        public int rmdir(RubyString path) {
+            return getContext().getRuntime().getPosix().rmdir(path.toString());
+        }
+
+    }
+
+    @CoreMethod(names = "getcwd", isModuleFunction = true, required = 2)
+    public abstract static class GetcwdNode extends PointerPrimitiveNodes.ReadAddressPrimitiveNode {
+
+        public GetcwdNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public GetcwdNode(GetcwdNode prev) {
+            super(prev);
+        }
+
+        @Specialization
+        public RubyString getcwd(RubyString resultPath, int maxSize) {
+            // We just ignore maxSize - I think this is ok
+
+            final String path = getContext().getRuntime().getCurrentDirectory();
+            resultPath.getByteList().replace(path.getBytes(StandardCharsets.UTF_8));
+            return resultPath;
+        }
+
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/StringPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/StringPrimitiveNodes.java
@@ -1115,6 +1115,18 @@ public StringPatternPrimitiveNode(StringPatternPrimitiveNode prev) {
             super(prev);
         }
 
+        @Specialization(guards = "isZero(arguments[1]))")
+        public RubyString stringPatternZero(RubyClass stringClass, int size, int value) {
+            return new RubyString(stringClass, new ByteList(new byte[size]));
+        }
+
+        @Specialization(guards = "!isZero(arguments[1]))")
+        public RubyString stringPattern(RubyClass stringClass, int size, int value) {
+            final byte[] bytes = new byte[size];
+            Arrays.fill(bytes, (byte) value);
+            return new RubyString(stringClass, new ByteList(bytes));
+        }
+
         @Specialization
         public RubyString stringPattern(RubyClass stringClass, int size, RubyString string) {
             final byte[] bytes = new byte[size];
@@ -1129,6 +1141,10 @@ public RubyString stringPattern(RubyClass stringClass, int size, RubyString stri
             return new RubyString(stringClass, new ByteList(bytes));
         }
 
+        protected boolean isZero(int value) {
+            return value == 0;
+        }
+
     }
 
     @RubiniusPrimitive(name = "string_to_inum")

diff --git a/truffle/src/main/ruby/core/rubinius/api/shims/rubinius.rb b/truffle/src/main/ruby/core/rubinius/api/shims/rubinius.rb
@@ -42,6 +42,9 @@ class DynamicLibrary
     end
   end
 
+  # jnr-posix hard codes this value
+  PATH_MAX = 1024
+
 end
 
 class PrimitiveFailure < StandardError

diff --git a/truffle/src/main/ruby/core/rubinius/common/dir.rb b/truffle/src/main/ruby/core/rubinius/common/dir.rb
@@ -28,6 +28,10 @@
 
 class Dir
 
+  # This seems silly, I know. But we do this to make Dir more resistent to people
+  # screwing with ::File later (ie, fakefs)
+  PrivateFile = ::File
+
   FFI = Rubinius::FFI
 
   def self.[](*patterns)
@@ -90,4 +94,54 @@ def self.mkdir(path, mode = 0777)
     error
   end
 
+  def self.chdir(path = ENV['HOME'])
+    path = Rubinius::Type.coerce_to_path path
+
+    if block_given?
+      original_path = self.getwd
+      error = FFI::Platform::POSIX.chdir path
+      Errno.handle(path) if error != 0
+
+      begin
+        value = yield path
+      ensure
+        error = FFI::Platform::POSIX.chdir original_path
+        Errno.handle(original_path) if error != 0
+      end
+
+      return value
+    else
+      error = FFI::Platform::POSIX.chdir path
+      Errno.handle path if error != 0
+      error
+    end
+  end
+
+  def self.rmdir(path)
+    error = FFI::Platform::POSIX.rmdir(Rubinius::Type.coerce_to_path(path))
+    Errno.handle path if error != 0
+    error
+  end
+
+  def self.getwd
+    buf = String.pattern Rubinius::PATH_MAX, 0
+    wd = FFI::Platform::POSIX.getcwd(buf, buf.length)
+    Errno.handle unless wd
+    Rubinius::Type.external_string wd
+  end
+
+  class << self
+    alias_method :pwd, :getwd
+    alias_method :delete, :rmdir
+    alias_method :unlink, :rmdir
+  end
+
+  def self.exist?(path)
+    PrivateFile.directory?(path)
+  end
+
+  class << self
+    alias_method :exists?, :exist?
+  end
+
 end