iostreams 1.11.0 → 2.0.0

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