iostreams 1.10.3 → 2.0.0

data/test/builder_test.rb

@@ -1,311 +0,0 @@
-require_relative "test_helper"
-
-class BuilderTest < Minitest::Test
-  describe IOStreams::Builder do
-    let(:file_name) { "my/path/abc.bcd.xlsx.zip.gz.pgp" }
-    let(:streams) { IOStreams::Builder.new(file_name) }
-
-    describe "#option" do
-      it "adds one option" do
-        streams.option(:pgp, passphrase: "unlock-me")
-        assert_equal({pgp: {passphrase: "unlock-me"}}, streams.options)
-      end
-
-      it "adds options in order" do
-        streams.option(:pgp, passphrase: "unlock-me")
-        streams.option(:enc, compress: false)
-        assert_equal({pgp: {passphrase: "unlock-me"}, enc: {compress: false}}, streams.options)
-      end
-
-      it "will not add an option if a stream was already set" do
-        streams.stream(:pgp, passphrase: "unlock-me")
-        assert_raises ArgumentError do
-          streams.option(:pgp, passphrase: "unlock-me")
-        end
-      end
-
-      it "will not add an invalid option" do
-        assert_raises ArgumentError do
-          streams.option(:blah, value: 23)
-        end
-      end
-
-      describe "with no file_name" do
-        let(:file_name) { nil }
-
-        it "prevents options being set" do
-          assert_raises ArgumentError do
-            streams.option(:pgp, passphrase: "unlock-me")
-          end
-        end
-      end
-    end
-
-    describe "#format" do
-      it "detects the format from the file name" do
-        streams = IOStreams::Builder.new("abc.json")
-        assert_equal :json, streams.format
-      end
-
-      it "is nil if the file name has no meaningful format" do
-        assert_nil streams.format
-      end
-
-      it "returns set format with no file_name" do
-        streams        = IOStreams::Builder.new
-        streams.format = :csv
-        assert_equal :csv, streams.format
-      end
-
-      it "returns set format with file_name" do
-        streams        = IOStreams::Builder.new("abc.json")
-        streams.format = :csv
-        assert_equal :csv, streams.format
-      end
-
-      it "validates bad format" do
-        assert_raises ArgumentError do
-          streams.format = :blah
-        end
-      end
-    end
-
-    describe "#stream" do
-      it "adds one stream" do
-        streams.stream(:pgp, passphrase: "unlock-me")
-        assert_equal({pgp: {passphrase: "unlock-me"}}, streams.streams)
-      end
-
-      it "adds streams in order" do
-        streams.stream(:pgp, passphrase: "unlock-me")
-        streams.stream(:enc, compress: false)
-        assert_equal({pgp: {passphrase: "unlock-me"}, enc: {compress: false}}, streams.streams)
-      end
-
-      it "will not add a stream if an option was already set" do
-        streams.option(:pgp, passphrase: "unlock-me")
-        assert_raises ArgumentError do
-          streams.stream(:pgp, passphrase: "unlock-me")
-        end
-      end
-
-      it "will not add an invalid stream" do
-        assert_raises ArgumentError do
-          streams.stream(:blah, value: 23)
-        end
-      end
-    end
-
-    describe "#reader" do
-      let :gzip_string do
-        io_string = StringIO.new("".b)
-        IOStreams::Gzip::Writer.stream(io_string) do |io|
-          io.write("Hello World")
-        end
-        io_string.string
-      end
-
-      it "directly calls block for an empty stream" do
-        string_io = StringIO.new
-        value     = nil
-        streams.stream(:none)
-        streams.reader(string_io) do |io|
-          assert_equal io, string_io
-          value = 32
-        end
-        assert_equal 32, value
-      end
-
-      it "returns the reader" do
-        string_io = StringIO.new(gzip_string)
-        streams.stream(:gz)
-        streams.reader(string_io) do |io|
-          assert io.is_a?(::Zlib::GzipReader), io
-        end
-      end
-
-      it "returns the last reader" do
-        string_io = StringIO.new(gzip_string)
-        streams.stream(:encode)
-        streams.stream(:gz)
-        streams.reader(string_io) do |io|
-          assert io.is_a?(IOStreams::Encode::Reader), io
-        end
-      end
-    end
-
-    describe "#writer" do
-      it "directly calls block for an empty stream" do
-        string_io = StringIO.new
-        value     = nil
-        streams.stream(:none)
-        streams.writer(string_io) do |io|
-          assert_equal io, string_io
-          value = 32
-        end
-        assert_equal 32, value
-      end
-
-      it "returns the reader" do
-        string_io = StringIO.new
-        streams.stream(:zip)
-        streams.writer(string_io) do |io|
-          assert io.is_a?(ZipTricks::Streamer::Writable), io
-        end
-      end
-
-      it "returns the last reader" do
-        string_io = StringIO.new
-        streams.stream(:encode)
-        streams.stream(:zip)
-        streams.writer(string_io) do |io|
-          assert io.is_a?(IOStreams::Encode::Writer), io
-        end
-      end
-    end
-
-    # Internal methods
-
-    describe "#class_for_stream" do
-      it "xlsx" do
-        assert_equal IOStreams::Xlsx::Reader, streams.send(:class_for_stream, :reader, :xlsx)
-      end
-
-      it "gzip" do
-        assert_equal IOStreams::Gzip::Writer, streams.send(:class_for_stream, :writer, :gzip)
-      end
-
-      it "unknown" do
-        assert_raises ArgumentError do
-          streams.send(:class_for_stream, :reader, :unknown)
-        end
-      end
-    end
-
-    describe "#parse_extensions" do
-      it "single stream" do
-        streams = IOStreams::Builder.new("my/path/abc.xlsx")
-        assert_equal %i[xlsx], streams.send(:parse_extensions)
-      end
-
-      it "empty" do
-        streams = IOStreams::Builder.new("my/path/abc.csv")
-        assert_equal [], streams.send(:parse_extensions)
-      end
-
-      it "handles multiple extensions" do
-        assert_equal %i[xlsx zip gz pgp], streams.send(:parse_extensions)
-      end
-
-      describe "case-insensitive" do
-        let(:file_name) { "a.XlsX.GzIp" }
-
-        it "is case-insensitive" do
-          assert_equal %i[xlsx gzip], streams.send(:parse_extensions)
-        end
-      end
-    end
-
-    describe "#pipeline" do
-      it "with stream and file name" do
-        expected = {enc: {compress: false}}
-        streams.stream(:enc, compress: false)
-        assert_equal expected, streams.pipeline
-      end
-
-      it "no file name, streams, or options" do
-        expected = {}
-        streams  = IOStreams::Builder.new
-        assert_equal expected, streams.pipeline
-      end
-
-      it "file name without options" do
-        expected = {xlsx: {}, zip: {}, gz: {}, pgp: {}}
-        assert_equal expected, streams.pipeline
-      end
-
-      it "file name with encode option" do
-        expected = {encode: {encoding: "BINARY"}, xlsx: {}, zip: {}, gz: {}, pgp: {}}
-        streams.option(:encode, encoding: "BINARY")
-        assert_equal expected, streams.pipeline
-      end
-
-      it "file name with option" do
-        expected = {xlsx: {}, zip: {}, gz: {}, pgp: {passphrase: "unlock-me"}}
-        streams.option(:pgp, passphrase: "unlock-me")
-        assert_equal expected, streams.pipeline
-      end
-    end
-
-    describe "#remove_from_pipeline" do
-      let(:file_name) { "my/path/abc.bz2.pgp" }
-      it "removes a named stream from the pipeline" do
-        assert_equal({bz2: {}, pgp: {}}, streams.pipeline)
-        streams.remove_from_pipeline(:bz2)
-        assert_equal({pgp: {}}, streams.pipeline)
-      end
-      it "removes a named stream from the pipeline with options" do
-        streams.option(:pgp, passphrase: "unlock-me")
-        assert_equal({bz2: {}, pgp: {passphrase: "unlock-me"}}, streams.pipeline)
-        streams.remove_from_pipeline(:bz2)
-        assert_equal({pgp: {passphrase: "unlock-me"}}, streams.pipeline)
-      end
-    end
-
-    describe "#execute" do
-      it "directly calls block for an empty stream" do
-        string_io = StringIO.new
-        value     = nil
-        streams.send(:execute, :writer, {}, string_io) do |io|
-          assert_equal io, string_io
-          value = 32
-        end
-        assert_equal 32, value
-      end
-
-      it "calls last block in one element stream" do
-        pipeline  = {simple: {arg: "first"}}
-        string_io = StringIO.new
-        streams.send(:execute, :writer, pipeline, string_io) { |io| io.write("last") }
-        assert_equal "first>last", string_io.string
-      end
-
-      it "chains blocks in 2 element stream" do
-        pipeline  = {simple: {arg: "first"}, simple2: {arg: "second"}}
-        string_io = StringIO.new
-        streams.send(:execute, :writer, pipeline, string_io) { |io| io.write("last") }
-        assert_equal "second>first>last", string_io.string
-      end
-
-      it "chains blocks in 3 element stream" do
-        pipeline  = {simple: {arg: "first"}, simple2: {arg: "second"}, simple3: {arg: "third"}}
-        string_io = StringIO.new
-        streams.send(:execute, :writer, pipeline, string_io) { |io| io.write("last") }
-        assert_equal "third>second>first>last", string_io.string
-      end
-    end
-
-    class SimpleStream
-      def self.stream(io, **args)
-        yield new(io, **args)
-      end
-
-      def self.open(file_name_or_io, **args, &block)
-        file_name_or_io.is_a?(String) ? file(file_name_or_io, **args, &block) : stream(file_name_or_io, **args, &block)
-      end
-
-      def initialize(io, arg:)
-        @io  = io
-        @arg = arg
-      end
-
-      def write(data)
-        @io.write("#{@arg}>#{data}")
-      end
-    end
-
-    IOStreams.register_extension(:simple, nil, SimpleStream)
-    IOStreams.register_extension(:simple2, nil, SimpleStream)
-    IOStreams.register_extension(:simple3, nil, SimpleStream)
-  end
-end

