iostreams 0.20.3 → 1.0.0.beta

data/lib/io_streams/symmetric_encryption/reader.rb

@@ -1,21 +1,13 @@
 module IOStreams
   module SymmetricEncryption
-    class Reader
+    class Reader < IOStreams::Reader
       # read from a file/stream using Symmetric Encryption
-      def self.open(file_name_or_io, **args, &block)
-        begin
-          require 'symmetric-encryption' unless defined?(SymmetricEncryption)
-        rescue LoadError => e
-          raise(LoadError, "Please install the 'symmetric-encryption' gem for .enc streaming support. #{e.message}")
+      def self.stream(input_stream, **args, &block)
+        unless defined?(SymmetricEncryption)
+          Utils.load_dependency('symmetric-encryption', '.enc streaming')
         end
 
-        if IOStreams.reader_stream?(file_name_or_io)
-          ::SymmetricEncryption::Reader.open(file_name_or_io, **args, &block)
-        else
-          IOStreams::File::Reader.open(file_name_or_io) do |file|
-            ::SymmetricEncryption::Reader.open(file, **args, &block)
-          end
-        end
+        ::SymmetricEncryption::Reader.open(input_stream, **args, &block)
       end
     end
   end

data/lib/io_streams/symmetric_encryption/writer.rb

@@ -1,24 +1,25 @@
 module IOStreams
   module SymmetricEncryption
-    class Writer
-      # Write to file/stream using Symmetric Encryption
-      def self.open(file_name_or_io, compress: nil, **args, &block)
-        begin
-          require 'symmetric-encryption' unless defined?(SymmetricEncryption)
-        rescue LoadError => e
-          raise(LoadError, "Please install the 'symmetric-encryption' gem for .enc streaming support. #{e.message}")
+    class Writer < IOStreams::Writer
+      # Write to stream using Symmetric Encryption
+      # By default the output stream is compressed.
+      # If the input_stream is already compressed consider setting compress: false.
+      def self.stream(input_stream, compress: true, **args, &block)
+        unless defined?(SymmetricEncryption)
+          Utils.load_dependency('symmetric-encryption', '.enc streaming')
         end
 
-        if IOStreams.writer_stream?(file_name_or_io)
-          compress = true if compress.nil?
-          ::SymmetricEncryption::Writer.open(file_name_or_io, compress: compress, **args, &block)
-        else
-          compress = !IOStreams.compressed?(file_name_or_io) if compress.nil?
+        ::SymmetricEncryption::Writer.open(input_stream, compress: compress, **args, &block)
+      end
 
-          IOStreams::File::Writer.open(file_name_or_io) do |file|
-            ::SymmetricEncryption::Writer.open(file, compress: compress, **args, &block)
-          end
+      # Write to stream using Symmetric Encryption
+      # By default the output stream is compressed unless the file_name extension indicates the file is already compressed.
+      def self.file(file_name, compress: nil, **args, &block)
+        unless defined?(SymmetricEncryption)
+          Utils.load_dependency('symmetric-encryption', '.enc streaming')
         end
+
+        ::SymmetricEncryption::Writer.open(file_name, compress: compress, **args, &block)
       end
     end
   end

data/lib/io_streams/tabular/header.rb

@@ -90,7 +90,10 @@ module IOStreams
 
         case row
         when Array
-          raise(IOStreams::Errors::InvalidHeader, "Missing mandatory header when trying to convert a row into a hash") unless columns
+          unless columns
+            raise(IOStreams::Errors::InvalidHeader, 'Missing mandatory header when trying to convert a row into a hash')
+          end
+
           array_to_hash(row)
         when Hash
           cleanse && columns ? cleanse_hash(row) : row
@@ -104,7 +107,11 @@ module IOStreams
           row = cleanse_hash(row) if cleanse
           row = columns.collect { |column| row[column] }
         end
-        raise(IOStreams::Errors::TypeMismatch, "Don't know how to convert #{row.class.name} to an Array without the header columns being set.") unless row.is_a?(Array)
+
+        unless row.is_a?(Array)
+          raise(IOStreams::Errors::TypeMismatch, "Don't know how to convert #{row.class.name} to an Array without the header columns being set.")
+        end
+
         row
       end
 
