iostreams 1.1.0 → 1.1.1

data/test/encode_reader_test.rb

@@ -1,52 +1,48 @@
-require_relative 'test_helper'
+require_relative "test_helper"
 
 class EncodeReaderTest < Minitest::Test
   describe IOStreams::Encode::Reader do
     let :bad_data do
       [
         "New M\xE9xico,NE".b,
-        'good line',
+        "good line",
         "New M\xE9xico,\x07SF".b
-      ].join("\n").encode('BINARY')
+      ].join("\n").encode("BINARY")
     end
 
     let :cleansed_data do
-      bad_data.gsub("\xE9".b, '')
+      bad_data.gsub("\xE9".b, "")
     end
 
     let :stripped_data do
-      cleansed_data.gsub("\x07", '')
+      cleansed_data.gsub("\x07", "")
     end
 
-    describe '#read' do
-      describe 'replacement' do
-        it 'does not strip invalid characters' do
+    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|
+          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
+        it "strips invalid characters" do
           input = StringIO.new(bad_data)
           data  =
-            IOStreams::Encode::Reader.stream(input, encoding: 'UTF-8', replace: '') do |io|
-              io.read
-            end
+            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
+      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: '') do |io|
-              io.read
-            end
+            IOStreams::Encode::Reader.stream(input, encoding: "UTF-8", cleaner: :printable, replace: "", &:read)
           assert_equal stripped_data, data
         end
       end

data/test/encode_writer_test.rb

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

data/test/gzip_reader_test.rb

@@ -1,32 +1,27 @@
-require_relative 'test_helper'
+require_relative "test_helper"
 
 class GzipReaderTest < Minitest::Test
   describe IOStreams::Gzip::Reader do
     let :file_name do
-      File.join(File.dirname(__FILE__), 'files', 'text.txt.gz')
+      File.join(File.dirname(__FILE__), "files", "text.txt.gz")
     end
 
     let :decompressed do
-      Zlib::GzipReader.open(file_name) { |gz| gz.read }
+      Zlib::GzipReader.open(file_name, &:read)
     end
 
-    describe '.open' do
-      it 'file' do
-        result = IOStreams::Gzip::Reader.file(file_name) do |io|
-          io.read
-        end
+    describe ".open" do
+      it "file" do
+        result = IOStreams::Gzip::Reader.file(file_name, &:read)
         assert_equal decompressed, result
       end
 
-      it 'stream' do
+      it "stream" do
         result = File.open(file_name) do |file|
-          IOStreams::Gzip::Reader.stream(file) do |io|
-            io.read
-          end
+          IOStreams::Gzip::Reader.stream(file, &:read)
         end
         assert_equal decompressed, result
       end
     end
-
   end
 end

data/test/gzip_writer_test.rb

@@ -1,9 +1,9 @@
-require_relative 'test_helper'
+require_relative "test_helper"
 
 class GzipWriterTest < Minitest::Test
   describe IOStreams::Gzip::Writer do
     let :temp_file do
-      Tempfile.new('iostreams')
+      Tempfile.new("iostreams")
     end
 
     let :file_name do
@@ -11,35 +11,34 @@ class GzipWriterTest < Minitest::Test
     end
 
     let :decompressed do
-      File.read(File.join(File.dirname(__FILE__), 'files', 'text.txt'))
+      File.read(File.join(File.dirname(__FILE__), "files", "text.txt"))
     end
 
     after do
       temp_file.delete
     end
 
-    describe '.file' do
-      it 'file' do
+    describe ".file" do
+      it "file" do
         IOStreams::Gzip::Writer.file(file_name) do |io|
           io.write(decompressed)
         end
-        result = Zlib::GzipReader.open(file_name) { |gz| gz.read }
+        result = Zlib::GzipReader.open(file_name, &:read)
         temp_file.delete
         assert_equal decompressed, result
       end
 
-      it 'stream' do
-        io_string = StringIO.new(''.b)
+      it "stream" do
+        io_string = StringIO.new("".b)
         IOStreams::Gzip::Writer.stream(io_string) do |io|
           io.write(decompressed)
         end
-        io   = StringIO.new(io_string.string)
-        gz   = Zlib::GzipReader.new(io)
+        io = StringIO.new(io_string.string)
+        gz = Zlib::GzipReader.new(io)
         data = gz.read
         gz.close
         assert_equal decompressed, data
       end
     end