data/test/bzip2_reader_test.rb

@@ -1,27 +0,0 @@
-require_relative "test_helper"
-
-class Bzip2ReaderTest < Minitest::Test
-  describe IOStreams::Bzip2::Reader do
-    let :file_name do
-      File.join(File.dirname(__FILE__), "files", "text.txt.bz2")
-    end
-
-    let :decompressed do
-      File.read(File.join(File.dirname(__FILE__), "files", "text.txt"))
-    end
-
-    describe ".file" do
-      it "file" do
-        result = IOStreams::Bzip2::Reader.file(file_name, &:read)
-        assert_equal decompressed, result
-      end
-
-      it "stream" do
-        result = File.open(file_name) do |file|
-          IOStreams::Bzip2::Reader.stream(file, &:read)
-        end
-        assert_equal decompressed, result
-      end
-    end
-  end
-end

data/test/bzip2_writer_test.rb

@@ -1,56 +0,0 @@
-require_relative "test_helper"
-
-class Bzip2WriterTest < Minitest::Test
-  describe IOStreams::Bzip2::Writer do
-    let :temp_file do
-      Tempfile.new("iostreams")
-    end
-
-    let :file_name do
-      temp_file.path
-    end
-
-    let :decompressed do
-      File.read(File.join(File.dirname(__FILE__), "files", "text.txt"))
-    end
-
-    after do
-      temp_file.delete
-    end
-
-    describe ".file" do
-      it "file" do
-        result =
-          IOStreams::Bzip2::Writer.file(file_name) do |io|
-            io.write(decompressed)
-            io.write(decompressed)
-            53534
-          end
-        assert_equal 53534, result
-
-        File.open(file_name, "rb") do |file|
-          io     = ::Bzip2::FFI::Reader.new(file)
-          result = io.read
-          temp_file.delete
-          assert_equal decompressed + decompressed, result
-        end
-      end
-
-      it "stream" do
-        io_string = StringIO.new("".b)
-        result    =
-          IOStreams::Bzip2::Writer.stream(io_string) do |io|
-            io.write(decompressed)
-            io.write(decompressed)
-            53534
-          end
-        assert_equal 53534, result
-
-        io     = StringIO.new(io_string.string)
-        rbzip2 = ::Bzip2::FFI::Reader.new(io)
-        data   = rbzip2.read
-        assert_equal decompressed + decompressed, data
-      end
-    end
-  end
-end

