iostreams 1.1.0 → 1.1.1

data/test/line_writer_test.rb

@@ -1,9 +1,9 @@
-require_relative 'test_helper'
+require_relative "test_helper"
 
 class DelimitedWriterTest < Minitest::Test
   describe IOStreams::Line::Writer do
     let :file_name do
-      File.join(File.dirname(__FILE__), 'files', 'text.txt')
+      File.join(File.dirname(__FILE__), "files", "text.txt")
     end
 
     let :raw do
@@ -14,9 +14,9 @@ class DelimitedWriterTest < Minitest::Test
       raw.lines.map(&:strip)
     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::Line::Writer.file(file_name) do |io|
           lines.each { |line| io << line }
@@ -25,7 +25,7 @@ class DelimitedWriterTest < Minitest::Test
         assert_equal raw, result
       end
 
-      it 'stream' do
+      it "stream" do
         io_string = StringIO.new
         IOStreams::Line::Writer.stream(io_string) do |io|
           lines.each { |line| io << line }
@@ -34,8 +34,8 @@ class DelimitedWriterTest < Minitest::Test
       end
     end
 
-    describe '.write' do
-      it 'returns byte count' do
+    describe ".write" do
+      it "returns byte count" do
         io_string = StringIO.new
         count     = 0
         IOStreams::Line::Writer.stream(io_string) do |io|
@@ -45,6 +45,5 @@ class DelimitedWriterTest < Minitest::Test
         assert_equal raw.size, count
       end
     end
-
   end
 end

data/test/minimal_file_reader.rb

@@ -4,7 +4,7 @@ class MinimalFileReader
     io = new(file_name)
     yield(io)
   ensure
-    io.close if io
+    io&.close
   end
 
   def initialize(file_name)

data/test/path_test.rb

@@ -1,53 +1,53 @@
-require_relative 'test_helper'
+require_relative "test_helper"
 
 module IOStreams
   class PathTest < Minitest::Test
     describe IOStreams::Path do
-      describe '.join' do
-        let(:path) { IOStreams::Path.new('some_path') }
+      describe ".join" do
+        let(:path) { IOStreams::Path.new("some_path") }
 
-        it 'returns self when no elements' do
+        it "returns self when no elements" do
           assert_equal path.object_id, path.join.object_id
         end
 
-        it 'adds element to path' do
-          assert_equal ::File.join('some_path', 'test'), path.join('test').to_s
+        it "adds element to path" do
+          assert_equal ::File.join("some_path", "test"), path.join("test").to_s
         end
 
-        it 'adds paths to root' do
-          assert_equal ::File.join('some_path', 'test', 'second', 'third'), path.join('test', 'second', 'third').to_s
+        it "adds paths to root" do
+          assert_equal ::File.join("some_path", "test", "second", "third"), path.join("test", "second", "third").to_s
         end
 
-        it 'returns path and filename' do
-          assert_equal ::File.join('some_path', 'file.xls'), path.join('file.xls').to_s
+        it "returns path and filename" do
+          assert_equal ::File.join("some_path", "file.xls"), path.join("file.xls").to_s
         end
 
-        it 'adds elements to path' do
-          assert_equal ::File.join('some_path', 'test', 'second', 'third', 'file.xls'), path.join('test', 'second', 'third', 'file.xls').to_s
+        it "adds elements to path" do
+          assert_equal ::File.join("some_path", "test", "second", "third", "file.xls"), path.join("test", "second", "third", "file.xls").to_s
         end
 
-        it 'return path as sent in when full path' do
-          assert_equal ::File.join('some_path', 'test', 'second', 'third', 'file.xls'), path.join('some_path', 'test', 'second', 'third', 'file.xls').to_s
+        it "return path as sent in when full path" do
+          assert_equal ::File.join("some_path", "test", "second", "third", "file.xls"), path.join("some_path", "test", "second", "third", "file.xls").to_s
         end
       end
 
-      describe '#absolute?' do
-        it 'true on absolute' do
-          assert_equal true, IOStreams::Path.new('/a/b/c/d').absolute?
+      describe "#absolute?" do
+        it "true on absolute" do
+          assert_equal true, IOStreams::Path.new("/a/b/c/d").absolute?
         end
 
-        it 'false when not absolute' do
-          assert_equal false, IOStreams::Path.new('a/b/c/d').absolute?
+        it "false when not absolute" do
+          assert_equal false, IOStreams::Path.new("a/b/c/d").absolute?
         end
       end
 
