embulk-decoder-unzip 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7752a0d8a9deefa4462b42140a47b76de3d7f21
-  data.tar.gz: 936158b3cdbff5031e5263dc9a97cfe0ec90495f
+  metadata.gz: 102affbd723ee4a9398356eadbd7fca47b480ad5
+  data.tar.gz: 6cdc51537a8b63b225d99af80593e33c038e550c
 SHA512:
-  metadata.gz: 6d6a2dc184c041d52b38a1027ca4a619c803af4814cece3cdc7cfea1e564bd488780bce1588d0c5244b23e60a1fea265d2ea1119c3875600752993b7cceea5c2
-  data.tar.gz: 2c0ae19262466aff5c6f359648a60e5b9ecf55d93b161117912a970fdacc115815cf09d2eea9cbef83ccc8e148a5b5ed17dc934a73176c376b4fdb700986bf66
+  metadata.gz: 4df92adfe66b3aeec9ecd8bd4a422554f1992e127d7e7e17df057f21e5900c1397ba4b1bfd6e96e71b669ad3d4947c35636d961df04c3e06818a88034666d9ce
+  data.tar.gz: f832f84ee19656949144fd62b507da09d76a0d6f8b0f2f9af17ee2d52124b847e31065918a03588937e5a23153a902b4ed1620d3fb43a9293da3c0bbf99e92c8

data/README.md

@@ -1,38 +1,4 @@
-# Unzip decoder plugin for Embulk
+Original code is copied from https://github.com/hata/embulk-decoder-commons-compress
 
-TODO: Write short description here and build.gradle file.
-
-## Overview
-
-* **Plugin type**: decoder
-* **Guess supported**: no
-
-## Configuration
-
-- **option1**: description (integer, required)
-- **option2**: description (string, default: `"myvalue"`)
-- **option3**: description (string, default: `null`)
-
-## Example
-
-```yaml
-in:
-  type: any output input plugin type
-  decoders:
-    - type: unzip
-      option1: example1
-      option2: example2
-```
-
-(If guess supported) you don't have to write `decoder:` section in the configuration file. After writing `in:` section, you can let embulk guess `decoder:` section using this command:
-
-```
-$ embulk gem install embulk-decoder-unzip
-$ embulk guess -g unzip config.yml -o guessed.yml
-```
-
-## Build
-
-```
-$ ./gradlew gem  # -t to watch change of files and rebuild continuously
-```
+This is just an upgrade of common-compress from 1.13 to 1.20 It's a solution to the unzip error.
+The reason for this is to deal with unzip errors.

data/build.gradle

@@ -13,7 +13,7 @@ configurations {
     provided
 }
 
-version = "0.1.1"
+version = "0.1.2"
 
 sourceCompatibility = 1.8
 targetCompatibility = 1.8
@@ -21,6 +21,7 @@ targetCompatibility = 1.8
 dependencies {
     compile  "org.embulk:embulk-core:0.9.23"
     provided "org.embulk:embulk-core:0.9.23"
+    compile  "org.apache.commons:commons-compress:1.20"
     // compile "YOUR_JAR_DEPENDENCY_GROUP:YOUR_JAR_DEPENDENCY_MODULE:YOUR_JAR_DEPENDENCY_VERSION"
     testCompile "junit:junit:4.+"
 }

data/src/main/java/org/embulk/decoder/unzip/ArchiveInputStreamIterator.java

