iostreams 0.14.0 → 0.15.0

data/test/bzip2_writer_test.rb

@@ -1,43 +1,49 @@
 require_relative 'test_helper'
 
-# Unit Test for IOStreams::Bzip2
-module Streams
-  class Bzip2WriterTest < Minitest::Test
-    describe IOStreams::Bzip2::Writer do
-      before do
-        @file_name = File.join(File.dirname(__FILE__), 'files', 'text.txt.gz')
-        @data      = File.read(File.join(File.dirname(__FILE__), 'files', 'text.txt'))
-      end
+class Bzip2WriterTest < Minitest::Test
+  describe IOStreams::Bzip2::Writer do
+    let :temp_file do
+      Tempfile.new('iostreams')
+    end
 
-      describe '.open' do
-        it 'file' do
-          temp_file = Tempfile.new('rocket_job')
-          file_name = temp_file.to_path
-          IOStreams::Bzip2::Writer.open(file_name) do |io|
-            io.write(@data)
-          end
-
-          File.open(file_name, 'rb') do |file|
-            io     = RBzip2.default_adapter::Decompressor.new(file)
-            result = io.read
-            temp_file.delete
-            assert_equal @data, result
-          end
-        end
+    let :file_name do
+      temp_file.path
+    end
 
-        it 'stream' do
-          io_string = StringIO.new(''.force_encoding('ASCII-8BIT'))
-          IOStreams::Bzip2::Writer.open(io_string) do |io|
-            io.write(@data)
-          end
+    let :decompressed do
+      File.read(File.join(File.dirname(__FILE__), 'files', 'text.txt'))
+    end
+
+    after do
+      temp_file.delete
+    end
 
-          io     = StringIO.new(io_string.string)
-          rbzip2 = RBzip2.default_adapter::Decompressor.new(io)
-          data   = rbzip2.read
-          assert_equal @data, data
+    describe '.open' do
+      it 'file' do
+        IOStreams::Bzip2::Writer.open(file_name) do |io|
+          io.write(decompressed)
+        end
+
+        File.open(file_name, 'rb') do |file|
+          io     = RBzip2.default_adapter::Decompressor.new(file)
+          result = io.read
+          temp_file.delete
+          assert_equal decompressed, result
         end
       end
 
+      it 'stream' do
+        io_string = StringIO.new(''.b)
+        IOStreams::Bzip2::Writer.open(io_string) do |io|
+          io.write(decompressed)
+        end
+
+        io     = StringIO.new(io_string.string)
+        rbzip2 = RBzip2.default_adapter::Decompressor.new(io)
+        data   = rbzip2.read
+        assert_equal decompressed, data
+      end
     end
+
   end
 end

data/test/file_reader_test.rb

@@ -1,32 +1,33 @@
 require_relative 'test_helper'
 
-# Unit Test for IOStreams::File
-module Streams
-  class FileReaderTest < Minitest::Test
-    describe IOStreams::File::Reader do
-      before do
-        @file_name = File.join(File.dirname(__FILE__), 'files', 'text.txt')
-        @data      = File.read(@file_name)
-      end
+class FileReaderTest < Minitest::Test
+  describe IOStreams::File::Reader do
+    let :file_name do
+      File.join(File.dirname(__FILE__), 'files', 'text.txt')
+    end
 
-      describe '.open' do
-        it 'file' do
-          result = IOStreams::File::Reader.open(@file_name) do |io|
-            io.read
-          end
-          assert_equal @data, result
+    let :raw do
+      File.read(file_name)
+    end
+
+    describe '.open' do
+      it 'file' do
+        result = IOStreams::File::Reader.open(file_name) do |io|
+          io.read
         end
+        assert_equal raw, result
+      end
 
-        it 'stream' do
-          result = File.open(@file_name) do |file|
+      it 'does not support streams' do
+        assert_raises ArgumentError do
+          File.open(file_name) do |file|
             IOStreams::File::Reader.open(file) do |io|
               io.read
             end
           end
-          assert_equal @data, result
         end
       end
-
     end
+
   end
 end

data/test/file_writer_test.rb

@@ -1,34 +1,35 @@
 require_relative 'test_helper'
 
-# Unit Test for IOStreams::File
-module Streams
-  class FileWriterTest < Minitest::Test
-    describe IOStreams::File::Writer do
-      before do
-        @file_name = File.join(File.dirname(__FILE__), 'files', 'text.txt')
-        @data      = File.read(@file_name)
-      end
+class FileWriterTest < Minitest::Test
+  describe IOStreams::File::Writer do
+    let :file_name do
+      File.join(File.dirname(__FILE__), 'files', 'text.txt')
+    end
 
-      describe '.open' do
-        it 'file' do
-          temp_file = Tempfile.new('rocket_job')
-          file_name = temp_file.to_path
-          IOStreams::File::Writer.open(file_name) do |io|
-            io.write(@data)
-          end
-          result = File.read(file_name)
-          assert_equal @data, result
+    let :raw do
+      File.read(file_name)
+    end
+
+    describe '.open' do
+      it 'file' do
+        temp_file = Tempfile.new('rocket_job')
+        file_name = temp_file.to_path
+        IOStreams::File::Writer.open(file_name) do |io|
+          io.write(raw)
         end