-      describe '#relatve?' do
-        it 'true on relative' do
-          assert_equal true, IOStreams::Path.new('a/b/c/d').relative?
+      describe "#relatve?" do
+        it "true on relative" do
+          assert_equal true, IOStreams::Path.new("a/b/c/d").relative?
         end
 
-        it 'false on absolute' do
-          assert_equal false, IOStreams::Path.new('/a/b/c/d').relative?
+        it "false on absolute" do
+          assert_equal false, IOStreams::Path.new("/a/b/c/d").relative?
         end
       end
     end

data/test/paths/file_test.rb

@@ -1,48 +1,48 @@
-require_relative '../test_helper'
+require_relative "../test_helper"
 
 module Paths
   class FileTest < Minitest::Test
     describe IOStreams::Paths::File do
       let(:root) { IOStreams::Paths::File.new("/tmp/iostreams").delete_all }
-      let(:directory) { root.join('/some_test_dir') }
+      let(:directory) { root.join("/some_test_dir") }
       let(:data) { "Hello World" }
       let(:file_path) do
-        path = root.join('some_test_dir/test_file.txt')
+        path = root.join("some_test_dir/test_file.txt")
         path.writer { |io| io << data }
         path
       end
       let(:file_path2) do
-        path = root.join('some_test_dir/test_file2.txt')
+        path = root.join("some_test_dir/test_file2.txt")
         path.writer { |io| io << "Hello World2" }
         path
       end
 
-      describe '#each_child' do
-        it 'iterates an empty path' do
+      describe "#each_child" do
+        it "iterates an empty path" do
           none = nil
-          directory.join('does_not_exist').mkdir.each_child { |path| none = path }
+          directory.join("does_not_exist").mkdir.each_child { |path| none = path }
           assert_nil none
         end
 
-        it 'iterates a non-existant path' do
+        it "iterates a non-existant path" do
           none = nil
-          directory.join('does_not_exist').each_child { |path| none = path }
+          directory.join("does_not_exist").each_child { |path| none = path }
           assert_nil none
         end
 
-        it 'find all files' do
+        it "find all files" do
           expected = [file_path.to_s, file_path2.to_s]
           actual   = root.children("**/*").collect(&:to_s)
           assert_equal expected.sort, actual.sort
         end
 
-        it 'find matches case-insensitive' do
+        it "find matches case-insensitive" do
           expected = [file_path.to_s, file_path2.to_s]
           actual   = root.children("**/Test*.TXT").collect(&:to_s)
           assert_equal expected, actual.sort
         end
 
-        it 'find matches case-sensitive' do
+        it "find matches case-sensitive" do
           skip "TODO"
           expected = [file_path.to_s, file_path2.to_s]
           actual   = root.children("**/Test*.TXT", case_sensitive: true).collect(&:to_s)
@@ -50,24 +50,24 @@ module Paths
         end
       end
 
-      describe '#mkpath' do
-        it 'makes path skipping file_name' do
-          new_path = directory.join('test_mkpath.xls').mkpath
+      describe "#mkpath" do
+        it "makes path skipping file_name" do
+          new_path = directory.join("test_mkpath.xls").mkpath
           assert ::File.exist?(directory.to_s)
           refute ::File.exist?(new_path.to_s)
         end
       end
 
-      describe '#mkdir' do
-        it 'makes entire path that does not have a file name' do
-          new_path = directory.join('more_path').mkdir
+      describe "#mkdir" do
+        it "makes entire path that does not have a file name" do
+          new_path = directory.join("more_path").mkdir
           assert ::File.exist?(directory.to_s)
           assert ::File.exist?(new_path.to_s)
         end
       end
 
-      describe '#exist?' do
-        it 'true on existing file or directory' do
+      describe "#exist?" do
+        it "true on existing file or directory" do
           assert ::File.exist?(file_path.to_s)
           assert ::File.exist?(directory.to_s)
 
@@ -75,8 +75,8 @@ module Paths
           assert file_path.exist?
         end
 
-        it 'false when not found' do
-          non_existant_directory = directory.join('oh_no')
+        it "false when not found" do
+          non_existant_directory = directory.join("oh_no")
           refute ::File.exist?(non_existant_directory.to_s)
 
           non_existant_file_path = directory.join("abc.txt")
@@ -87,31 +87,31 @@ module Paths
         end
       end
 
-      describe '#size' do
-        it 'of file' do
+      describe "#size" do
+        it "of file" do
           assert_equal data.size, file_path.size
         end
       end
 
