iostreams 0.19.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 161967be051ed1b82c87f30afd32b760a2e6627cf8e090e978578c7c35aab278
-  data.tar.gz: abb7aab7f5aca8cc0d043ce3820603c86b3227c9db41d07420f3117010bf68af
+  metadata.gz: b16ce2bb98466540950ee6a40c9b3066630e99e7987c93621b3a175b5b027731
+  data.tar.gz: 6fb4dd208cc04a71d78ac1355f8035159a97b67f2a749dc922df3f6edf7208ac
 SHA512:
-  metadata.gz: 2172e682359bfe1240669fee5da16f807b5a04b940529c5a7046166d5343e7c80bd20c52f05243b59c72f7cfe57ac288603ac6475e75f413f8f99031f3e1cbd0
-  data.tar.gz: 76923520dfda93c00b4209424496c5324ae7975b59f0f8653578652b540c07a9dd6866890b72c147ab5c968e48879210e3aaa85ab8c8ffbe4b4921524352eb32
+  metadata.gz: e58da1ef631c0eae5574194e6586dbf7b52becc934a01a00ede0ef0f665d14f08391a5a2fee645bbe8ffe8fe8452c6d4b79eb84396f1e94e9b98ad9dea229041
+  data.tar.gz: d821299bb5742832125ff2b7a6826f68b734967ea7a5f5d94cf1b619ef3ad82dfd2c457455a5d62523ca52832f5d17b7c2f343f5f387f77abdbeaca6bff42dd7

data/lib/io_streams/base_path.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module IOStreams
+  class BasePath
+    attr_reader :path
+
+    def initialize(path)
+      @path = path.frozen? ? path : path.dup.freeze
+    end
+
+    # If elements already contains the current path then it is used as is without
+    # adding the current path for a second time
+    def join(*elements)
+      return self if elements.empty?
+
+      relative = ::File.join(*elements)
+      if relative.start_with?(path)
+        self.class.new(relative)
+      else
+        self.class.new(::File.join(path, relative))
+      end
+    end
+
+    def to_s
+      path
+    end
+
+    # Removes the last element of the path, the file name, before creating the entire path.
+    # Returns self
+    def mkpath
+      raise NotImplementedError
+    end
+
+    # Assumes the current path does not include a file name, and creates all elements in the path.
+    # Returns self
+    #
+    # Note: Do not call this method if the path contains a file name, see `#mkpath`
+    def mkdir
+      raise NotImplementedError
+    end
+
+    # Returns [true|false] whether the file exists
+    def exist?
+      raise NotImplementedError
+    end
+
+    # Returns [Integer] size of the file
+    def size
+      raise NotImplementedError
+    end
+
+    # Delete the file.
+    # Returns self
+    #
+    # Notes:
+    # * No error is raised if the file is not present.
+    # * Only the file is removed, not any of the parent paths.
+    def delete
+      raise NotImplementedError
+    end
+
+    # Return a reader for this path
+    def reader(**args, &block)
+      IOStreams.reader(path, **args, &block)
+    end
+
+    # Return a writer for this path
+    def writer(**args, &block)
+      IOStreams.writer(path, **args, &block)
+    end
+
+  end
+end

data/lib/io_streams/file/path.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'fileutils'
+
+module IOStreams
+  module File
+    class Path < IOStreams::BasePath
+      # 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
+
+      # Used by writers that can write directly to file to create the target path
+      def self.mkpath(path)
+        dir = ::File.dirname(path)
+        FileUtils.mkdir_p(dir) unless ::File.exist?(dir)
+      end
+
+      def mkpath
+        self.class.mkpath(path)
+        self
+      end
+
+      def mkdir
+        FileUtils.mkdir_p(path) unless ::File.exist?(path)
+        self
+      end
+
+      def exist?
+        ::File.exist?(path)
+      end
+
+      def size
+        ::File.size(path)
+      end
+
+      def delete(recursively: false)
+        return self unless ::File.exist?(path)
+
+        if ::File.directory?(path)
+          recursively ? FileUtils.remove_dir(path) : Dir.delete(path)
+        else
+          ::File.unlink(path)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/io_streams/file/writer.rb

@@ -9,7 +9,7 @@ module IOStreams
       def self.open(file_name, **args, &block)
         raise(ArgumentError, 'File name must be a string') unless file_name.is_a?(String)
 
-        IOStreams.mkpath(file_name)
+        IOStreams::File::Path.mkpath(file_name)
         begin
           ::File.open(file_name, 'wb', &block)
         rescue StandardError => e

data/lib/io_streams/gzip/writer.rb

@@ -4,7 +4,7 @@ module IOStreams
       # Write to a file / stream, compressing with GZip
       def self.open(file_name_or_io, **args, &block)
         unless IOStreams.writer_stream?(file_name_or_io)
-          IOStreams.mkpath(file_name_or_io)
+          IOStreams::File::Path.mkpath(file_name_or_io)
           Zlib::GzipWriter.open(file_name_or_io, &block)
         else
           begin

data/lib/io_streams/http/reader.rb

@@ -55,7 +55,7 @@ module IOStreams
             raise(IOStreams::Errors::CommunicationsFailure, "Invalid response code: #{response.code}") unless response.is_a?(Net::HTTPSuccess)
 
             # Since Net::HTTP download only supports a push stream, write it to a tempfile first.