data/test/deprecated_test.rb

@@ -1,121 +0,0 @@
-require_relative "test_helper"
-
-IOStreams.include(IOStreams::Deprecated)
-
-# Test deprecated api
-class DeprecatedTest < Minitest::Test
-  describe IOStreams do
-    let :source_file_name do
-      File.join(__dir__, "files", "text.txt")
-    end
-
-    let :data do
-      File.read(source_file_name)
-    end
-
-    let :temp_file do
-      Tempfile.new("iostreams")
-    end
-
-    let :target_file_name do
-      temp_file.path
-    end
-
-    let :bad_data do
-      [
-        "New M\xE9xico,NE".b,
-        "good line",
-        "New M\xE9xico,\x07SF".b
-      ].join("\n").encode("BINARY")
-    end
-
-    let :stripped_data do
-      bad_data.gsub("\xE9".b, "").gsub("\x07", "")
-    end
-
-    let :multiple_zip_file_name do
-      File.join(File.dirname(__FILE__), "files", "multiple_files.zip")
-    end
-
-    let :zip_gz_file_name do
-      File.join(File.dirname(__FILE__), "files", "text.zip.gz")
-    end
-
-    let :contents_test_txt do
-      File.read(File.join(File.dirname(__FILE__), "files", "text.txt"))
-    end
-
-    let :contents_test_json do
-      File.read(File.join(File.dirname(__FILE__), "files", "test.json"))
-    end
-
-    after do
-      temp_file.delete
-    end
-
-    describe ".copy" do
-      it "streams" do
-        size = IOStreams.reader(source_file_name) do |source_stream|
-          IOStreams.writer(target_file_name) do |target_stream|
-            IOStreams.copy(source_stream, target_stream)
-          end
-        end
-        actual = File.read(target_file_name)
-
-        assert_equal actual, data
-        assert_equal actual.size, size
-      end
-
-      it "IO stream" do
-        size = File.open(source_file_name) do |source_stream|
-          IOStreams.writer(target_file_name) do |target_stream|
-            IOStreams.copy(source_stream, target_stream)
-          end
-        end
-        actual = File.read(target_file_name)
-
-        assert_equal actual, data
-        assert_equal actual.size, size
-      end
-
-      it "files" do
-        size   = IOStreams.copy(source_file_name, target_file_name)
-        actual = File.read(target_file_name)
-
-        assert_equal actual, data
-        assert_equal actual.size, size
-      end
-    end
-
-    describe ".each_line" do
-      it "returns a line at a time" do
-        lines = []
-        count = IOStreams.each_line(source_file_name) { |line| lines << line }
-        assert_equal data.lines.map(&:strip), lines
-        assert_equal data.lines.count, count
-      end
-
-      it "strips non-printable characters" do
-        input = StringIO.new(bad_data)
-        lines = []
-        count = IOStreams.each_line(input, encoding: "UTF-8", encode_cleaner: :printable, encode_replace: "") do |line|
-          lines << line
-        end
-        assert_equal stripped_data.lines.map(&:strip), lines
-        assert_equal stripped_data.lines.count, count
-      end
-    end
-
-    describe ".reader" do
-      it "reads a zip file" do
-        result = IOStreams.reader(multiple_zip_file_name, streams: {zip: {entry_file_name: "test.json"}}, &:read)
-        assert_equal contents_test_json, result
-      end
-
-      it "reads a zip file from within a gz file" do
-        result = IOStreams.reader(zip_gz_file_name, &:read)
-        assert_equal contents_test_txt, result
-      end
-    end
-  end
-end