@@ -140,7 +147,6 @@ module IOStreams
         cleansed.gsub!(/\W+/, '')
         cleansed
       end
-
     end
   end
 end

data/lib/io_streams/tabular/parser/array.rb

@@ -6,20 +6,25 @@ module IOStreams
         # Returns [Array<String>] the header row.
         # Returns nil if the row is blank.
         def parse_header(row)
-          raise(IOStreams::Errors::InvalidHeader, "Format is :array. Invalid input header: #{row.class.name}") unless row.is_a?(::Array)
+          unless row.is_a?(::Array)
+            raise(IOStreams::Errors::InvalidHeader, "Format is :array. Invalid input header: #{row.class.name}")
+          end
+
           row
         end
 
         # Returns Array
         def parse(row)
-          raise(IOStreams::Errors::TypeMismatch, "Format is :array. Invalid input: #{row.class.name}") unless row.is_a?(::Array)
+          unless row.is_a?(::Array)
+            raise(IOStreams::Errors::TypeMismatch, "Format is :array. Invalid input: #{row.class.name}")
+          end
+
           row
         end
 
         def render(row, header)
           header.to_array(row)
         end
-
       end
     end
   end

data/lib/io_streams/tabular/parser/csv.rb

@@ -14,7 +14,9 @@ module IOStreams
         def parse_header(row)
           return row if row.is_a?(::Array)
 
-          raise(IOStreams::Errors::InvalidHeader, "Format is :csv. Invalid input header: #{row.class.name}") unless row.is_a?(String)
+          unless row.is_a?(String)
+            raise(IOStreams::Errors::InvalidHeader, "Format is :csv. Invalid input header: #{row.class.name}")
+          end
 
           parse_line(row)
         end
@@ -23,7 +25,9 @@ module IOStreams
         def parse(row)
           return row if row.is_a?(::Array)
 
-          raise(IOStreams::Errors::TypeMismatch, "Format is :csv. Invalid input: #{row.class.name}") unless row.is_a?(String)
+          unless row.is_a?(String)
+            raise(IOStreams::Errors::TypeMismatch, "Format is :csv. Invalid input: #{row.class.name}")
+          end
 
           parse_line(row)
         end

data/lib/io_streams/tabular/parser/hash.rb

@@ -4,7 +4,10 @@ module IOStreams
     module Parser
       class Hash < Base
         def parse(row)
-          raise(IOStreams::Errors::TypeMismatch, "Format is :hash. Invalid input: #{row.class.name}") unless row.is_a?(::Hash)
+          unless row.is_a?(::Hash)
+            raise(IOStreams::Errors::TypeMismatch, "Format is :hash. Invalid input: #{row.class.name}")
+          end
+
           row
         end
 

data/lib/io_streams/tabular/parser/json.rb

@@ -7,7 +7,9 @@ module IOStreams
         def parse(row)
           return row if row.is_a?(::Hash)
 
-          raise(IOStreams::Errors::TypeMismatch, "Format is :json. Invalid input: #{row.class.name}") unless row.is_a?(String)
+          unless row.is_a?(String)
+            raise(IOStreams::Errors::TypeMismatch, "Format is :json. Invalid input: #{row.class.name}")
+          end
 
           JSON.parse(row)
         end

data/lib/io_streams/tabular/parser/psv.rb

@@ -19,7 +19,9 @@ module IOStreams
         def parse(row)
           return row if row.is_a?(::Array)
 
-          raise(IOStreams::Errors::TypeMismatch, "Format is :psv. Invalid input: #{row.class.name}") unless row.is_a?(String)
+          unless row.is_a?(String)
+            raise(IOStreams::Errors::TypeMismatch, "Format is :psv. Invalid input: #{row.class.name}")
+          end
 
           row.split('|')
         end

data/lib/io_streams/tabular/utility/csv_row.rb

@@ -24,10 +24,10 @@ module IOStreams
         #     A single line of CSV data without any line terminators
         def parse(line)
           return if IOStreams::Utils.blank?(line)
-          return if @skip_lines and @skip_lines.match line
+          return if @skip_lines&.match(line)
 
           in_extended_col = false
-          csv             = Array.new
+          csv             = []
           parts           = line.split(@col_sep, -1)
           csv << nil if parts.empty?
 