-            IOStreams::Path.temp_file_name('iostreams_http') do |file_name|
+            IOStreams::File::Path.temp_file_name('iostreams_http') do |file_name|
               IOStreams::File::Writer.open(file_name) do |io|
                 response.read_body { |chunk| io.write(chunk) }
               end

data/lib/io_streams/io_streams.rb

@@ -425,7 +425,52 @@ module IOStreams
     end
   end
 
-  Extension = Struct.new(:reader_class, :writer_class)
+  # Return the complete path including supplied elements.
+  #
+  # Example:
+  #    IOStreams.path('sample')
+  #    # => "/default_root/sample"
+  #
+  #    IOStreams.path('file.xls')
+  #    # => "/default_root/file.xls"
+  #
+  #    IOStreams.path('sample', root: :ftp)
+  #    # => "/ftp_root/sample"
+  #
+  #    IOStreams.path('sample', 'file.xls', root: :ftp)
+  #    # => "/ftp_root/sample/file.xls"
+  #
+  # Notes:
+  # * Add the root path first against which this path is permitted to operate.
+  #     `IOStreams.add_root_path(:default, "/usr/local/var/files")`
+  def self.path(*elements, root: :default)
+    root_path(root).join(*elements)
+  end
+
+  # When using a full path, without needing the root prefixed.
+  def self.full_path(*elements)
+    path = ::File.join(*elements)
+    uri  = URI.parse(path)
+    IOStreams.scheme(uri.scheme).path_class.new(path)
+  end
+
+  # Return named root path
+  def self.root_path(root = :default)
+    @roots_paths[root.to_sym] || raise(ArgumentError, "Unknown root: #{root.inspect}")
+  end
+
+  # Add a named root path
+  def self.add_root_path(root, path)
+    raise(ArgumentError, "Invalid root name #{root.inspect}") unless root.to_s =~ /\A\w+\Z/
+
+    uri                       = URI.parse(path.to_s)
+    path_class                = IOStreams.scheme(uri.scheme).path_class
+    @roots_paths[root.to_sym] = path_class.new(path)
+  end
+
+  def self.root_paths
+    @roots_paths.dup
+  end
 
   # Register a file extension and the reader and writer streaming classes
   #
@@ -453,34 +498,23 @@ module IOStreams
   # Example:
   #   # MyXls::Reader and MyXls::Writer must implement .open
   #   register_extension(:xls, MyXls::Reader, MyXls::Writer)
-  def self.register_scheme(scheme, reader_class, writer_class)
+  def self.register_scheme(scheme, reader_class, writer_class, path_class = nil)
     raise(ArgumentError, "Invalid scheme #{scheme.inspect}") unless scheme.nil? || scheme.to_s =~ /\A\w+\Z/
-    @schemes[scheme.nil? ? nil : scheme.to_sym] = Extension.new(reader_class, writer_class)
-  end
-
-  # Helper method: Returns [true|false] if a value is blank?
-  def self.blank?(value)
-    if value.nil?
-      true
-    elsif value.is_a?(String)
-      value !~ /\S/
-    else
-      value.respond_to?(:empty?) ? value.empty? : !value
-    end
-  end
-
-  # Used by writers that can write directly to file to create the target path
-  def self.mkpath(file_name)
-    path = ::File.dirname(file_name)
-    FileUtils.mkdir_p(path) unless ::File.exist?(path)
+    @schemes[scheme.nil? ? nil : scheme.to_sym] = Scheme.new(reader_class, writer_class, path_class)
   end
 
   private
 
+  # Hold root paths
+  @roots_paths = {}
+
   # A registry to hold formats for processing files during upload or download
   @extensions = {}
   @schemes    = {}
 
+  Extension = Struct.new(:reader_class, :writer_class)
+  Scheme    = Struct.new(:reader_class, :writer_class, :path_class)
+
   # Struct to hold the Stream and options if any
   StreamStruct = Struct.new(:klass, :options)
 
@@ -556,9 +590,12 @@ module IOStreams
     StreamStruct.new(klass, options)
   end
 
-  def self.stream_struct_for_scheme(type, scheme, options = {})
-    ext   = @schemes[scheme.nil? ? nil : scheme.to_sym] || raise(ArgumentError, "Unknown Scheme type: #{scheme.inspect}")
-    klass = ext.send("#{type}_class")
+  def self.scheme(scheme_name)
+    @schemes[scheme_name.nil? ? nil : scheme_name.to_sym] || raise(ArgumentError, "Unknown Scheme type: #{scheme_name.inspect}")
+  end
+
+  def self.stream_struct_for_scheme(type, scheme_name, options = {})
+    klass = scheme(scheme_name).send("#{type}_class")
     StreamStruct.new(klass, options)
   end
 
@@ -584,9 +621,9 @@ module IOStreams
   #    https://hostname/path/file_name
   #    sftp://hostname/path/file_name
   #    s3://bucket/key
-  register_scheme(nil, IOStreams::File::Reader, IOStreams::File::Writer)
-  register_scheme(:http,  IOStreams::HTTP::Reader,  nil)
+  register_scheme(nil, IOStreams::File::Reader, IOStreams::File::Writer, IOStreams::File::Path)
+  register_scheme(:http, IOStreams::HTTP::Reader, nil)
   register_scheme(:https, IOStreams::HTTP::Reader, nil)