data/test/encode_reader_test.rb

@@ -1,51 +0,0 @@
-require_relative "test_helper"
-
-class EncodeReaderTest < Minitest::Test
-  describe IOStreams::Encode::Reader do
-    let :bad_data do
-      [
-        "New M\xE9xico,NE".b,
-        "good line",
-        "New M\xE9xico,\x07SF".b
-      ].join("\n").encode("BINARY")
-    end
-
-    let :cleansed_data do
-      bad_data.gsub("\xE9".b, "")
-    end
-
-    let :stripped_data do
-      cleansed_data.gsub("\x07", "")
-    end
-
-    describe "#read" do
-      describe "replacement" do
-        it "does not strip invalid characters" do
-          skip "Does not raise on JRuby" if defined?(JRuby)
-          input = StringIO.new(bad_data)
-          IOStreams::Encode::Reader.stream(input, encoding: "UTF-8") do |io|
-            assert_raises ::Encoding::UndefinedConversionError do
-              io.read.encoding
-            end
-          end
-        end
-
-        it "strips invalid characters" do
-          input = StringIO.new(bad_data)
-          data  =
-            IOStreams::Encode::Reader.stream(input, encoding: "UTF-8", replace: "", &:read)
-          assert_equal cleansed_data, data
-        end
-      end
-
-      describe "printable" do
-        it "strips non-printable characters" do
-          input = StringIO.new(bad_data)
-          data  =
-            IOStreams::Encode::Reader.stream(input, encoding: "UTF-8", cleaner: :printable, replace: "", &:read)
-          assert_equal stripped_data, data
-        end
-      end
-    end
-  end
-end