-      describe '#realpath' do
-        it 'already a real path' do
-          path = ::File.expand_path(__dir__, '../files/test.csv')
+      describe "#realpath" do
+        it "already a real path" do
+          path = ::File.expand_path(__dir__, "../files/test.csv")
           assert_equal path, IOStreams::Paths::File.new(path).realpath.to_s
         end
 
-        it 'removes ..' do
-          path     = ::File.join(__dir__, '../files/test.csv')
+        it "removes .." do
+          path     = ::File.join(__dir__, "../files/test.csv")
           realpath = ::File.realpath(path)
           assert_equal realpath, IOStreams::Paths::File.new(path).realpath.to_s
         end
       end
 
-      describe '#move_to' do
-        it 'move_to existing file' do
+      describe "#move_to" do
+        it "move_to existing file" do
           IOStreams.temp_file("iostreams_move_test", ".txt") do |temp_file|
             temp_file.write("Hello World")
             begin
-              target = temp_file.directory.join("move_test.txt")
+              target   = temp_file.directory.join("move_test.txt")
               response = temp_file.move_to(target)
               assert_equal target, response
               assert target.exist?
@@ -124,7 +124,7 @@ module Paths
           end
         end
 
-        it 'missing source file' do
+        it "missing source file" do
           IOStreams.temp_file("iostreams_move_test", ".txt") do |temp_file|
             begin
               refute temp_file.exist?
@@ -138,11 +138,11 @@ module Paths
           end
         end
 
-        it 'missing target directories' do
+        it "missing target directories" do
           IOStreams.temp_file("iostreams_move_test", ".txt") do |temp_file|
             temp_file.write("Hello World")
             begin
-              target = temp_file.directory.join("a/b/c/move_test.txt")
+              target   = temp_file.directory.join("a/b/c/move_test.txt")
               response = temp_file.move_to(target)
               assert_equal target, response
               assert target.exist?
@@ -156,27 +156,27 @@ module Paths
         end
       end
 
-      describe '#delete' do
-        it 'deletes existing file' do
+      describe "#delete" do
+        it "deletes existing file" do
           assert ::File.exist?(file_path.to_s)
           file_path.delete
           refute ::File.exist?(file_path.to_s)
         end
 
-        it 'ignores missing file' do
+        it "ignores missing file" do
           file_path.delete
           file_path.delete
         end
       end
 
-      describe 'reader' do
-        it 'reads file' do
+      describe "reader" do
+        it "reads file" do
           assert_equal data, file_path.reader(&:read)
         end
       end
 
-      describe 'writer' do
-        it 'creates file' do
+      describe "writer" do
+        it "creates file" do
           new_file_path = directory.join("new.txt")
           refute ::File.exist?(new_file_path.to_s)
           new_file_path.writer { |io| io << data }

data/test/paths/http_test.rb

@@ -1,4 +1,4 @@
-require_relative '../test_helper'
+require_relative "../test_helper"
 
 module Paths
   class HTTPTest < Minitest::Test
@@ -11,18 +11,18 @@ module Paths
         "https://example.com/index.html?count=10"
       end
 
-      describe '.open' do
-        it 'reads http' do
+      describe ".open" do
+        it "reads http" do
           result = IOStreams::Paths::HTTP.new(url).read
           assert_includes result, "<html>"
         end
 
-        it 'reads https' do
+        it "reads https" do
           result = IOStreams::Paths::HTTP.new(ssl_url).read
           assert_includes result, "<html>"
         end
 
-        it 'does not support streams' do
+        it "does not support streams" do
           assert_raises URI::InvalidURIError do
             io = StringIO.new
             IOStreams::Paths::HTTP.new(io)

data/test/paths/matcher_test.rb

@@ -1,4 +1,4 @@
-require_relative '../test_helper'
+require_relative "../test_helper"
 
 module Paths
   class MatcherTest < Minitest::Test
@@ -49,13 +49,13 @@ module Paths
             case_sensitive:   true
           },
           {path: "/path/work", pattern: "file.txt", expected_path: "/path/work/file.txt", expected_pattern: nil, recursive: false},
-          {path: "/path/work", pattern: "*", expected_path: "/path/work", expected_pattern: "*", recursive: false},
+          {path: "/path/work", pattern: "*", expected_path: "/path/work", expected_pattern: "*", recursive: false}
         ]
       end
       # , case_sensitive: false, hidden: false
 
-      describe '#recursive?' do
-        it 'identifies recursive paths correctly' do
+      describe "#recursive?" do
+        it "identifies recursive paths correctly" do
           cases.each do |test_case|
             path    = IOStreams.path(test_case[:path])
             matcher = IOStreams::Paths::Matcher.new(path, test_case[:pattern])