-  # register_scheme(:sftp,  IOStreams::SFTP::Reader,  IOStreams::SFTP::Writer)
-  register_scheme(:s3, IOStreams::S3::Reader, IOStreams::S3::Writer)
+  register_scheme(:sftp, IOStreams::SFTP::Reader, IOStreams::SFTP::Writer)
+  register_scheme(:s3, IOStreams::S3::Reader, IOStreams::S3::Writer, IOStreams::S3::Path)
 end

data/lib/io_streams/line/reader.rb

@@ -57,10 +57,11 @@ module IOStreams
         @eof               = false
         @read_cache_buffer = nil
         @buffer            = nil
+        @delimiter         = delimiter
 
         read_block
         # Auto-detect windows/linux line endings if not supplied. \n or \r\n
-        @delimiter = delimiter || auto_detect_line_endings
+        @delimiter ||= auto_detect_line_endings
 
         if @buffer
           # Change the delimiters encoding to match that of the input stream

data/lib/io_streams/pgp/reader.rb

@@ -14,31 +14,37 @@ module IOStreams
       #   Or, the IO stream to receive the decrypted contents
       # passphrase: [String]
       #   Pass phrase for private key to decrypt the file with
-      def self.open(file_name_or_io, passphrase: self.default_passphrase, binary: true)
+      def self.open(file_name_or_io, passphrase: self.default_passphrase, binary: true, &block)
         raise(ArgumentError, 'Missing both passphrase and IOStreams::Pgp::Reader.default_passphrase') unless passphrase
 
-        if IOStreams.reader_stream?(file_name_or_io)
-          raise(NotImplementedError, 'Can only PGP Decrypt directly from a file name. Input streams are not yet supported.')
-        else
-          loopback = IOStreams::Pgp.pgp_version.to_f >= 2.1 ? '--pinentry-mode loopback' : ''
-          command  = "#{IOStreams::Pgp.executable} #{loopback} --batch --no-tty --yes --decrypt --passphrase-fd 0 #{file_name_or_io}"
-          IOStreams::Pgp.logger.debug { "IOStreams::Pgp::Reader.open: #{command}" } if IOStreams::Pgp.logger
-
-          # Read decrypted contents from stdout
-          Open3.popen3(command) do |stdin, stdout, stderr, waith_thr|
-            stdin.puts(passphrase) if passphrase
-            stdin.close
-            result =
-              begin
-                stdout.binmode if binary
-                yield(stdout)
-              rescue Errno::EPIPE
-                # Ignore broken pipe because gpg terminates early due to an error
-                raise(Pgp::Failure, "GPG Failed reading from encrypted file: #{file_name_or_io}: #{stderr.read.chomp}")
-              end
-            raise(Pgp::Failure, "GPG Failed to decrypt file: #{file_name_or_io}: #{stderr.read.chomp}") unless waith_thr.value.success?
-            result
-          end
+        return read_file(file_name_or_io, passphrase: passphrase, binary: binary, &block) if file_name_or_io.is_a?(String)
+
+        # PGP can only work against a file, not a stream, so create temp file.
+        IOStreams::File::Path.temp_file_name('iostreams_pgp') do |temp_file_name|
+          IOStreams.copy(file_name_or_io, temp_file_name, target_options: {streams: []})
+          read_file(temp_file_name, passphrase: passphrase, binary: binary, &block)
+        end
+      end
+
+      def self.read_file(file_name, passphrase: self.default_passphrase, binary: true)
+        loopback = IOStreams::Pgp.pgp_version.to_f >= 2.1 ? '--pinentry-mode loopback' : ''
+        command  = "#{IOStreams::Pgp.executable} #{loopback} --batch --no-tty --yes --decrypt --passphrase-fd 0 #{file_name}"
+        IOStreams::Pgp.logger.debug { "IOStreams::Pgp::Reader.open: #{command}" } if IOStreams::Pgp.logger
+
+        # Read decrypted contents from stdout
+        Open3.popen3(command) do |stdin, stdout, stderr, waith_thr|
+          stdin.puts(passphrase) if passphrase
+          stdin.close
+          result =
+            begin
+              stdout.binmode if binary
+              yield(stdout)
+            rescue Errno::EPIPE
+              # Ignore broken pipe because gpg terminates early due to an error
+              raise(Pgp::Failure, "GPG Failed reading from encrypted file: #{file_name}: #{stderr.read.chomp}")
+            end
+          raise(Pgp::Failure, "GPG Failed to decrypt file: #{file_name}: #{stderr.read.chomp}") unless waith_thr.value.success?
+          result
         end
       end
 

data/lib/io_streams/pgp/writer.rb

@@ -45,13 +45,22 @@ module IOStreams
       # compress_level: [Integer]
       #   Compression level
       #   Default: 6
-      def self.open(file_name, recipient:, signer: default_signer, signer_passphrase: default_signer_passphrase, binary: true, compression: :zip, compress_level: 6)
+      def self.open(file_name_or_io, recipient:, signer: default_signer, signer_passphrase: default_signer_passphrase, binary: true, compression: :zip, compress_level: 6, &block)
         compress_level = 0 if compression == :none