data/test/encode_writer_test.rb

@@ -1,90 +0,0 @@
-require_relative "test_helper"
-
-class EncodeWriterTest < Minitest::Test
-  describe IOStreams::Encode::Writer do
-    let :bad_data do
-      [
-        "New M\xE9xico,NE".b,
-        "good line",
-        "New M\xE9xico,\x07SF".b
-      ].join("\n").encode("BINARY")
-    end
-
-    let :cleansed_data do
-      bad_data.gsub("\xE9".b, "?")
-    end
-
-    let :stripped_data do
-      cleansed_data.gsub("\x07", "")
-    end
-
-    describe "#<<" do
-      it "file" do
-        temp_file = Tempfile.new("rocket_job")
-        file_name = temp_file.to_path
-        result    =
-          IOStreams::Encode::Writer.file(file_name, encoding: "ASCII-8BIT") do |io|
-            io << bad_data
-            53534
-          end
-        assert_equal 53534, result
-        result = File.read(file_name, mode: "rb")
-        assert_equal bad_data, result
-      end
-
-      it "stream" do
-        io     = StringIO.new("".b)
-        result =
-          IOStreams::Encode::Writer.stream(io, encoding: "ASCII-8BIT") do |encoded|
-            encoded << bad_data
-            53534
-          end
-        assert_equal 53534, result
-        assert_equal "ASCII-8BIT", io.string.encoding.to_s
-        assert_equal bad_data, io.string
-      end
-
-      it "stream as utf-8" do
-        io = StringIO.new("")
-        assert_raises Encoding::UndefinedConversionError do
-          IOStreams::Encode::Writer.stream(io, encoding: "UTF-8") do |encoded|
-            encoded << bad_data
-          end
-        end
-      end
-
-      it "stream as utf-8 with replacement" do
-        io = StringIO.new("")
-        IOStreams::Encode::Writer.stream(io, encoding: "UTF-8", replace: "?") do |encoded|
-          encoded << bad_data
-        end
-        assert_equal "UTF-8", io.string.encoding.to_s
-        assert_equal cleansed_data, io.string
-      end
-
-      it "stream as utf-8 with replacement and printable cleansing" do
-        io = StringIO.new("")
-        IOStreams::Encode::Writer.stream(io, encoding: "UTF-8", replace: "?", cleaner: :printable) do |encoded|
-          encoded << bad_data
-        end
-        assert_equal "UTF-8", io.string.encoding.to_s
-        assert_equal stripped_data, io.string
-      end
-    end
-
-    describe ".write" do
-      it "returns byte count" do
-        io_string = StringIO.new("".b)
-        count     = 0
-        result    =
-          IOStreams::Encode::Writer.stream(io_string, encoding: "ASCII-8BIT") do |io|
-            count += io.write(bad_data)
-            53534
-          end
-        assert_equal 53534, result
-        assert_equal bad_data, io_string.string
-        assert_equal bad_data.size, count
-      end
-    end
-  end
-end

data/test/files/embedded_lines_test.csv

@@ -1,7 +0,0 @@
-name, description, zip
-"
-Jack","Firstname is Jack","234567"
-"John","Firstname
-is John","234568"
-"Zack","Firstname is Zack","234568
-"

data/test/files/test.csv

@@ -1,4 +0,0 @@
-name, address, state, zip
-Joe Black, 23 Where Rd, FL, 12452
-Who is this, 42 Able Rd, GA, 23432
-Another's Person, 42 and 2nd St, NY, 17449

data/test/files/test.json

@@ -1,3 +0,0 @@
-{"name":"Joe Black"," address":" 23 Where Rd"," state":" FL"," zip":" 12452"}
-{"name":"Who is this"," address":" 42 Able Rd"," state":" GA"," zip":" 23432"}
-{"name":"Another's Person"," address":" 42 and 2nd St"," state":" NY"," zip":" 17449"}

data/test/files/test.psv

@@ -1,4 +0,0 @@
-name|address|state|zip
-Joe Black|23 Where Rd|FL|12452
-Who is this|42 Able Rd|GA|23432
-Another's Person|42 and 2nd St|NY|17449

data/test/files/text file.txt

@@ -1,3 +0,0 @@
-Hello World
-Line2
-Line3

data/test/files/text.txt

@@ -1,3 +0,0 @@
-Hello World
-Line2
-Line3