-
   end
 end

data/test/io_streams_test.rb

@@ -1,78 +1,78 @@
-require_relative 'test_helper'
+require_relative "test_helper"
 
 module IOStreams
   class PathTest < Minitest::Test
     describe IOStreams do
-      describe '.root' do
-        it 'return default path' do
-          path = ::File.expand_path(::File.join(__dir__, '../tmp/default'))
+      describe ".root" do
+        it "return default path" do
+          path = ::File.expand_path(::File.join(__dir__, "../tmp/default"))
           assert_equal path, IOStreams.root.to_s
         end
 
-        it 'return downloads path' do
-          path = ::File.expand_path(::File.join(__dir__, '../tmp/downloads'))
+        it "return downloads path" do
+          path = ::File.expand_path(::File.join(__dir__, "../tmp/downloads"))
           assert_equal path, IOStreams.root(:downloads).to_s
         end
       end
 
-      describe '.join' do
-        it 'returns path' do
+      describe ".join" do
+        it "returns path" do
           assert_equal IOStreams.root.to_s, IOStreams.join.to_s
         end
 
-        it 'adds path to root' do
-          assert_equal ::File.join(IOStreams.root.to_s, 'test'), IOStreams.join('test').to_s
+        it "adds path to root" do
+          assert_equal ::File.join(IOStreams.root.to_s, "test"), IOStreams.join("test").to_s
         end
 
-        it 'adds paths to root' do
-          assert_equal ::File.join(IOStreams.root.to_s, 'test', 'second', 'third'), IOStreams.join('test', 'second', 'third').to_s
+        it "adds paths to root" do
+          assert_equal ::File.join(IOStreams.root.to_s, "test", "second", "third"), IOStreams.join("test", "second", "third").to_s
         end
 
-        it 'returns path and filename' do
-          path = ::File.join(IOStreams.root.to_s, 'file.xls')
-          assert_equal path, IOStreams.join('file.xls').to_s
+        it "returns path and filename" do
+          path = ::File.join(IOStreams.root.to_s, "file.xls")
+          assert_equal path, IOStreams.join("file.xls").to_s
         end
 
-        it 'adds path to root and filename' do
-          path = ::File.join(IOStreams.root.to_s, 'test', 'file.xls')
-          assert_equal path, IOStreams.join('test', 'file.xls').to_s
+        it "adds path to root and filename" do
+          path = ::File.join(IOStreams.root.to_s, "test", "file.xls")
+          assert_equal path, IOStreams.join("test", "file.xls").to_s
         end
 
-        it 'adds paths to root' do
-          path = ::File.join(IOStreams.root.to_s, 'test', 'second', 'third', 'file.xls')
-          assert_equal path, IOStreams.join('test', 'second', 'third', 'file.xls').to_s
+        it "adds paths to root" do
+          path = ::File.join(IOStreams.root.to_s, "test", "second", "third", "file.xls")
+          assert_equal path, IOStreams.join("test", "second", "third", "file.xls").to_s
         end
 
-        it 'return path as sent in when full path' do
-          path = ::File.join(IOStreams.root.to_s, 'file.xls')
+        it "return path as sent in when full path" do
+          path = ::File.join(IOStreams.root.to_s, "file.xls")
           assert_equal path, IOStreams.join(path).to_s
         end
       end
 
-      describe '.path' do
-        it 'default' do
-          path = IOStreams.path('a.xyz')
+      describe ".path" do
+        it "default" do
+          path = IOStreams.path("a.xyz")
           assert path.is_a?(IOStreams::Paths::File), path
         end
 
-        it 's3' do
-          skip 'TODO'
-          IOStreams.path('s3://a.xyz')
+        it "s3" do
+          skip "TODO"
+          IOStreams.path("s3://a.xyz")
           assert_equal :s3, path
         end
       end
 
-      describe '.temp_file' do
-        it 'returns value from block' do
-          result = IOStreams.temp_file('base', '.ext') { |_path| 257 }
+      describe ".temp_file" do
+        it "returns value from block" do
+          result = IOStreams.temp_file("base", ".ext") { |_path| 257 }
           assert_equal 257, result
         end
 
-        it 'supplies new temp file_name' do
+        it "supplies new temp file_name" do
           path1 = nil
           path2 = nil