-        if IOStreams.writer_stream?(file_name)
-          raise(NotImplementedError, 'Can only PGP Encrypt directly to a file name. Output to streams are not yet supported.')
+
+        if file_name_or_io.is_a?(String)
+          IOStreams::File::Path.mkpath(file_name_or_io)
+          return write_file(file_name_or_io, recipient: recipient, signer: signer, signer_passphrase: signer_passphrase, binary: binary, compression: compression, compress_level: compress_level, &block)
+        end
+
+        # PGP can only work against a file, not a stream, so create temp file.
+        IOStreams::File::Path.temp_file_name('iostreams_pgp') do |temp_file_name|
+          write_file(temp_file_name, recipient: recipient, signer: signer, signer_passphrase: signer_passphrase, binary: binary, compression: compression, compress_level: compress_level, &block)
+          IOStreams.copy(temp_file_name, file_name_or_io, source_options: {streams: []})
         end
-        IOStreams.mkpath(file_name)
+      end
 
+      def self.write_file(file_name, recipient:, signer: default_signer, signer_passphrase: default_signer_passphrase, binary: true, compression: :zip, compress_level: 6)
         # Write to stdin, with encrypted contents being written to the file
         command = "#{IOStreams::Pgp.executable} --batch --no-tty --yes --encrypt"
         command << " --sign --local-user \"#{signer}\"" if signer

data/lib/io_streams/s3/path.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module IOStreams
+  module S3
+    class Path < IOStreams::BasePath
+      def initialize(path)
+        IOStreams::S3.load_dependencies
+        @s3      = Aws::S3::Resource.new
+        @options = IOStreams::S3.parse_uri(path)
+        @object  = s3.bucket(options[:bucket]).object(options[:key])
+        super(path)
+      end
+
+      # S3 logically creates paths when a key is set.
+      def mkpath
+        self
+      end
+
+      def mkdir
+        self
+      end
+
+      def exist?
+        object.exists?
+      end
+
+      def size
+        object.size
+      end
+
+      def delete
+        object.delete
+        self
+      end
+
+      private
+
+      attr_reader :s3, :options, :object
+    end
+  end
+end

data/lib/io_streams/s3/reader.rb

@@ -7,13 +7,14 @@ module IOStreams
 
         IOStreams::S3.load_dependencies
 
+        # https://aws.amazon.com/blogs/developer/using-resources/
         s3      = region.nil? ? Aws::S3::Resource.new : Aws::S3::Resource.new(region: region)
         options = IOStreams::S3.parse_uri(uri)
         object  = s3.bucket(options[:bucket]).object(options[:key])
 
         begin
           # Since S3 download only supports a push stream, write it to a tempfile first.
-          IOStreams::Path.temp_file_name('iostreams_s3') do |file_name|
+          IOStreams::File::Path.temp_file_name('iostreams_s3') do |file_name|
             args[:response_target] = file_name
             object.get(args)
 

data/lib/io_streams/s3.rb

@@ -1,6 +1,7 @@
 require 'uri'
 module IOStreams
   module S3
+    autoload :Path, 'io_streams/s3/path'
     autoload :Reader, 'io_streams/s3/reader'
     autoload :Writer, 'io_streams/s3/writer'
 

data/lib/io_streams/tabular/header.rb

@@ -86,7 +86,7 @@ module IOStreams
       #     Only Applies to when the hash is already a Hash.
       #     Useful to turn off narrowing when the input data is already trusted.
       def to_hash(row, cleanse = true)
-        return if IOStreams.blank?(row)
+        return if IOStreams::Utils.blank?(row)
 
         case row
         when Array
@@ -112,7 +112,7 @@ module IOStreams
 
       def array_to_hash(row)
         h = {}
-        columns.each_with_index { |col, i| h[col] = row[i] unless IOStreams.blank?(col) }
+        columns.each_with_index { |col, i| h[col] = row[i] unless IOStreams::Utils.blank?(col) }
         h
       end
 

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

@@ -40,7 +40,7 @@ module IOStreams
           # About 10 times slower than the approach used in Ruby 2.5 and earlier,
           # but at least it works on Ruby 2.6 and above.
           def parse_line(line)
-            return if IOStreams.blank?(line)
+            return if IOStreams::Utils.blank?(line)
 
             CSV.parse_line(line)
           end

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

@@ -23,7 +23,7 @@ module IOStreams
         #   line [String]
         #     A single line of CSV data without any line terminators
         def parse(line)
-          return if IOStreams.blank?(line)
+          return if IOStreams::Utils.blank?(line)
           return if @skip_lines and @skip_lines.match line
 
           in_extended_col = false

data/lib/io_streams/tabular.rb

@@ -66,7 +66,7 @@ module IOStreams
 
     # Returns [true|false] whether a header is still required in order to parse or render the current format.
     def header?
-      parser.requires_header? && IOStreams.blank?(header.columns)
+      parser.requires_header? && IOStreams::Utils.blank?(header.columns)
     end
 
     # Returns [true|false] whether a header row show be rendered on output.
@@ -81,7 +81,7 @@ module IOStreams
     # * Call `header?` first to determine if the header should be parsed first.
     # * The header columns are set after parsing the row, but the header is not cleansed.
     def parse_header(line)
-      return if IOStreams.blank?(line) || !parser.requires_header?
+      return if IOStreams::Utils.blank?(line) || !parser.requires_header?
 
       header.columns = parser.parse(line)
     end