+        result = File.read(file_name)
+        assert_equal raw, result
+      end
 
-        it 'stream' do
-          io_string = StringIO.new
+      it 'does not support streams' do
+        io_string = StringIO.new
+        assert_raises ArgumentError do
           IOStreams::File::Writer.open(io_string) do |io|
-            io.write(@data)
+            io.write(raw)
           end
-          assert_equal @data, io_string.string
         end
       end
-
     end
+
   end
 end

data/test/files/test.json

@@ -0,0 +1,3 @@
+{"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/gzip_reader_test.rb

@@ -1,33 +1,32 @@
 require_relative 'test_helper'
 
-# Unit Test for IOStreams::Gzip
-module Streams
-  class GzipReaderTest < Minitest::Test
-    describe IOStreams::Gzip::Reader do
-      before do
-        @file_name = File.join(File.dirname(__FILE__), 'files', 'text.txt.gz')
-        @gzip_data = File.open(@file_name, 'rb') { |f| f.read }
-        @data      = Zlib::GzipReader.open(@file_name) { |gz| gz.read }
-      end
+class GzipReaderTest < Minitest::Test
+  describe IOStreams::Gzip::Reader do
+    let :file_name do
+      File.join(File.dirname(__FILE__), 'files', 'text.txt.gz')
+    end
 
-      describe '.open' do
-        it 'file' do
-          result = IOStreams::Gzip::Reader.open(@file_name) do |io|
-            io.read
-          end
-          assert_equal @data, result
+    let :decompressed do
+      Zlib::GzipReader.open(file_name) { |gz| gz.read }
+    end
+
+    describe '.open' do
+      it 'file' do
+        result = IOStreams::Gzip::Reader.open(file_name) do |io|
+          io.read
         end
+        assert_equal decompressed, result
+      end
 
-        it 'stream' do
-          result = File.open(@file_name) do |file|
-            IOStreams::Gzip::Reader.open(file) do |io|
-              io.read
-            end
+      it 'stream' do
+        result = File.open(file_name) do |file|
+          IOStreams::Gzip::Reader.open(file) do |io|
+            io.read
           end
-          assert_equal @data, result
         end
+        assert_equal decompressed, result
       end
-
     end
+
   end
 end

data/test/gzip_writer_test.rb

@@ -1,39 +1,45 @@
 require_relative 'test_helper'
 
-# Unit Test for IOStreams::Gzip
-module Streams
-  class GzipWriterTest < Minitest::Test
-    describe IOStreams::Gzip::Writer do
-      before do
-        @file_name = File.join(File.dirname(__FILE__), 'files', 'text.txt.gz')
-        @data      = Zlib::GzipReader.open(@file_name) { |gz| gz.read }
-      end
+class GzipWriterTest < Minitest::Test
+  describe IOStreams::Gzip::Writer do
+    let :temp_file do
+      Tempfile.new('iostreams')
+    end
 
-      describe '.open' do
-        it 'file' do
-          temp_file = Tempfile.new('rocket_job')
-          file_name = temp_file.to_path
-          IOStreams::Gzip::Writer.open(file_name) do |io|
-            io.write(@data)
-          end
-          result = Zlib::GzipReader.open(file_name) { |gz| gz.read }
-          temp_file.delete
-          assert_equal @data, result
-        end
+    let :file_name do
+      temp_file.path
+    end
+
+    let :decompressed do
+      File.read(File.join(File.dirname(__FILE__), 'files', 'text.txt'))
+    end
 
-        it 'stream' do
-          io_string = StringIO.new(''.force_encoding('ASCII-8BIT'))
-          IOStreams::Gzip::Writer.open(io_string) do |io|
-            io.write(@data)
-          end
-          io   = StringIO.new(io_string.string)
-          gz   = Zlib::GzipReader.new(io)
-          data = gz.read
-          gz.close
-          assert_equal @data, data
+    after do
+      temp_file.delete
+    end
+
+    describe '.open' do
+      it 'file' do
+        IOStreams::Gzip::Writer.open(file_name) do |io|
+          io.write(decompressed)
         end
+        result = Zlib::GzipReader.open(file_name) { |gz| gz.read }
+        temp_file.delete
+        assert_equal decompressed, result
       end
 
+      it 'stream' do
+        io_string = StringIO.new(''.b)
+        IOStreams::Gzip::Writer.open(io_string) do |io|
+          io.write(decompressed)
+        end
+        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,84 +1,160 @@
 require_relative 'test_helper'
 
-# Unit Test for IOStreams::File
-module Streams
-  class IOStreamsTest < Minitest::Test
-    describe IOStreams do
-      before do
-        @source_file_name = File.join(File.dirname(__FILE__), 'files', 'text.txt')
-        @data             = File.read(@source_file_name)
-
-        @temp_file        = Tempfile.new('iostreams')
-        @target_file_name = @temp_file.to_path
-      end
+class IOStreamsTest < Minitest::Test
+  describe IOStreams do
+    let :source_file_name do
+      File.join(__dir__, 'files', 'text.txt')
+    end
 
-      after do
-        @temp_file.delete if @temp_file
-      end
+    let :data do
+      File.read(source_file_name)
+    end
 
-      describe '.copy' do
-        it 'file' 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)
+    let :temp_file do
+      Tempfile.new('iostreams')
+    end
 