-          IOStreams.temp_file('base', '.ext') { |path| path1 = path }
-          IOStreams.temp_file('base', '.ext') { |path| path2 = path }
+          IOStreams.temp_file("base", ".ext") { |path| path1 = path }
+          IOStreams.temp_file("base", ".ext") { |path| path2 = path }
           refute_equal path1.to_s, path2.to_s
           assert path1.is_a?(IOStreams::Paths::File), path1
           assert path2.is_a?(IOStreams::Paths::File), path2

data/test/line_reader_test.rb

@@ -1,25 +1,23 @@
-require_relative 'test_helper'
+require_relative "test_helper"
 
 class LineReaderTest < Minitest::Test
   describe IOStreams::Line::Reader do
     let :file_name do
-      File.join(File.dirname(__FILE__), 'files', 'text.txt')
+      File.join(File.dirname(__FILE__), "files", "text.txt")
     end
 
     let :csv_file do
-      File.join(File.dirname(__FILE__), 'files', 'embedded_lines_test.csv')
+      File.join(File.dirname(__FILE__), "files", "embedded_lines_test.csv")
     end
 
     let :unclosed_quote_file do
-      File.join(File.dirname(__FILE__), 'files', 'unclosed_quote_test.csv')
+      File.join(File.dirname(__FILE__), "files", "unclosed_quote_test.csv")
     end
 
     let :data do
       data = []
-      File.open(file_name, 'rt') do |file|
-        while !file.eof?
-          data << file.readline.strip
-        end
+      File.open(file_name, "rt") do |file|
+        data << file.readline.strip until file.eof?
       end
       data
     end
@@ -31,10 +29,9 @@ class LineReaderTest < Minitest::Test
     # "John","Firstname\n is John","234568"
     # "Zack","Firstname is Zack","234568\n"
     #
-    describe 'embedded_within_quotes' do
-      describe 'csv file' do
-
-        it 'fails to keep embedded lines if flag is not set' do
+    describe "embedded_within_quotes" do
+      describe "csv file" do
+        it "fails to keep embedded lines if flag is not set" do
           lines = []
           IOStreams::Line::Reader.file(csv_file) do |io|
             io.each do |line|
@@ -44,7 +41,7 @@ class LineReaderTest < Minitest::Test
           assert_equal 7, lines.count
         end
 
-        it 'keeps embedded lines if flag is set' do
+        it "keeps embedded lines if flag is set" do
           lines = []
           IOStreams::Line::Reader.file(csv_file, embedded_within: '"') do |io|
             io.each do |line|
@@ -54,7 +51,7 @@ class LineReaderTest < Minitest::Test
           assert_equal 4, lines.count
         end
 
-        it 'raises error for unclosed quote' do
+        it "raises error for unclosed quote" do
           assert_raises(RuntimeError) do
             IOStreams::Line::Reader.file(unclosed_quote_file, embedded_within: '"') do |io|
               io.each do |line|
@@ -65,8 +62,8 @@ class LineReaderTest < Minitest::Test
       end
     end
 
-    describe '#each' do
-      it 'each_line file' do
+    describe "#each" do
+      it "each_line file" do
         lines = []
         count = IOStreams::Line::Reader.file(file_name) do |io|
           io.each { |line| lines << line }
@@ -75,7 +72,7 @@ class LineReaderTest < Minitest::Test
         assert_equal data.size, count
       end
 
-      it 'each_line stream' do
+      it "each_line stream" do
         lines = []
         count = File.open(file_name) do |file|
           IOStreams::Line::Reader.stream(file) do |io|
@@ -108,7 +105,7 @@ class LineReaderTest < Minitest::Test
         end
       end
 
-      ['@', 'BLAH'].each do |delimiter|
+      ["@", "BLAH"].each do |delimiter|
         it "reads delimited #{delimiter.inspect}" do
           lines  = []
           stream = StringIO.new(data.join(delimiter))
@@ -120,10 +117,10 @@ class LineReaderTest < Minitest::Test
         end
       end
 
-      it 'reads binary delimited' do
+      it "reads binary delimited" do
         delimiter = "\x01"
         lines     = []
-        stream    = StringIO.new(data.join(delimiter).encode('ASCII-8BIT'))
+        stream    = StringIO.new(data.join(delimiter).encode("ASCII-8BIT"))
         count     = IOStreams::Line::Reader.stream(stream, buffer_size: 15, delimiter: delimiter) do |io|
           io.each { |line| lines << line }
         end