@@ -96,14 +96,14 @@ module IOStreams
     # Returns [Array] the row/line as a parsed Array of values.
     # Returns nil if the row/line is blank.
     def row_parse(line)
-      return if IOStreams.blank?(line)
+      return if IOStreams::Utils.blank?(line)
 
       parser.parse(line)
     end
 
     # Renders the output row
     def render(row)
-      return if IOStreams.blank?(row)
+      return if IOStreams::Utils.blank?(row)
 
       parser.render(row, header)
     end
@@ -113,7 +113,7 @@ module IOStreams
     def render_header
       return unless requires_header?
 
-      if IOStreams.blank?(header.columns)
+      if IOStreams::Utils.blank?(header.columns)
         raise(Errors::MissingHeader, "Header columns must be set before attempting to render a header for format: #{format.inspect}")
       end
 

data/lib/io_streams/utils.rb

@@ -0,0 +1,14 @@
+module IOStreams
+  module Utils
+    # Helper method: Returns [true|false] if a value is blank?
+    def self.blank?(value)
+      if value.nil?
+        true
+      elsif value.is_a?(String)
+        value !~ /\S/
+      else
+        value.respond_to?(:empty?) ? value.empty? : !value
+      end
+    end
+  end
+end

data/lib/io_streams/version.rb

@@ -1,3 +1,3 @@
 module IOStreams
-  VERSION = '0.19.0'
+  VERSION = '0.20.0'
 end

data/lib/io_streams/xlsx/reader.rb

@@ -8,7 +8,7 @@ module IOStreams
         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::Path.temp_file_name('iostreams_xlsx') do |temp_file_name|
+        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
@@ -16,7 +16,7 @@ module IOStreams
 
       # Convert the spreadsheet to csv in a tempfile
       def self.extract_csv(file_name, &block)
-        IOStreams::Path.temp_file_name('iostreams_csv') do |temp_file_name|
+        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

data/lib/io_streams/zip/reader.rb

@@ -26,7 +26,7 @@ module IOStreams
         return read_file(file_name_or_io, &block) unless IOStreams.reader_stream?(file_name_or_io)
 
         # ZIP can only work against a file, not a stream, so create temp file.
-        IOStreams::Path.temp_file_name('iostreams_zip') do |temp_file_name|
+        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, &block)
         end

data/lib/io_streams/zip/writer.rb

@@ -39,7 +39,7 @@ module IOStreams
         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::Path.temp_file_name('iostreams_zip') do |temp_file_name|
+        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
@@ -62,7 +62,7 @@ module IOStreams
 
       else
         def self.write_file(file_name, zip_file_name, &block)
-          IOStreams.mkpath(file_name)
+          IOStreams::File::Path.mkpath(file_name)
           zos = ::Zip::OutputStream.new(file_name)
           zos.put_next_entry(zip_file_name)
           block.call(zos)

data/lib/iostreams.rb

@@ -1,13 +1,23 @@
 require 'io_streams/version'
 #@formatter:off
 module IOStreams
-  autoload :Errors,  'io_streams/errors'
+  autoload :BasePath, 'io_streams/base_path'
+  autoload :Errors,   'io_streams/errors'
+  autoload :Pgp,      'io_streams/pgp'
+  autoload :S3,       'io_streams/s3'
+  autoload :Tabular,  'io_streams/tabular'
+  autoload :Utils,    'io_streams/utils'
 
   module Bzip2
     autoload :Reader, 'io_streams/bzip2/reader'
     autoload :Writer, 'io_streams/bzip2/writer'
   end
+  module Encode
+    autoload :Reader, 'io_streams/encode/reader'
+    autoload :Writer, 'io_streams/encode/writer'
+  end
   module File
+    autoload :Path,   'io_streams/file/path'
     autoload :Reader, 'io_streams/file/reader'
     autoload :Writer, 'io_streams/file/writer'
   end
@@ -18,22 +28,6 @@ module IOStreams
   module HTTP
     autoload :Reader, 'io_streams/http/reader'
   end
-  autoload :Path,     'io_streams/path'
-  autoload :Pgp,      'io_streams/pgp'
-  autoload :S3,       'io_streams/s3'
-  module SFTP
-    autoload :Reader, 'io_streams/sftp/reader'
-    autoload :Writer, 'io_streams/sftp/writer'
-  end
-  module Zip
-    autoload :Reader, 'io_streams/zip/reader'
-    autoload :Writer, 'io_streams/zip/writer'
-  end
-
-  module Encode
-    autoload :Reader, 'io_streams/encode/reader'
-    autoload :Writer, 'io_streams/encode/writer'
-  end
   module Line
     autoload :Reader, 'io_streams/line/reader'
     autoload :Writer, 'io_streams/line/writer'
@@ -46,6 +40,10 @@ module IOStreams
     autoload :Reader, 'io_streams/row/reader'
     autoload :Writer, 'io_streams/row/writer'
   end
+  module SFTP
+    autoload :Reader, 'io_streams/sftp/reader'
+    autoload :Writer, 'io_streams/sftp/writer'
+  end
   module SymmetricEncryption
     autoload :Reader, 'io_streams/symmetric_encryption/reader'
     autoload :Writer, 'io_streams/symmetric_encryption/writer'
@@ -53,7 +51,9 @@ module IOStreams
   module Xlsx
     autoload :Reader, 'io_streams/xlsx/reader'
   end