-          assert_equal actual, @data
-          assert_equal actual.size, size
-        end
+    let :target_file_name do
+      temp_file.path
+    end
+
+    after do
+      temp_file.delete
+    end
 
-        it '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
+    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
-          actual = File.read(@target_file_name)
+        end
+        actual = File.read(target_file_name)
 
-          assert_equal actual, @data
-          assert_equal actual.size, size
+        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
 
-      describe '.copy_file' do
-        it 'copies' do
-          size   = IOStreams.copy_file(@source_file_name, @target_file_name)
-          actual = File.read(@target_file_name)
+      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
+        assert_equal actual, data
+        assert_equal actual.size, size
       end
+    end
 
-      describe '.streams_for_file_name' do
-        it 'file only' do
-          streams = IOStreams.streams_for_file_name('a.xyz')
-          assert_equal [:file], streams
-        end
+    describe '.streams_for_file_name' do
+      it 'file only' do
+        streams = IOStreams.streams_for_file_name('a.xyz')
+        assert_equal [], streams
+      end
 
-        it 'single stream' do
-          streams = IOStreams.streams_for_file_name('a.gz')
-          assert_equal [:gz], streams
-        end
+      it 'single stream' do
+        streams = IOStreams.streams_for_file_name('a.gz')
+        assert_equal [:gz], streams
+      end
 
-        it 'multiple streams' do
-          streams = IOStreams.streams_for_file_name('a.xlsx.gz')
-          assert_equal [:xlsx, :gz], streams
-        end
+      it 'multiple streams' do
+        streams = IOStreams.streams_for_file_name('a.xlsx.gz')
+        assert_equal [:xlsx, :gz], streams
+      end
 
-        it 'is case-insensitive' do
-          streams = IOStreams.streams_for_file_name('a.GzIp')
-          assert_equal [:gzip], streams
-        end
+      it 'is case-insensitive' do
+        streams = IOStreams.streams_for_file_name('a.GzIp')
+        assert_equal [:gzip], streams
+      end
 
-        it 'multiple streams are case-insensitive' do
-          streams = IOStreams.streams_for_file_name('a.XlsX.Gz')
-          assert_equal [:xlsx, :gz], streams
-        end
+      it 'multiple streams are case-insensitive' do
+        streams = IOStreams.streams_for_file_name('a.XlsX.Gz')
+        assert_equal [:xlsx, :gz], streams
+      end
+    end
+
+    describe '.each_line' do
+      it 'returns a line at a time' do
+        lines = []
+        IOStreams.each_line(source_file_name) { |line| lines << line }
+        assert_equal data.lines.map(&:strip), lines
       end
+    end
+
+    describe '.reader' do
+      # IOStreams.reader('abc.csv') do |io|
+      #   p data while (data = io.read(128))
+      # end
+    end
 
+    describe '.each_line' do
+      # IOStreams.each_line('abc.csv') do |line|
+      #   puts line
+      # end
     end
+
+    describe '.each_row' do
+      # IOStreams.each_row('abc.csv') do |array|
+      #   p array
+      # end
+    end
+
+    describe '.each_record' do
+      # IOStreams.each_record('abc.csv') do |hash|
+      #   p hash
+      # end
+
+      # array = [
+      #   'name, address, zip_code',
+      #   'Jack, Down Under, 12345'
+      # ]
+      # IOStreams.each_record(array) do |hash|
+      #   p hash
+      # end
+    end
+
+    describe '.writer' do
+      # IOStreams.writer('abc.csv') do |io|
+      #   io.write('This')
+      #   io.write(' is ')
+      #   io.write(" one line\n")
+      # end
+    end
+
+    describe '.line_writer' do
+      # IOStreams.line_writer('abc.csv') do |file|
+      #   file << 'these'
+      #   file << 'are'
+      #   file << 'all'
+      #   file << 'separate'
+      #   file << 'lines'
+      # end
+    end
+
+    describe '.row_writer' do
+      # IOStreams.row_writer('abc.csv') do |io|
+      #   io << %w[name address zip_code]
+      #   io << %w[Jack There 1234]
+      #   io << ['Joe', 'Over There somewhere', 1234]
+      # end
+    end
+
+    describe '.record_writer' do
+      # IOStreams.record_writer('abc.csv') do |stream|
+      #   stream << {name: 'Jack', address: 'There', zip_code: 1234}
+      #   stream << {name: 'Joe', address: 'Over There somewhere', zip_code: 1234}
+      # end
+    end
+
   end
 end