@@ -65,7 +65,7 @@ module Paths
       end
 
       describe "#path?" do
-        it 'optimizes path correctly' do
+        it "optimizes path correctly" do
           cases.each do |test_case|
             path    = IOStreams.path(test_case[:path])
             matcher = IOStreams::Paths::Matcher.new(path, test_case[:pattern])
@@ -75,7 +75,7 @@ module Paths
       end
 
       describe "#pattern" do
-        it 'optimizes pattern correctly' do
+        it "optimizes pattern correctly" do
           cases.each do |test_case|
             path    = IOStreams.path(test_case[:path])
             matcher = IOStreams::Paths::Matcher.new(path, test_case[:pattern])
@@ -89,7 +89,7 @@ module Paths
       end
 
       describe "#match?" do
-        it 'matches' do
+        it "matches" do
           cases.each do |test_case|
             path           = IOStreams.path(test_case[:path])
             case_sensitive = test_case.fetch(:case_sensitive, false)
@@ -102,20 +102,19 @@ module Paths
           end
         end
 
-        it 'should not match' do
-          cases.each do |test_case|
+        it "should not match" do
+          cases.each_with_index do |test_case, index|
             path           = IOStreams.path(test_case[:path])
-            case_sensitive = test_case.fetch(case_sensitive, :false)
+            case_sensitive = test_case.key?(:case_sensitive) ? test_case[:case_sensitive] : false
             matcher        = IOStreams::Paths::Matcher.new(path, test_case[:pattern], case_sensitive: case_sensitive)
             next unless test_case[:not_matches]
 
             test_case[:not_matches].each do |file_name|
-              refute matcher.match?(file_name), test_case.merge(file_name: file_name)
+              refute matcher.match?(file_name), -> { {case_sensitive: case_sensitive, test_case_number: index + 1, failed_file_name: file_name, test_case: test_case}.ai }
             end
           end
         end
       end
-
     end
   end
 end

data/test/paths/s3_test.rb

@@ -1,16 +1,14 @@
-require_relative '../test_helper'
+require_relative "../test_helper"
 
 module Paths
   class S3Test < Minitest::Test
     describe IOStreams::Paths::S3 do
       before do
-        unless ENV['S3_BUCKET_NAME']
-          skip "Supply 'S3_BUCKET_NAME' environment variable with S3 bucket name to test S3 paths"
-        end
+        skip "Supply 'S3_BUCKET_NAME' environment variable with S3 bucket name to test S3 paths" unless ENV["S3_BUCKET_NAME"]
       end
 
       let :file_name do
-        File.join(File.dirname(__FILE__), '..', 'files', 'text file.txt')
+        File.join(File.dirname(__FILE__), "..", "files", "text file.txt")
       end
 
       let :raw do
@@ -20,98 +18,98 @@ module Paths
       let(:root_path) { IOStreams::Paths::S3.new("s3://#{ENV['S3_BUCKET_NAME']}/iostreams_test") }
 
       let :existing_path do
-        path = root_path.join('test.txt')
+        path = root_path.join("test.txt")
         path.write(raw) unless path.exist?
         path
       end
 
       let :missing_path do
-        root_path.join('unknown.txt')
+        root_path.join("unknown.txt")
       end
 
       let :write_path do
-        root_path.join('writer_test.txt').delete
+        root_path.join("writer_test.txt").delete
       end
 
-      describe '#delete' do
-        it 'existing file' do
+      describe "#delete" do
+        it "existing file" do
           assert existing_path.delete.is_a?(IOStreams::Paths::S3)
         end
 
-        it 'missing file' do
+        it "missing file" do
           assert missing_path.delete.is_a?(IOStreams::Paths::S3)
         end
       end
 
-      describe '#exist?' do
-        it 'existing file' do
+      describe "#exist?" do
+        it "existing file" do
           assert existing_path.exist?
         end
 
-        it 'missing file' do
+        it "missing file" do
           refute missing_path.exist?
         end
       end
 
-      describe '#mkpath' do
-        it 'returns self for non-existant path' do
+      describe "#mkpath" do
+        it "returns self for non-existant path" do
           assert existing_path.mkpath.is_a?(IOStreams::Paths::S3)
         end
 
-        it 'checks for lack of existence' do
+        it "checks for lack of existence" do
           assert missing_path.mkpath.is_a?(IOStreams::Paths::S3)
         end
       end
 