@@ -0,0 +1,87 @@
+package org.embulk.decoder.unzip;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Iterator;
+
+import org.apache.commons.compress.archivers.ArchiveEntry;
+import org.apache.commons.compress.archivers.ArchiveInputStream;
+
+class ArchiveInputStreamIterator implements Iterator<InputStream> {
+    private ArchiveInputStream ain;
+    private ArchiveEntry entry;
+    private String matchRegex = "";
+    private boolean endOfArchive = false;
+
+    ArchiveInputStreamIterator(ArchiveInputStream ain)
+    {
+        this.ain = ain;
+    }
+
+    ArchiveInputStreamIterator(ArchiveInputStream ain, String matchRegex) {
+        this.ain = ain;
+        this.matchRegex = matchRegex;
+    }
+
+    @Override
+    public boolean hasNext() {
+        try {
+            return checkNext();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public InputStream next() {
+        try {
+            if (checkNext()) {
+                entry = null;
+            } else {
+                return null;
+            }
+
+            return ain;
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public void remove() {
+        throw new UnsupportedOperationException();
+    }
+
+    private boolean checkNext() throws IOException {
+        if (endOfArchive) {
+            return false;
+        } else if (entry != null) {
+            return true;
+        }
+
+        while (true) {
+            entry = ain.getNextEntry();
+            if (entry == null) {
+                endOfArchive = true;
+                return false;
+            } else if (entry.isDirectory()) {
+                continue;
+            } else if (!matchName(entry, matchRegex)){
+                continue;
+            } else {
+                return true;
+            }
+        }
+    }
+
+    private boolean matchName(ArchiveEntry entry, String regex) {
+        String name = entry.getName();
+        if(regex == null || regex.equals("")){
+            return true;
+        } else if(name == null) {
+            return false;
+        } else {
+            return name.matches(regex);
+        }
+    }
+}

data/src/main/java/org/embulk/decoder/unzip/CommonsCompressFileInput.java

@@ -0,0 +1,73 @@
+package org.embulk.decoder.unzip;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.embulk.spi.Buffer;
+import org.embulk.spi.BufferAllocator;
+import org.embulk.spi.FileInput;
+import org.embulk.spi.util.InputStreamFileInput.Provider;
+
+
+class CommonsCompressFileInput implements FileInput
+{
+    private final BufferAllocator allocator;
+    private final Provider provider;
+    private InputStream current;
+
+    public CommonsCompressFileInput(BufferAllocator allocator, Provider provider)
+    {
+        this.allocator = allocator;
+        this.provider = provider;
+        this.current = null;
+    }
+
+    @Override
+    public Buffer poll()
+    {
+        if (current == null) {
+            throw new IllegalStateException("nextFile() must be called before poll()");
+        }
+        Buffer buffer = allocator.allocate();
+        try {
+            int n = current.read(buffer.array(), buffer.offset(), buffer.capacity());
+            if (n < 0) {
+                return null;
+            }
+            buffer.limit(n);
+            Buffer b = buffer;
+            buffer = null;
+            return b;
+        } catch (IOException ex) {
+            throw new RuntimeException(ex);
+        } finally {
+            if (buffer != null) {
+                buffer.release();
+                buffer = null;
+            }
+        }
+    }
+
+    @Override
+    public boolean nextFile()
+    {
+        try {
+            // NOTE: DO NOT close current because this stream may
+            // be one of a file in an archive. Provider manage it.
+            current = provider.openNext();
+            return current != null;
+        } catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    @Override
+    public void close()
+    {
+        try {
+            provider.close();
+        } catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+}

data/src/main/java/org/embulk/decoder/unzip/CommonsCompressProvider.java

@@ -0,0 +1,190 @@
+package org.embulk.decoder.unzip;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.commons.compress.archivers.ArchiveException;
+import org.apache.commons.compress.archivers.ArchiveInputStream;
+import org.apache.commons.compress.archivers.ArchiveStreamFactory;
+import org.apache.commons.compress.compressors.CompressorException;
+import org.apache.commons.compress.compressors.CompressorInputStream;
+import org.apache.commons.compress.compressors.CompressorStreamFactory;
+import org.embulk.decoder.unzip.UnzipDecoderPlugin.PluginTask;
+import org.embulk.spi.util.FileInputInputStream;
+import org.embulk.spi.util.InputStreamFileInput.Provider;
+
+class CommonsCompressProvider implements Provider {
+    private static final String AUTO_DETECT_FORMAT = "";
+
+    private final FileInputInputStream files;
+    private final boolean formatAutoDetection;
+    private Iterator<InputStream> inputStreamIterator;
+    private String[] formats;
+    private final boolean decompressConcatenated;
+    private final String matchName;
+
+    CommonsCompressProvider(PluginTask task, FileInputInputStream files) {
+        this.files = files;
+        this.formatAutoDetection = task == null
+                || CommonsCompressUtil.isAutoDetect(task.getFormat());
+        if (!this.formatAutoDetection) {
+            formats = CommonsCompressUtil.toFormats(task.getFormat());
+            if (formats == null) {
+                throw new RuntimeException("Failed to get a format.");
+            }
+        }
+        this.decompressConcatenated = task == null
+            || task.getDecompressConcatenated();
+        this.matchName = (task == null)? "" : task.getMatchName();
+    }
+
+    @Override
+    public InputStream openNext() throws IOException {
+        while (true) {
+            if (inputStreamIterator == null) {
+                if (!files.nextFile()) {
+                    return null;
+                }
+                inputStreamIterator = formatAutoDetection ? createInputStreamIterator(files)
+                        : createInputStreamIterator(formats, 0, files);
+            } else {
+                if (inputStreamIterator.hasNext()) {
+                    InputStream in = inputStreamIterator.next();
+                    if (in == null) {
+                        inputStreamIterator = null;
+                    } else {
+                        return in;
+                    }
+                } else {
+                    inputStreamIterator = null;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void close() throws IOException {
+        inputStreamIterator = null;
+        if (files != null) {
+            files.close();
+        }
+    }
+
+    boolean isFormatAutoDetection() {
+        return formatAutoDetection;
+    }
+    
+    String[] getFormats() {
+        return formats;
+    }
+
+    Iterator<InputStream> createInputStreamIterator(InputStream in)
+            throws IOException {
+        // It is required to support mark to detect a file format.
+        in = in.markSupported() ? in : new BufferedInputStream(in);
+        try {
+            return new ArchiveInputStreamIterator(
+                    createArchiveInputStream(AUTO_DETECT_FORMAT, in),
+                    this.matchName
+            );
+        } catch (IOException | ArchiveException e) {
+            // ArchiveStreamFactory set mark and reset the stream.
+            // So, we can use the same stream to check compressor.
+            try {
+                return toIterator(createCompressorInputStream(AUTO_DETECT_FORMAT, in));
+            } catch (CompressorException e2) {
+                throw new IOException("Failed to detect a file format.", e2);
+            }
+        }
+    }
+
+    /**
+     * Create iterator to list InputStream for each archived/compressed file.
+     * 
+     * This can handle like the following formats:
+     * 1 archived format which defined in ArchiveStreamFactory(e.g. tar)
+     * 1 archived format and 1 compressor format defined in CompressorStreamFactory.(e.g. tar.bz2)
+     * 1 compressor format defined in CompressorStreamFactory.(e.g. bz2)
+     * (Actually, compressor formats can use two or more times in this code.
+     *  But it is not common case.)
+     */
+    Iterator<InputStream> createInputStreamIterator(String[] inputFormats,
+            int pos, InputStream in) throws IOException {
+        if (pos >= inputFormats.length) {
+            return toIterator(in);
+        }
+
+        try {
+            String format = inputFormats[pos];
+            if (CommonsCompressUtil.isArchiveFormat(format)) {
+                return new ArchiveInputStreamIterator(
+                        createArchiveInputStream(format, in));
+            } else if (CommonsCompressUtil.isCompressorFormat(format)) {
+                return createInputStreamIterator(inputFormats, pos + 1,
+                        createCompressorInputStream(format, in));
+            }
+            throw new IOException("Unsupported format is configured. format:"
+                    + format);
+        } catch (ArchiveException | CompressorException e) {
+            throw new IOException(e);
+        }
+    }
+
+    /**
+     * Create a new ArchiveInputStream to read an archive file based on a format
+     * parameter.
+     * 
+     * If format is not set, this method tries to detect file format
+     * automatically. In this case, BufferedInputStream is used to wrap
+     * FileInputInputStream instance. BufferedInputStream may read a data
+     * partially when calling files.nextFile(). However, it doesn't matter
+     * because the partial read data should be discarded. And then this method
+     * is called again to create a new ArchiveInputStream.
+     * 
+     * @return a new ArchiveInputStream instance.
+     */
+    ArchiveInputStream createArchiveInputStream(String format, InputStream in)
+            throws IOException, ArchiveException {
+        ArchiveStreamFactory factory = new ArchiveStreamFactory();
+        if (CommonsCompressUtil.isAutoDetect(format)) {
+            in = in.markSupported() ? in : new BufferedInputStream(in);
+            try {
+                return factory.createArchiveInputStream(in);
+            } catch (ArchiveException e) {
+                throw new IOException(
+                        "Failed to detect a file format. Please try to set a format explicitly.",
+                        e);
+            }
+        } else {
+            return factory.createArchiveInputStream(format, in);
+        }
+    }
+
+    CompressorInputStream createCompressorInputStream(String format,
+            InputStream in) throws IOException, CompressorException {
+        CompressorStreamFactory factory = new CompressorStreamFactory();
+        factory.setDecompressConcatenated(decompressConcatenated);
+        if (CommonsCompressUtil.isAutoDetect(format)) {
+            in = in.markSupported() ? in : new BufferedInputStream(in);
+            try {
+                return factory.createCompressorInputStream(in);
+            } catch (CompressorException e) {
+                throw new IOException(
+                        "Failed to detect a file format. Please try to set a format explicitly.",
+                        e);
+            }
+        } else {
+            return factory.createCompressorInputStream(format, in);
+        }
+    }
+
+    private Iterator<InputStream> toIterator(InputStream in) {
+        List<InputStream> list = new ArrayList<InputStream>(1);
+        list.add(in);
+        return list.iterator();
+    }
+}

data/src/main/java/org/embulk/decoder/unzip/CommonsCompressUtil.java

@@ -0,0 +1,155 @@
+package org.embulk.decoder.unzip;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.commons.compress.archivers.ArchiveStreamFactory;
+import org.apache.commons.compress.compressors.CompressorStreamFactory;
+
+class CommonsCompressUtil {
+    // TODO: It may be better to check performance between Set and array.
+    // NOTE: Some file types may not work in an environment because some required
+    // libraries are not found.
+    static final String[] archiveFormats = {
+        ArchiveStreamFactory.AR,
+        ArchiveStreamFactory.ARJ,
+        ArchiveStreamFactory.CPIO,
+        ArchiveStreamFactory.DUMP,
+        ArchiveStreamFactory.JAR,
+        ArchiveStreamFactory.SEVEN_Z,
+        ArchiveStreamFactory.TAR,
+        ArchiveStreamFactory.ZIP,
+    };
+
+    // Even indexes have both extensions and aliases. And odd indexes are
+    // CompressorStreamFactory values.
+    static final String[] compressorFormats = {
+        CompressorStreamFactory.BZIP2,
+        CompressorStreamFactory.DEFLATE,
+        CompressorStreamFactory.GZIP,
+        CompressorStreamFactory.LZMA,
+        CompressorStreamFactory.PACK200,
+        CompressorStreamFactory.SNAPPY_FRAMED,
+        CompressorStreamFactory.SNAPPY_RAW,
+        CompressorStreamFactory.XZ,
+        CompressorStreamFactory.Z,
+        "bz2", // These values should be handled by normalizeFormats
+        "gzip",
+    };
+
+    // This table is even indexes have short extensions and odd indexes has
+    // split formats for each short extensions.
+    private static final String[] solidCompressionFormats = {
+        "tgz",      ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.GZIP,
+        "tar.gz",   ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.GZIP,
+        "tbz",      ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.BZIP2,
+        "tbz2",     ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.BZIP2,
+        "tb2",      ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.BZIP2,
+        "tar.bz2",  ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.BZIP2,
+        "taz",      ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.Z,
+        "tz",       ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.Z,
+        "tar.Z",    ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.Z,
+        "tlz",      ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.LZMA,
+        "tar.lz",   ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.LZMA,
+        "tar.lzma", ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.LZMA,
+        "txz",      ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.XZ,
+        "tar.xz",   ArchiveStreamFactory.TAR + " " + CompressorStreamFactory.XZ
+    };
+
+    static boolean isArchiveFormat(String format) {
+        for (String fmt : archiveFormats) {
+            if (fmt.equalsIgnoreCase(format)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static boolean isCompressorFormat(String format) {
+        for (String fmt : compressorFormats) {
+            if (fmt.equalsIgnoreCase(format)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static boolean isAutoDetect(String format) {
+        return format == null || format.length() == 0;
+    }
+
+    /**
+     * Split solid compresson formats and reorder to decode the formats
+     * based on this order.
+     * 
+     * If format is a single format like "tar", then return
+     * new String[]{"tar"}.
+     * If format is a solid compresson format like "tgz", then return
+     * new String[]{"gzip", "tar"}.
+     * If format is "tar bzip2", then return
+     * new String[]{"bzip2", "tar"}.
+     * 
+     * @param format contains a file format or some file formats.
+     * @return a single format or multi format values.
+     * Otherwise, returns null.
+     */
+    static String[] toFormats(String format) {
+        if (isAutoDetect(format)) {
+            return null;
+        } else if (isArchiveFormat(format) || isCompressorFormat(format)) {
+            return normalizeFormats(splitAndReverse(format));
+        }
+
+        String[] formats = toSolidCompressionFormats(format);
+        if (formats != null) {
+            return formats;
+        }
+
+        formats = normalizeFormats(splitAndReverse(format));
+        
+        for (String s : formats) {
+            if (!(isArchiveFormat(s) || isCompressorFormat(s))) {
+                return null;
+            }
+        }
+        
+        return formats;
+    }
+
+    private static String[] toSolidCompressionFormats(String format) {
+        for (int i = 0;i < solidCompressionFormats.length; i+= 2) {
+            if (solidCompressionFormats[i].equalsIgnoreCase(format)) {
+                return splitAndReverse(solidCompressionFormats[i + 1]);
+            }
+        }
+        return null;
+    }
+
+    private static String[] splitAndReverse(String format) {
+        List<String> result = new ArrayList<>();
+        for (String s : format.split(" ")) {
+            if (s.length() > 0) {
+                result.add(s);
+            }
+        }
+        Collections.reverse(result);
+        return result.toArray(new String[result.size()]);
+    }
+
+    private static String[] normalizeFormats(String... formats) {
+        if (formats == null || formats.length == 0) {
+            return formats;
+        }
+
+        for (int i = 0;i < formats.length;i++) {
+            if (formats[i].equalsIgnoreCase("gzip")) {
+                formats[i] = CompressorStreamFactory.GZIP;
+            } else if (formats[i].equalsIgnoreCase("bz2")) {
+                formats[i] = CompressorStreamFactory.BZIP2;
+            }
+        }
+
+        return formats;
+    }
+}

data/src/main/java/org/embulk/decoder/unzip/UnzipDecoderPlugin.java

@@ -1,8 +1,5 @@
 package org.embulk.decoder.unzip;
 
-import java.io.InputStream;
-import java.io.IOException;
-
 import org.embulk.config.Config;
 import org.embulk.config.ConfigDefault;
 import org.embulk.config.ConfigInject;
@@ -13,7 +10,6 @@ import org.embulk.spi.BufferAllocator;
 import org.embulk.spi.DecoderPlugin;
 import org.embulk.spi.FileInput;
 import org.embulk.spi.util.FileInputInputStream;
-import org.embulk.spi.util.InputStreamFileInput;
 
 public class UnzipDecoderPlugin
         implements DecoderPlugin
@@ -21,6 +17,18 @@ public class UnzipDecoderPlugin
     public interface PluginTask
             extends Task
     {
+        @Config("format")
+        @ConfigDefault("\"\"")
+        public String getFormat();
+
+        @Config("decompress_concatenated")
+        @ConfigDefault("true")
+        public boolean getDecompressConcatenated();
+
+        @Config("match_name")
+        @ConfigDefault("\"\"")
+        public String getMatchName();
+
 //        @Config("skip_on_error")
 //        @ConfigDefault("true")
 //        public boolean skipOnError();
@@ -40,40 +48,13 @@ public class UnzipDecoderPlugin
     @Override
     public FileInput open(TaskSource taskSource, FileInput fileInput)
     {
+    	String zipFileName = fileInput.hintOfCurrentInputFileNameForLogging().get();
+    	System.out.println(zipFileName);
         final PluginTask task = taskSource.loadTask(PluginTask.class);
 
         final FileInputInputStream files = new FileInputInputStream(fileInput);
-
-        InputStreamFileInput isfi = null;
-        try {
-	        isfi = new InputStreamFileInput(
-	                task.getBufferAllocator(),
-	                new InputStreamFileInput.Provider() {
-	                    public InputStream openNext() throws IOException
-	                    {
-	                        if (!files.nextFile()) {
-	                            return null;
-	                        }
-	                        return newDecoderInputStream(task, files);
-	                    }
-	        
-	                    public void close() throws IOException
-	                    {
-	                        files.close();
-	                    }
-	                });
-        } catch (Exception e) {
-//        	if(task.skipOnError()) {
-//        		System.out.println("skip: " + isfi.hintOfCurrentInputFileNameForLogging());
-//        		return null;
-//        	} else
-       		throw new RuntimeException(e);
-        }
-        return isfi;
+        return new CommonsCompressFileInput(task.getBufferAllocator(),
+                new CommonsCompressProvider(task, files));
     }
 
-    private static InputStream newDecoderInputStream(PluginTask task, InputStream file) throws IOException
-    {
-        return new UnzipInputStream(file);
-    }
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: embulk-decoder-unzip
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - fundoshi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-07 00:00:00.000000000 Z
+date: 2020-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -49,7 +49,8 @@ files:
 - LICENSE.txt
 - README.md
 - build.gradle
-- classpath/embulk-decoder-unzip-0.1.1.jar
+- classpath/commons-compress-1.20.jar
+- classpath/embulk-decoder-unzip-0.1.2.jar
 - config/checkstyle/checkstyle.xml
 - config/checkstyle/default.xml
 - gradle/wrapper/gradle-wrapper.jar
@@ -58,12 +59,16 @@ files:
 - gradlew.bat
 - lib/embulk/decoder/unzip.rb
 - lib/embulk/guess/unzip.rb
+- src/main/java/org/embulk/decoder/unzip/ArchiveInputStreamIterator.java
+- src/main/java/org/embulk/decoder/unzip/CommonsCompressFileInput.java
+- src/main/java/org/embulk/decoder/unzip/CommonsCompressProvider.java
+- src/main/java/org/embulk/decoder/unzip/CommonsCompressUtil.java
 - src/main/java/org/embulk/decoder/unzip/UnzipDecoderPlugin.java
-- src/main/java/org/embulk/decoder/unzip/UnzipInputStream.java
 - src/main/resources/config.yml
 - src/main/resources/sample.csv
 - src/main/resources/test1.zip
 - src/main/resources/test2.zip
+- src/main/resources/test3.zip
 - src/test/java/org/embulk/decoder/unzip/TestUnzipDecoderPlugin.java
 homepage:
 licenses:

data/src/main/java/org/embulk/decoder/unzip/UnzipInputStream.java

@@ -1,29 +0,0 @@
-package org.embulk.decoder.unzip;
-
-import java.io.BufferedInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipInputStream;
-
-public class UnzipInputStream extends InputStream {
-
-	private ZipInputStream zis;
-	
-	public UnzipInputStream(InputStream is) {
-		zis = new ZipInputStream(new BufferedInputStream(is), StandardCharsets.UTF_8);
-	}
-
-	@Override
-	public int read() throws IOException {
-
-		ZipEntry zipentry = zis.getNextEntry();
-		int v = -1;
-		if(zipentry != null)
-       		v = zis.read();
-		return v;
-
-	}
-
-}