@@ -131,12 +128,12 @@ class LineReaderTest < Minitest::Test
         assert_equal data.size, count
       end
 
-      describe '#readline' do
-        let(:short_line) { '0123456789' }
-        let(:longer_line) { 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' }
+      describe "#readline" do
+        let(:short_line) { "0123456789" }
+        let(:longer_line) { "ABCDEFGHIJKLMNOPQRSTUVWXYZ" }
         let(:delimiter) { "\r\n" }
 
-        it 'reads delimiter in first block, no delimiter at end' do
+        it "reads delimiter in first block, no delimiter at end" do
           data        = [short_line, longer_line].join(delimiter)
           buffer_size = short_line.length + delimiter.size + (longer_line.size / 2)
 
@@ -153,7 +150,7 @@ class LineReaderTest < Minitest::Test
           end
         end
 
-        it 'reads delimiter in second block, no delimiter at end' do
+        it "reads delimiter in second block, no delimiter at end" do
           data        = [longer_line, short_line, short_line].join(delimiter)
           buffer_size = (longer_line.length + delimiter.size + 5) / 2
 
@@ -169,7 +166,7 @@ class LineReaderTest < Minitest::Test
           end
         end
 
-        it 'reads delimiter split across first and second blocks' do
+        it "reads delimiter split across first and second blocks" do
           data        = [longer_line, short_line, short_line].join(delimiter)
           buffer_size = longer_line.length + 1
 
@@ -185,8 +182,8 @@ class LineReaderTest < Minitest::Test
           end
         end
 
-        it 'reads file with no matching delimiter' do
-          delimiter   = '@'
+        it "reads file with no matching delimiter" do
+          delimiter   = "@"
           data        = [longer_line, short_line, longer_line].join(delimiter) + delimiter
           buffer_size = longer_line.length + 1
 
@@ -200,7 +197,7 @@ class LineReaderTest < Minitest::Test
           end
         end
 
-        it 'reads small file with no matching delimiter' do
+        it "reads small file with no matching delimiter" do
           data        = short_line
           buffer_size = short_line.length + 100
 
@@ -214,8 +211,8 @@ class LineReaderTest < Minitest::Test
           end
         end
 
-        it 'reads last line with the delimiter as the last character' do
-          delimiter   = '@'
+        it "reads last line with the delimiter as the last character" do
+          delimiter   = "@"
           data        = [longer_line, short_line, longer_line].join(delimiter) + delimiter
           buffer_size = longer_line.length + 1
 
@@ -231,7 +228,7 @@ class LineReaderTest < Minitest::Test
           end
         end
 
-        it 'reads last line with the multi-byte delimiter as the last bytes' do
+        it "reads last line with the multi-byte delimiter as the last bytes" do
           data        = [longer_line, short_line, longer_line].join(delimiter) + delimiter
           buffer_size = longer_line.length + 1
 
@@ -247,10 +244,10 @@ class LineReaderTest < Minitest::Test
           end
         end
 
-        describe 'read 1 char at a time' do
+        describe "read 1 char at a time" do
           let(:buffer_size) { 1 }
 
-          it 'delimiter at the end' do
+          it "delimiter at the end" do
             data = [longer_line, short_line, longer_line].join(delimiter) + delimiter
 
             stream = StringIO.new(data)
@@ -265,7 +262,7 @@ class LineReaderTest < Minitest::Test
             end
           end
 
-          it 'no delimiter at the end' do
+          it "no delimiter at the end" do
             data = [longer_line, short_line, longer_line].join(delimiter)
 
             stream = StringIO.new(data)
@@ -281,21 +278,20 @@ class LineReaderTest < Minitest::Test
           end
         end
 
-        it 'reads empty file' do
+        it "reads empty file" do
           stream = StringIO.new
           IOStreams::Line::Reader.stream(stream) do |io|
             assert io.eof?
           end
         end
 
-        it 'prevents denial of service' do
-          data   = 'a' * IOStreams::Line::Reader::MAX_BLOCKS_MULTIPLIER + 'a'
+        it "prevents denial of service" do
+          data   = "a" * IOStreams::Line::Reader::MAX_BLOCKS_MULTIPLIER + "a"
           stream = StringIO.new(data)
           assert_raises IOStreams::Errors::DelimiterNotFound do
             IOStreams::Line::Reader.stream(stream, buffer_size: 1) do |io|
             end
           end
-
         end
       end
     end