-
-  autoload :Tabular, 'io_streams/tabular'
+  module Zip
+    autoload :Reader, 'io_streams/zip/reader'
+    autoload :Writer, 'io_streams/zip/writer'
+  end
 end
 require 'io_streams/io_streams'

data/test/base_path_test.rb

@@ -0,0 +1,35 @@
+require_relative 'test_helper'
+
+module IOStreams
+  class BasePathTest < Minitest::Test
+    describe IOStreams::BasePath do
+      describe '.join' do
+        let(:path) { IOStreams::BasePath.new('some_path') }
+
+        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
+        end
+
+        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
+        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
+        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
+        end
+      end
+    end
+  end
+end

data/test/file_path_test.rb

@@ -0,0 +1,97 @@
+require_relative 'test_helper'
+
+module IOStreams
+  class FilePathTest < Minitest::Test
+    describe IOStreams::File::Path do
+      let(:path) { IOStreams::File::Path.new('/tmp/iostreams/some_test_path').delete(recursively: true) }
+      let(:path_with_file_name) { IOStreams::File::Path.new('/tmp/iostreams/some_test_path/test_file.txt').delete }
+
+      describe '.temp_file_name' do
+        it 'returns value from block' do
+          result = IOStreams::File::Path.temp_file_name('base', '.ext') { |name| 257 }
+          assert_equal 257, result
+        end
+
+        it 'supplies new temp file_name' do
+          file_name = nil
+          file_name2 = nil
+          IOStreams::File::Path.temp_file_name('base', '.ext') { |name| file_name = name }
+          IOStreams::File::Path.temp_file_name('base', '.ext') { |name| file_name2 = name }
+          refute_equal file_name, file_name2
+        end
+      end
+
+      describe '.mkpath' do
+        it 'makes path skipping file_name' do
+          new_path = path.join('test_mkpath.xls')
+          IOStreams::File::Path.mkpath(new_path.to_s)
+
+          assert ::File.exist?(path.to_s)
+          refute ::File.exist?(new_path.to_s)
+        end
+      end
+
+      describe '#mkpath' do
+        it 'makes path skipping file_name' do
+          #path.writer { |io| io << "Hello World" }
+          new_path = path.join('test_mkpath.xls').mkpath
+          assert ::File.exist?(path.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 = path.join('more_path').mkdir
+          assert ::File.exist?(path.to_s)
+          assert ::File.exist?(new_path.to_s)
+        end
+      end
+
+      describe '#exist?' do
+        it 'true on existing file' do
+          new_path = path.join('test_exist.txt')
+          new_path.writer { |io| io << "Hello World" }
+          assert ::File.exist?(path.to_s)
+          assert ::File.exist?(new_path.to_s)
+        end
+      end
+
+      describe '#size' do
+        it 'of file' do
+          data = "Hello World"
+          path_with_file_name.writer { |io| io << data }
+          assert_equal data.size, path_with_file_name.size
+        end
+      end
+
+      describe '#delete' do
+        it 'deletes existing file' do
+          path_with_file_name.writer { |io| io << "Hello World" }
+          assert ::File.exist?(path_with_file_name.to_s)
+          path_with_file_name.delete
+          refute ::File.exist?(path_with_file_name.to_s)
+        end
+
+        it 'ignores missing file' do
+          path_with_file_name.delete
+          path_with_file_name.delete
+        end
+      end
+
+      describe 'reader' do
+        it 'reads file' do
+          path_with_file_name.writer { |io| io << "Hello World" }
+          assert_equal "Hello World", path_with_file_name.reader(&:read)
+        end
+      end
+
+      describe 'writer' do
+        it 'creates file' do
+          path_with_file_name.writer { |io| io << "Hello World" }
+          assert ::File.exist?(path_with_file_name.to_s)
+        end
+      end
+    end
+  end
+end

data/test/path_test.rb

@@ -2,73 +2,52 @@ require_relative 'test_helper'
 
 module IOStreams
   class PathTest < Minitest::Test
-    describe IOStreams::Path do
-      describe '.root' do
+    describe IOStreams do
+      describe '.root_path' do
         it 'return default path' do
           path = ::File.expand_path(::File.join(__dir__, '../tmp/default'))
-          assert_equal path, IOStreams::Path[:default]
+          assert_equal path, IOStreams.root_path.to_s
         end
 
         it 'return downloads path' do
           path = ::File.expand_path(::File.join(__dir__, '../tmp/downloads'))
-          assert_equal path, IOStreams::Path[:downloads]
+          assert_equal path, IOStreams.root_path(:downloads).to_s
         end
       end
 
-      describe '.to_s' do
+      describe '.path' do
         it 'returns path' do
-          assert_equal IOStreams::Path[:default], IOStreams::Path.new.to_s
+          assert_equal IOStreams.root_path.to_s, IOStreams.path.to_s
         end
 
         it 'adds path to root' do
-          assert_equal ::File.join(IOStreams::Path[:default], 'test'), IOStreams::Path.new('test').to_s
+          assert_equal ::File.join(IOStreams.root_path.to_s, 'test'), IOStreams.path('test').to_s
         end
 
         it 'adds paths to root' do
-          assert_equal ::File.join(IOStreams::Path[:default], 'test', 'second', 'third'), IOStreams::Path.new('test', 'second', 'third').to_s
+          assert_equal ::File.join(IOStreams.root_path.to_s, 'test', 'second', 'third'), IOStreams.path('test', 'second', 'third').to_s
         end
 
         it 'returns path and filename' do
-          path = ::File.join(IOStreams::Path[:default], 'file.xls')
-          assert_equal path, IOStreams::Path.new('file.xls').to_s
+          path = ::File.join(IOStreams.root_path.to_s, 'file.xls')
+          assert_equal path, IOStreams.path('file.xls').to_s
         end
 
         it 'adds path to root and filename' do
-          path = ::File.join(IOStreams::Path[:default], 'test', 'file.xls')
-          assert_equal path, IOStreams::Path.new('test', 'file.xls').to_s
+          path = ::File.join(IOStreams.root_path.to_s, 'test', 'file.xls')
+          assert_equal path, IOStreams.path('test', 'file.xls').to_s
         end
 
         it 'adds paths to root' do
-          path = ::File.join(IOStreams::Path[:default], 'test', 'second', 'third', 'file.xls')
-          assert_equal path, IOStreams::Path.new('test', 'second', 'third', 'file.xls').to_s
+          path = ::File.join(IOStreams.root_path.to_s, 'test', 'second', 'third', 'file.xls')
+          assert_equal path, IOStreams.path('test', 'second', 'third', 'file.xls').to_s
         end
 
         it 'return path as sent in when full path' do
-          path = ::File.join(IOStreams::Path[:default], 'file.xls')
-          assert_equal path, IOStreams::Path.new(path).to_s
+          path = ::File.join(IOStreams.root_path.to_s, 'file.xls')
+          assert_equal path, IOStreams.path(path).to_s
         end
       end
-
-      describe '.mkpath' do
-        it 'makes root' do
-          path = IOStreams::Path.new('test.xls')
-          assert_equal path, path.mkpath
-          assert ::File.exist?(IOStreams::Path.new.to_s)
-        end
-
-        it 'makes root with path' do
-          path = IOStreams::Path.new('test', 'test.xls')
-          assert_equal path, path.mkpath
-          assert ::File.exist?(IOStreams::Path.new('test').to_s)
-        end
-
-        it 'makes root with paths' do
-          path = IOStreams::Path.new('test', 'second', 'third', 'test.xls')
-          assert_equal path, path.mkpath
-          assert ::File.exist?(IOStreams::Path.new('test', 'second', 'third').to_s)
-        end
-      end
-
     end
   end
 end

data/test/pgp_reader_test.rb

@@ -31,11 +31,15 @@ class PgpReaderTest < Minitest::Test
         end
       end
 
-      it 'fails with stream input' do
-        io = StringIO.new
-        assert_raises NotImplementedError do
-          IOStreams::Pgp::Reader.open(io, passphrase: 'BAD') { |file| file.read }
+      it 'streams input' do
+        IOStreams::Pgp::Writer.open(temp_file.path, recipient: 'receiver@example.org') do |io|
+          io.write(decrypted)
         end
+
+        encrypted = IOStreams::File::Reader.open(temp_file.path, &:read)
+        io        = StringIO.new(encrypted)
+        result = IOStreams::Pgp::Reader.open(io, passphrase: 'receiver_passphrase', &:read)
+        assert_equal decrypted, result
       end
 
     end

data/test/pgp_writer_test.rb

@@ -25,7 +25,7 @@ class PgpWriterTest < Minitest::Test
           io.write(decrypted)
         end
 
-        result = IOStreams::Pgp::Reader.open(file_name, passphrase: 'receiver_passphrase', binary: false) { |file| file.read }
+        result = IOStreams::Pgp::Reader.open(file_name, passphrase: 'receiver_passphrase', binary: false, &:read)
         assert_equal decrypted, result
       end
 
@@ -39,7 +39,7 @@ class PgpWriterTest < Minitest::Test
           end
         end
 
-        result = IOStreams::Pgp::Reader.open(file_name, passphrase: 'receiver_passphrase') { |file| file.read }
+        result = IOStreams::Pgp::Reader.open(file_name, passphrase: 'receiver_passphrase', &:read)
         assert_equal binary_data, result
       end
 
@@ -48,7 +48,7 @@ class PgpWriterTest < Minitest::Test
           io.write(decrypted)
         end
 
-        result = IOStreams::Pgp::Reader.open(file_name, passphrase: 'receiver_passphrase') { |file| file.read }
+        result = IOStreams::Pgp::Reader.open(file_name, passphrase: 'receiver_passphrase', &:read)
         assert_equal decrypted, result
       end
 
@@ -80,14 +80,17 @@ class PgpWriterTest < Minitest::Test
         end
       end
 
-      it 'fails with stream output' do
-        string_io = StringIO.new
-        assert_raises NotImplementedError do
-          IOStreams::Pgp::Writer.open(string_io, recipient: 'receiver@example.org') do |io|
-            io.write(decrypted)
-          end
+      it 'writes to a stream' do
+        io_string = StringIO.new(''.b)
+        IOStreams::Pgp::Writer.open(io_string, recipient: 'receiver@example.org', signer: 'sender@example.org', signer_passphrase: 'sender_passphrase') do |io|
+          io.write(decrypted)
         end
+
+        io     = StringIO.new(io_string.string)
+        result = IOStreams::Pgp::Reader.open(io, passphrase: 'receiver_passphrase', &:read)
+        assert_equal decrypted, result
       end
+
     end
   end
 end

data/test/test_helper.rb

@@ -35,5 +35,5 @@ end
 
 # Test paths
 root = File.expand_path(File.join(__dir__, '../tmp'))
-IOStreams::Path.add_root(:default, File.join(root, 'default'))
-IOStreams::Path.add_root(:downloads, File.join(root, 'downloads'))
+IOStreams.add_root_path(:default, File.join(root, 'default'))
+IOStreams.add_root_path(:downloads, File.join(root, 'downloads'))

data/test/xlsx_reader_test.rb

@@ -17,7 +17,6 @@ class XlsxReaderTest
     describe '.open' do
       describe 'with a file path' do
         it 'returns the contents of the file' do
-          rows = []
           csv  = IOStreams::Xlsx::Reader.open(file_name, &:read)
           assert_equal xlsx_contents, CSV.parse(csv)
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iostreams
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-22 00:00:00.000000000 Z
+date: 2019-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -34,11 +34,13 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- lib/io_streams/base_path.rb
 - lib/io_streams/bzip2/reader.rb
 - lib/io_streams/bzip2/writer.rb
 - lib/io_streams/encode/reader.rb
 - lib/io_streams/encode/writer.rb
 - lib/io_streams/errors.rb
+- lib/io_streams/file/path.rb
 - lib/io_streams/file/reader.rb
 - lib/io_streams/file/writer.rb
 - lib/io_streams/gzip/reader.rb
@@ -47,7 +49,6 @@ files:
 - lib/io_streams/io_streams.rb
 - lib/io_streams/line/reader.rb
 - lib/io_streams/line/writer.rb
-- lib/io_streams/path.rb
 - lib/io_streams/pgp.rb
 - lib/io_streams/pgp/reader.rb
 - lib/io_streams/pgp/writer.rb
@@ -56,6 +57,7 @@ files:
 - lib/io_streams/row/reader.rb
 - lib/io_streams/row/writer.rb
 - lib/io_streams/s3.rb
+- lib/io_streams/s3/path.rb
 - lib/io_streams/s3/reader.rb
 - lib/io_streams/s3/writer.rb
 - lib/io_streams/sftp/reader.rb
@@ -72,15 +74,18 @@ files:
 - lib/io_streams/tabular/parser/json.rb
 - lib/io_streams/tabular/parser/psv.rb
 - lib/io_streams/tabular/utility/csv_row.rb
+- lib/io_streams/utils.rb
 - lib/io_streams/version.rb
 - lib/io_streams/xlsx/reader.rb
 - lib/io_streams/zip/reader.rb
 - lib/io_streams/zip/writer.rb
 - lib/iostreams.rb
+- test/base_path_test.rb
 - test/bzip2_reader_test.rb
 - test/bzip2_writer_test.rb
 - test/encode_reader_test.rb
 - test/encode_writer_test.rb
+- test/file_path_test.rb
 - test/file_reader_test.rb
 - test/file_writer_test.rb
 - test/files/embedded_lines_test.csv
@@ -139,6 +144,7 @@ specification_version: 4
 summary: Input and Output streaming for Ruby.
 test_files:
 - test/pgp_reader_test.rb
+- test/base_path_test.rb
 - test/line_reader_test.rb
 - test/xlsx_reader_test.rb
 - test/row_writer_test.rb
@@ -175,3 +181,4 @@ test_files:
 - test/io_streams_test.rb
 - test/record_writer_test.rb
 - test/s3_reader_test.rb
+- test/file_path_test.rb

data/lib/io_streams/path.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-require 'fileutils'
-
-module IOStreams
-  #
-  # NOTE: This is a proof of concept class and will change significantly.
-  # I.e. Dont use it yet.
-  #
-  class Path
-    attr_reader :root, :relative
-
-    # Return named root path
-    def self.[](root)
-      @roots[root.to_sym] || raise(ArgumentError, "Unknown root: #{root.inspect}")
-    end
-
-    # Add a named root path
-    def self.add_root(root, path)
-      @roots[root.to_sym] = path.dup.freeze
-    end
-
-    def self.roots
-      @roots.dup
-    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
-
-    def initialize(*elements, root: :default)
-      @root     = root.to_sym
-      root_path = self.class[@root]
-      if elements.empty?
-        @relative = ''
-        @path     = root_path
-      else
-        @relative = ::File.join(*elements).freeze
-        if @relative.start_with?(root_path)
-          @path     = @relative
-          @relative = @path[root_path.size + 1..-1].freeze
-        else
-          @path = ::File.join(root_path, @relative).freeze
-        end
-      end
-    end
-
-    def to_s
-      @path
-    end
-
-    # Creates the entire path excluding the file_name.
-    def mkpath
-      path = ::File.dirname(@path)
-      FileUtils.mkdir_p(path) unless ::File.exist?(path)
-      self
-    end
-
-    def exist?
-      ::File.exist?(@path)
-    end
-
-    # Delete the file.
-    #
-    # Note: Only the file is removed, not any of the parent paths.
-    def delete
-      ::File.unlink(@path)
-      self
-    end
-
-    private
-
-    @roots = {}
-  end
-end