-      describe '#mkdir' do
-        it 'returns self for non-existant path' do
+      describe "#mkdir" do
+        it "returns self for non-existant path" do
           assert existing_path.mkdir.is_a?(IOStreams::Paths::S3)
         end
 
-        it 'checks for lack of existence' do
+        it "checks for lack of existence" do
           assert missing_path.mkdir.is_a?(IOStreams::Paths::S3)
         end
       end
 
-      describe '#reader' do
-        it 'reads' do
-          assert_equal raw, existing_path.reader { |io| io.read }
+      describe "#reader" do
+        it "reads" do
+          assert_equal raw, existing_path.reader(&:read)
         end
       end
 
-      describe '#size' do
-        it 'existing file' do
+      describe "#size" do
+        it "existing file" do
           assert_equal raw.size, existing_path.size
         end
 
-        it 'missing file' do
+        it "missing file" do
           assert_nil missing_path.size
         end
       end
 
-      describe '#writer' do
-        it 'writes' do
+      describe "#writer" do
+        it "writes" do
           assert_equal raw.size, write_path.writer { |io| io.write(raw) }
           assert write_path.exist?
           assert_equal raw, write_path.read
         end
       end
 
-      describe '#each_line' do
-        it 'reads line by line' do
+      describe "#each_line" do
+        it "reads line by line" do
           lines = []
-          existing_path.each(:line) {|line| lines << line}
+          existing_path.each(:line) { |line| lines << line }
           assert_equal raw.lines.collect(&:chomp), lines
         end
       end
 
-      describe '#each_child' do
+      describe "#each_child" do
         # TODO: case_sensitive: false, directories: false, hidden: false
         let(:abd_file_names) { %w[abd/test1.txt abd/test5.file abd/extra/file.csv] }
         let(:files_for_test) { abd_file_names + %w[xyz/test2.csv xyz/another.csv] }
 
         let :each_root do
-          root_path.join('each_child_test')
+          root_path.join("each_child_test")
         end
 
         let :multiple_paths do
@@ -122,37 +120,37 @@ module Paths
           multiple_paths.each { |path| path.write(raw) unless path.exist? }
         end
 
-        it 'existing file returns just the file itself' do
+        it "existing file returns just the file itself" do
           # Glorified exists call
           existing_path
           assert_equal root_path.join("test.txt").to_s, root_path.children("test.txt").first.to_s
         end
 
-        it 'missing file does nothing' do
+        it "missing file does nothing" do
           # Glorified exists call
           assert_equal [], missing_path.children("readme").collect(&:to_s)
         end
 
-        it 'returns all the children' do
+        it "returns all the children" do
           write_raw_data
           assert_equal multiple_paths.collect(&:to_s).sort, each_root.children("**/*").collect(&:to_s).sort
         end
 
-        it 'returns all the children under a sub-dir' do
+        it "returns all the children under a sub-dir" do
           write_raw_data
           expected = abd_file_names.collect { |file_name| each_root.join(file_name) }
           assert_equal expected.collect(&:to_s).sort, each_root.children("abd/*").collect(&:to_s).sort
         end
 
-        it 'missing path' do
+        it "missing path" do
           count = 0
           missing_path.each_child { |_| count += 1 }
           assert_equal 0, count
         end
 
         # Test is here since all the test artifacts have been created already in S3.
-        describe 'IOStreams.each_child' do
-          it 'returns all the children' do
+        describe "IOStreams.each_child" do
+          it "returns all the children" do
             write_raw_data
             children = []
             IOStreams.each_child(each_root.join("**/*").to_s) { |child| children << child }
@@ -161,8 +159,8 @@ module Paths
         end
       end
 
-      describe '#move_to' do
-        it 'moves existing file' do
+      describe "#move_to" do
+        it "moves existing file" do
           source = root_path.join("move_test_source.txt")
           begin
             source.write("Hello World")
@@ -179,7 +177,7 @@ module Paths
           end
         end
 
-        it 'missing source file' do
+        it "missing source file" do
           source = root_path.join("move_test_source.txt")
           refute source.exist?
           begin
@@ -194,7 +192,7 @@ module Paths
           end
         end
 
-        it 'missing target directories' do
+        it "missing target directories" do
           source = root_path.join("move_test_source.txt")
           begin
             source.write("Hello World")
@@ -212,8 +210,8 @@ module Paths
         end
       end
 
-      describe '#partial_files_visible?' do
-        it 'visible only after upload' do
+      describe "#partial_files_visible?" do
+        it "visible only after upload" do
           refute root_path.partial_files_visible?
         end
       end