@@ -36,12 +36,13 @@ module IOStreams
           parts.each do |part|
             if in_extended_col
               # If we are continuing a previous column
-              if part[-1] == @quote_char && part.count(@quote_char) % 2 != 0
+              if part[-1] == @quote_char && part.count(@quote_char).odd?
                 # extended column ends
                 csv.last << part[0..-2]
                 if csv.last =~ @parsers[:stray_quote]
                   raise MalformedCSVError, "Missing or stray quote in line #{lineno + 1}"
                 end
+
                 csv.last.gsub!(@quote_char * 2, @quote_char)
                 in_extended_col = false
               else
@@ -50,7 +51,7 @@ module IOStreams
               end
             elsif part[0] == @quote_char
               # If we are starting a new quoted column
-              if part[-1] != @quote_char || part.count(@quote_char) % 2 != 0
+              if part[-1] != @quote_char || part.count(@quote_char).odd?
                 # start an extended column
                 csv << part[1..-1]
                 csv.last << @col_sep
@@ -61,6 +62,7 @@ module IOStreams
                 if csv.last =~ @parsers[:stray_quote]
                   raise MalformedCSVError, "Missing or stray quote in line #{lineno + 1}"
                 end
+
                 csv.last.gsub!(@quote_char * 2, @quote_char)
               end
             elsif part =~ @parsers[:quote_or_nl]
@@ -90,12 +92,12 @@ module IOStreams
           unconverted = csv.dup if @unconverted_fields
 
           # convert fields, if needed...
-          csv         = convert_fields(csv) unless @use_headers or @converters.empty?
+          csv         = convert_fields(csv) unless @use_headers || @converters.empty?
           # parse out header rows and handle CSV::Row conversions...
           csv         = parse_headers(csv) if @use_headers
 
           # inject unconverted fields and accessor, if requested...
-          if @unconverted_fields and not csv.respond_to? :unconverted_fields
+          if @unconverted_fields && (!csv.respond_to? :unconverted_fields)
             add_unconverted_fields(csv, unconverted)
           end
 
@@ -107,8 +109,7 @@ module IOStreams
           row.map(&@quote).join(@col_sep) + @row_sep # quote and separate
         end
 
-        alias_method :to_csv, :render
-
+        alias to_csv render
       end
     end
   end

data/lib/io_streams/utils.rb

@@ -1,5 +1,12 @@
 module IOStreams
   module Utils
+    # Lazy load dependent gem so that it remains a soft dependency.
+    def self.load_dependency(gem_name, stream_type, require_name = gem_name)
+      require require_name
+    rescue LoadError => e
+      raise(LoadError, "Please install the gem '#{gem_name}' to support #{stream_type}. #{e.message}")
+    end
+
     # Helper method: Returns [true|false] if a value is blank?
     def self.blank?(value)
       if value.nil?
@@ -10,5 +17,20 @@ module IOStreams
         value.respond_to?(:empty?) ? value.empty? : !value
       end
     end
+
+    # Yields the path to a temporary file_name.
+    #
+    # File is deleted upon completion if present.
+    def self.temp_file_name(basename, extension = '')
+      result = nil
+      ::Dir::Tmpname.create([basename, extension]) do |tmpname|
+        begin
+          result = yield(tmpname)
+        ensure
+          ::File.unlink(tmpname) if ::File.exist?(tmpname)
+        end
+      end
+      result
+    end
   end
 end

data/lib/io_streams/version.rb

@@ -1,3 +1,3 @@
 module IOStreams
-  VERSION = '0.20.3'
+  VERSION = "1.0.0.beta".freeze
 end

data/lib/io_streams/writer.rb

@@ -0,0 +1,28 @@
+module IOStreams
+  class Writer
+    # When a Writer does not support streams, we copy the stream to a local temp file
+    # and then pass that filename in for this reader.
+    def self.stream(output_stream, original_file_name: nil, **args, &block)
+      Utils.temp_file_name("iostreams_writer") do |file_name|
+        file(file_name, original_file_name: original_file_name, **args, &block)
+        ::File.open(file_name, 'rb') { |source| ::IO.copy_stream(source, output_stream) }
+      end
+    end
+
+    # When a Writer supports streams, also allow it to simply support a file
+    def self.file(file_name, original_file_name: file_name, **args, &block)
+      ::File.open(file_name, "wb") { |file| stream(file, original_file_name: original_file_name, **args, &block) }
+    end
+
+    # For processing by either a file name or an open IO stream.
+    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
+
+    attr_reader :output_stream
+
+    def initialize(output_stream)
+      @output_stream = output_stream
+    end
+  end
+end

