Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   ***** BEGIN LICENSE BLOCK *****
   * Version: CPL 1.0/GPL 2.0/LGPL 2.1
   *
   * The contents of this file are subject to the Common Public
   * License Version 1.0 (the "License"); you may not use this file
   * except in compliance with the License. You may obtain a copy of
   * the License at http://www.eclipse.org/legal/cpl-v10.html
   *
  * Software distributed under the License is distributed on an "AS
  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  * implied. See the License for the specific language governing
  * rights and limitations under the License.
  *
  * Copyright (C) 2004-2009 Thomas E Enebo <enebo@acm.org>
  *
  * Alternatively, the contents of this file may be used under the terms of
  * either of the GNU General Public License Version 2 or later (the "GPL"),
  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the CPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the CPL, the GPL or the LGPL.
  ***** END LICENSE BLOCK *****/
 package org.jruby.ext.tempfile;
 
 import java.io.File;
 import org.jruby.Ruby;
 
 import static org.jruby.runtime.Visibility.*;
An implementation of tempfile.rb in Java.
 
 @JRubyClass(name="Tempfile", parent="File")
 public class Tempfile extends org.jruby.RubyTempfile {

    
Keep strong references to the Reaper until cleanup
 
     private static final ConcurrentMap<ReaperBooleanreferenceSet
             = new ConcurrentHashMap<ReaperBoolean>();
     private transient volatile Reaper reaper;
 
     private static ObjectAllocator TEMPFILE_ALLOCATOR = new ObjectAllocator() {
         public IRubyObject allocate(Ruby runtimeRubyClass klass) {
             RubyFile instance = new Tempfile(runtimeklass);
 
             return instance;
         }
     };
 
     public static RubyClass createTempfileClass(Ruby runtime) {
         RubyClass tempfileClass = runtime.defineClass("Tempfile"runtime.getFile(), );
 
         RubyKernel.require(tempfileClassruntime.newString("tmpdir"), .);
 
         tempfileClass.defineAnnotatedMethods(Tempfile.class);
 
         return tempfileClass;
     }
 
     private final static String DEFAULT_TMP_DIR;
     private static final Object tmpFileLock = new Object();
     private static int counter = -1;
     private final static java.util.Random RND = new java.util.Random();
 
     static {
         String tmpDir;
         if (.) {
            tmpDir = System.getProperty("java.io.tmpdir");
            if (tmpDir == nulltmpDir = System.getenv("TEMP");
           if (tmpDir == nulltmpDir = System.getenv("TMP");
           if (tmpDir == nulltmpDir = "C:\\Windows\\Temp";
        } else {
            tmpDir = "/tmp";
        }
         = tmpDir;
    }
    private File tmpFile = null;
    // This should only be called by this and RubyFile.
    // It allows this object to be created without a IOHandler.
    public Tempfile(Ruby runtimeRubyClass type) {
        super(runtimetype);
    }
    @JRubyMethod(required = 1, optional = 1, visibility = , compat = .)
    @Override
    public IRubyObject initialize(IRubyObject[] argsBlock block) {
        Ruby runtime = getRuntime();
        IRubyObject basename = args[0];
        IRubyObject dir = defaultTmpDir(runtimeargs);
        File tmp = null;
        synchronized() {
            while (true) {
                try {
                    if ( == -1) {
                         = .nextInt() & 0xffff;
                    }
                    ++;
                    // We do this b/c make_tmpname might be overridden
                    IRubyObject tmpname = callMethod(runtime.getCurrentContext(),
                                                     "make_tmpname"new IRubyObject[] {basenameruntime.newFixnum()});
                    tmp = JRubyFile.create(getRuntime().getCurrentDirectory(),
                                           new File(dir.convertToString().toString(), tmpname.convertToString().toString()).getPath());
                    if (tmp.createNewFile()) {
                         = tmp;
                         = tmp.getPath();
                        try {
                            .deleteOnExit();
                        } catch (NullPointerException npe) {
                            // See JRUBY-4624.
                            // Due to JDK bug, NPE could be thrown
                            // when shutdown is in progress.
                            // Do nothing.
                        } catch (IllegalStateException ise) {
                            // do nothing, shutdown in progress
                        }
                        initializeOpen();
                        .put( = new Reaper(thisruntime), .);
                        return this;
                    }
                } catch (IOException e) {
                    throw runtime.newIOErrorFromException(e);
                }
            }
        }
    }
    @JRubyMethod(required = 1, optional = 2, visibility = , compat = .)
    @Override
    public IRubyObject initialize19(ThreadContext contextIRubyObject[] argsBlock block) {
        RubyHash options = null;
        // check for trailing hash
        if (args.length > 1) {
            if (args[args.length - 1] instanceof RubyHash) {
                options = (RubyHash)args[args.length - 1];
                args = Arrays.copyOfRange(args, 0, args.length - 1);
            }
        }
        initialize(argsblock);
        if (options != null) {
            EncodingOption encodingOption = EncodingOption.getEncodingOptionFromObject(options);
            if (encodingOption != null) {
                setEncodingFromOptions(encodingOption);
            }
        }
        return this;
    }
    private IRubyObject defaultTmpDir(Ruby runtimeIRubyObject[] args) {
        IRubyObject dir = null;
        if (args.length == 2) {
            dir = args[1];
        } else {
            // Dir::tmpdir
            runtime.getLoadService().require("tmpdir");
            dir = runtime.getDir().callMethod(runtime.getCurrentContext(), "tmpdir");
        }
        return dir;
    }
    private void initializeOpen() {
        Ruby runtime = getRuntime();
        IOOptions ioOptions = newIOOptions(runtime. | .);
        getRuntime().getPosix().chmod(, 0600);
        sysopenInternal(ioOptions.getModeFlags(), 0600);
    }

    
Compatibility with Tempfile#make_tmpname(basename, n) in MRI
    @JRubyMethod(visibility = )
    public IRubyObject make_tmpname(ThreadContext contextIRubyObject basenameIRubyObject nBlock block) {
        Ruby runtime = context.runtime;
        IRubyObject[] newargs = new IRubyObject[5];
        IRubyObject basesuffix;
        if (basename instanceof RubyArray) {
            RubyArray array = (RubyArraybasename;
            int length = array.getLength();
            base = length > 0 ? array.eltInternal(0) : runtime.getNil();
            suffix = length > 0 ? array.eltInternal(1) : runtime.getNil();
        } else {
            base = basename;
            suffix = runtime.newString("");
        }
        newargs[0] = runtime.newString("%s.%d.%d%s");
        newargs[1] = base;
        newargs[2] = runtime.getGlobalVariables().get("$$"); // PID
        newargs[3] = n;
        newargs[4] = suffix;
        return callMethod(context"sprintf"newargs);
    }
    @JRubyMethod(visibility = )
    public IRubyObject open() {
        if (!isClosed()) close();
        openInternal("r+");
        return this;
    }
    @JRubyMethod(visibility = )
    public IRubyObject _close(ThreadContext context) {
        return !isClosed() ? super.close() : context.runtime.getNil();
    }
    @JRubyMethod(optional = 1, visibility = )
    public IRubyObject close(ThreadContext contextIRubyObject[] argsBlock block) {
        boolean unlink = args.length == 1 ? args[0].isTrue() : false;
        return unlink ? close_bang(context) : _close(context);
    }
    @JRubyMethod(name = "close!", visibility = )
    public IRubyObject close_bang(ThreadContext context) {
         .remove();
         . = true;
        _close(context);
        .delete();
        return context.runtime.getNil();
    }
    @JRubyMethod(name = {"unlink""delete"})
    public IRubyObject unlink(ThreadContext context) {
        // JRUBY-6688: delete when closed, warn otherwise
        if (isClosed()) {
            // the user intends to delete the file immediately, so do it
            if (!.exists() || .delete()) {
                .remove();
                . = true;
                 = null;
            }
        } else {
            // else, no-op, since we can't unlink the file without breaking stat et al
            context.runtime.getWarnings().warn("Tempfile#unlink or delete called on open file; ignoring");
        }
        return context.runtime.getNil();
    }
    @JRubyMethod(name = {"size""length"})
    public IRubyObject size(ThreadContext context) {
        if (!isClosed()) {
            flush();
            return context.runtime.newFileStat(false).size();
        }
        return RubyFixnum.zero(context.runtime);
    }
    @JRubyMethod(required = 1, optional = 1, meta = true, compat = .)
    public static IRubyObject open(ThreadContext contextIRubyObject recvIRubyObject[] argsBlock block) {
        Ruby runtime = context.runtime;
        RubyClass klass = (RubyClassrecv;
        Tempfile tempfile = (Tempfileklass.newInstance(contextargsblock);
        if (block.isGiven()) {
            try {
                block.yield(contexttempfile);
            } finally {
                if (!tempfile.isClosed()) tempfile.close();
            }
            return runtime.getNil();
        }
        return tempfile;
    }
    @JRubyMethod(required = 1, optional = 1, meta = true, compat = .)
    public static IRubyObject open19(ThreadContext contextIRubyObject recvIRubyObject[] argsBlock block) {
        Ruby runtime = context.runtime;
        RubyClass klass = (RubyClassrecv;
        Tempfile tempfile = (Tempfileklass.newInstance(contextargsblock);
        if (block.isGiven()) {
            try {
                return block.yield(contexttempfile);
            } finally {
                if (!tempfile.isClosed()) tempfile.close();
            }
        } else {
            return tempfile;
        }
    }
    @Override
    public IRubyObject inspect() {
        StringBuilder val = new StringBuilder();
        val.append("#<Tempfile:").append();
        if(!.isOpen()) {
            val.append(" (closed)");
        }
        val.append(">");
        return getRuntime().newString(val.toString());
    }
    // FIXME This reaper never actually runs; delete it or implement it properly
    // For JRUBY-6477, I add the finalize above to do basically what this was
    // intended to do.
    private static final class Reaper extends PhantomReferenceReaper<Tempfileimplements Runnable {
        private volatile boolean released = false;
        private final Ruby runtime;
        private final File tmpFile;
        private final OpenFile openFile;
        Reaper(Tempfile fileRuby runtimeFile tmpFileOpenFile openFile) {
            super(file);
            this. = runtime;
            this. = tmpFile;
            this. = openFile;
        }
        public final void run() {
            .remove(this);
            release();
            clear();
        }
        final void release() {
            if (!) {
                 = true;
                if ( != null) {
                    .cleanup(false);
                }
                if (.exists()) {
                    boolean deleted = .delete();
                    if (.getDebug().isTrue()) {
                        String msg = "removing " + .getPath() + " ... ";
                        if (deleted) {
                            .getErr().println(msg + "done");
                        } else {
                            .getErr().println(msg + "can't delete");
                        }
                    }
                }
            }
        }
    }