WIP: Made temporary files deleted when closing the RqMultipart body.

Commit made for preliminary review.

src/main/java/org/takes/rq/RqMultipart.java

@@ -123,6 +123,10 @@ final class Base extends RqWrap implements RqMultipart {
          * Origin request body.
          */
         private final transient ReadableByteChannel body;
+        /**
+         * Request base temporary files.
+         */
+        private final transient Collection<File> files;
         /**
          * Ctor.
          * @param req Original request
@@ -132,11 +136,12 @@ final class Base extends RqWrap implements RqMultipart {
         public Base(final Request req) throws IOException {
             super(req);
             final InputStream stream = new RqLengthAware(req).body();
-            this.body = Channels.newChannel(stream);
             this.buffer = ByteBuffer.allocate(
                 // @checkstyle MagicNumberCheck (1 line)
                 Math.min(8192, stream.available())
             );
+            this.files = new LinkedList<File>();
+            this.body = new TempReadableByteChannel(Channels.newChannel(stream), files);
             this.map = this.buildRequests(req);
         }
         @Override
@@ -226,7 +231,7 @@ private ConcurrentMap<String, List<Request>> buildRequests(
         /**
          * Make a request.
          *  Scans the origin request until the boundary reached. Caches
-         *  the  content into a temporary file and returns it as a new request.
+         *  the content into a temporary file and returns it as a new request.
          * @param boundary Boundary
          * @return Request
          * @throws IOException If fails
@@ -235,7 +240,7 @@ private Request make(final byte[] boundary) throws IOException {
             final File file = File.createTempFile(
                 RqMultipart.class.getName(), ".tmp"
             );
-            file.deleteOnExit();
+            this.files.add(file);
             final FileChannel channel = new RandomAccessFile(
                 file,
                 "rw"

src/main/java/org/takes/rq/TempReadableByteChannel.java

@@ -0,0 +1,82 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Yegor Bugayenko
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package org.takes.rq;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.ReadableByteChannel;
+import java.util.Collection;
+
+/**
+ * ReadableByteChannel removing its temporary cache file when closing.
+ *
+ * <p>All implementations of this interface must be immutable and thread-safe.
+ *
+ * @author Yohann Ferreira (yohann.ferreira@orange.fr)
+ * @version $Id$
+ * @since 0.18
+ */
+final class TempReadableByteChannel implements ReadableByteChannel {
+
+    /**
+     * Original channel.
+     */
+    private final transient ReadableByteChannel origin;
+
+    /**
+     * Temporary files.
+     */
+    private final transient Collection<File> files;
+
+    /**
+     * Ctor.
+     * @param channel Original channel
+     * @param file Temporary file
+     */
+    TempReadableByteChannel(final ReadableByteChannel channel, Collection<File> files) {
+        super();
+        this.origin = channel;
+        this.files = files;
+    }
+
+    public int read(ByteBuffer dst) throws IOException {
+        return this.origin.read(dst);
+    }
+
+    public boolean isOpen() {
+        return this.origin.isOpen();
+    }
+
+    /**
+     * The close method also takes care to remove the temporary file.
+     */
+    @Override
+    public void close() throws IOException {
+        this.origin.close();
+        for (File file : files) {
+            file.delete();
+        }
+    }
+}