data/lib/io_streams/xlsx/reader.rb

@@ -2,25 +2,13 @@ require 'csv'
 
 module IOStreams
   module Xlsx
-    class Reader
-      # Convert a xlsx, or xlsm file or stream into CSV format.
-      def self.open(file_name_or_io, _ = nil, &block)
-        return extract_csv(file_name_or_io, &block) if file_name_or_io.is_a?(String)
-
-        # Creek gem can only work against a file, not a stream, so create temp file.
-        IOStreams::File::Path.temp_file_name('iostreams_xlsx') do |temp_file_name|
-          IOStreams.copy(file_name_or_io, temp_file_name, target_options: {streams: []})
-          extract_csv(temp_file_name, &block)
-        end
-      end
-
-      # Convert the spreadsheet to csv in a tempfile
-      def self.extract_csv(file_name, &block)
-        IOStreams::File::Path.temp_file_name('iostreams_csv') do |temp_file_name|
-          IOStreams::File::Writer.open(temp_file_name) do |io|
-            new(file_name).each { |lines| io << lines.to_csv }
-          end
-          IOStreams::File::Reader.open(temp_file_name, &block)
+    class Reader < IOStreams::Reader
+      # Convert a xlsx, or xlsm file into CSV format.
+      def self.file(file_name, original_file_name: file_name, &block)
+        # Stream into a temp file as csv
+        Utils.temp_file_name('iostreams_csv') do |temp_file_name|
+          ::File.open(temp_file_name, 'wb') { |io| new(file_name).each { |lines| io << lines.to_csv } }
+          ::File.open(temp_file_name, 'rb', &block)
         end
       end
 

data/lib/io_streams/zip/reader.rb

@@ -1,6 +1,6 @@
 module IOStreams
   module Zip
-    class Reader
+    class Reader < IOStreams::Reader
       # Read from a zip file or stream, decompressing the contents as it is read
       # The input stream from the first file found in the zip file is passed
       # to the supplied block.
@@ -17,46 +17,27 @@ module IOStreams
       #       puts data
       #     end
       #   end
-      def self.open(file_name_or_io, entry_file_name: nil, &block)
-        # File name supplied
-        return read_file(file_name_or_io, entry_file_name, &block) unless IOStreams.reader_stream?(file_name_or_io)
-
-        # Ruby ZIP gem uses `#seek` so can only work against a file, not a stream, so create temp file.
-        # JRuby ZIP requires an InputStream.
-        IOStreams::File::Path.temp_file_name('iostreams_zip') do |temp_file_name|
-          IOStreams.copy(file_name_or_io, temp_file_name, target_options: {streams: []})
-          read_file(temp_file_name, entry_file_name, &block)
-        end
-      end
-
       if defined?(JRuby)
         # Java has built-in support for Zip files
-        def self.read_file(file_name, entry_file_name)
+        def self.file(file_name, entry_file_name: nil)
           fin = Java::JavaIo::FileInputStream.new(file_name)
           zin = Java::JavaUtilZip::ZipInputStream.new(fin)
 
           get_entry(zin, entry_file_name) ||
-            raise(Java::JavaUtilZip::ZipException.new("File #{entry_file_name} not found within zip file."))
+            raise(Java::JavaUtilZip::ZipException, "File #{entry_file_name} not found within zip file.")
 
           yield(zin.to_io)
         ensure
-          zin.close if zin
-          fin.close if fin
+          zin&.close
+          fin&.close
         end
 
       else
         # Read from a zip file or stream, decompressing the contents as it is read
         # The input stream from the first file found in the zip file is passed
         # to the supplied block
-        def self.read_file(file_name, entry_file_name)
-          if !defined?(::Zip)
-            # MRI needs Ruby Zip, since it only has native support for GZip
-            begin
-              require 'zip'
-            rescue LoadError => exc
-              raise(LoadError, "Install gem 'rubyzip' to read and write Zip files: #{exc.message}")
-            end
-          end
+        def self.file(file_name, entry_file_name: nil)
+          Utils.load_dependency('rubyzip', 'Zip', 'zip') unless defined?(::Zip)
 
           ::Zip::InputStream.open(file_name) do |zin|
             get_entry(zin, entry_file_name) ||

data/lib/io_streams/zip/writer.rb

@@ -1,14 +1,14 @@
 module IOStreams
   module Zip
-    class Writer
+    class Writer < IOStreams::Writer
       # Write a single file in Zip format to the supplied output file name
       #
       # Parameters
-      #   file_name_or_io [String]
-      #     Full path and filename for the output zip file
+      #   file_name [String]
+      #     Full path and filename for the output zip file.
       #
-      #   zip_file_name: [String]
-      #     Name of the file within the Zip Stream
+      #   entry_file_name: [String]
+      #     Name of the file entry within the Zip file.
       #
       # The stream supplied to the block only responds to #write
       #
@@ -21,57 +21,40 @@ module IOStreams
       # Notes:
       # - Since Zip cannot write to streams, if a stream is supplied, a temp file
       #   is automatically created under the covers
-      def self.open(file_name_or_io, zip_file_name: nil, buffer_size: 65536, &block)
+      def self.file(file_name, original_file_name: file_name, zip_file_name: nil, entry_file_name: zip_file_name, &block)
         # Default the name of the file within the zip to the supplied file_name without the zip extension
-        zip_file_name = file_name_or_io.to_s[0..-5] if zip_file_name.nil? && !IOStreams.writer_stream?(file_name_or_io) && (file_name_or_io =~ /\.(zip)\z/)
-        zip_file_name ||= 'file'
-
-        if !defined?(JRuby) && !defined?(::Zip)
-          # MRI needs Ruby Zip, since it only has native support for GZip
-          begin
-            require 'zip'
-          rescue LoadError => exc
-            raise(LoadError, "Install gem 'rubyzip' to read and write Zip files: #{exc.message}")
-          end
+        if entry_file_name.nil? && (original_file_name =~ /\.(zip)\z/i)
+          entry_file_name = original_file_name.to_s[0..-5]
         end
+        entry_file_name ||= 'file'
 
-        # File name supplied
-        return write_file(file_name_or_io, zip_file_name, &block) unless IOStreams.writer_stream?(file_name_or_io)
-
-        # ZIP can only work against a file, not a stream, so create temp file.
-        IOStreams::File::Path.temp_file_name('iostreams_zip') do |temp_file_name|
-          write_file(temp_file_name, zip_file_name, &block)
-          IOStreams.copy(temp_file_name, file_name_or_io, source_options: {streams: []})
-        end
+        write_file(file_name, entry_file_name, &block)
       end
 
       private
 
       if defined?(JRuby)
-
-        def self.write_file(file_name, zip_file_name, &block)
+        def self.write_file(file_name, entry_file_name)
           out  = Java::JavaIo::FileOutputStream.new(file_name)
           zout = Java::JavaUtilZip::ZipOutputStream.new(out)
-          zout.put_next_entry(Java::JavaUtilZip::ZipEntry.new(zip_file_name))
+          zout.put_next_entry(Java::JavaUtilZip::ZipEntry.new(entry_file_name))
           io = zout.to_io
-          block.call(io)
+          yield(io)
         ensure
-          io.close if io && !io.closed?
-          out.close if out
+          io&.close
+          out&.close
         end
-
       else
-        def self.write_file(file_name, zip_file_name, &block)
-          IOStreams::File::Path.mkpath(file_name)
+        def self.write_file(file_name, entry_file_name)
+          Utils.load_dependency('rubyzip', 'Zip', 'zip') unless defined?(::Zip)
+
           zos = ::Zip::OutputStream.new(file_name)
-          zos.put_next_entry(zip_file_name)
-          block.call(zos)
+          zos.put_next_entry(entry_file_name)
+          yield(zos)
         ensure
-          zos.close if zos
+          zos&.close
         end
-
       end
-
     end
   end
 end