iostreams 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dad581b0665992975c33f75b23f50964ae1311e025b7a1524fca4004f0ede2b
-  data.tar.gz: 4db01e4d6c2d36ce522df3b323a6e0d9f42de0d1644a282a0cea06479e979289
+  metadata.gz: 2ff0af97e5f820b516ec7a7e695d1c4cb0f7ee7022d9463e6fe917e3c56554cd
+  data.tar.gz: 8f2831eb25377f9944280726e585efb524d0ab711da04aa6cb3a5872477e9635
 SHA512:
-  metadata.gz: 4057a5c484129c60dbc9c84e462026da862900e17b0604b385164210f14814fbae6d065d015ee9171402eb9f793f33ac26c0ee7658f94b8cdeb0724c796cbe63
-  data.tar.gz: 5a84fe37c1eebc775bd84b9903181ff035c325b1233ab64990e586f5b0bd3fd51c21d4f1429f9b0e8ab64733e9b63be5c5e05df7bf026e9d1d8c0cd8a7716417
+  metadata.gz: b5fe32aec626686316168b9bf627f01a86a7d0ab7aea6c56d4b522084a41ee7ac079ef9c6fb7fee20011db78ab9828adf39de75476dc33f5406b1d43b4066eb9
+  data.tar.gz: a59ded1990c6a7ffc13f42a65dc8f9dd89e1e42e19933c4b0aff026bdbf2712acc08c027293b44002ac9e937bd80916ffe4e4765b3903fcb85b286031de39acc

data/README.md

@@ -1,7 +1,8 @@
-# iostreams
+# IOStreams
 [![Gem Version](https://img.shields.io/gem/v/iostreams.svg)](https://rubygems.org/gems/iostreams) [![Build Status](https://travis-ci.org/rocketjob/iostreams.svg?branch=master)](https://travis-ci.org/rocketjob/iostreams) [![Downloads](https://img.shields.io/gem/dt/iostreams.svg)](https://rubygems.org/gems/iostreams) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) ![](https://img.shields.io/badge/status-Production%20Ready-blue.svg) [![Gitter chat](https://img.shields.io/badge/IRC%20(gitter)-Support-brightgreen.svg)](https://gitter.im/rocketjob/support)
 
-Input and Output streaming for Ruby.
+IOStreams is an incredibly powerful streaming library that makes changes to file formats, compression, encryption, 
+or storage mechanism transparent to the application.
 
 ## Project Status
 
@@ -9,7 +10,9 @@ Production Ready, heavily used in production environments, many as part of Rocke
 
 ## Documentation
 
-[Semantic Logger Guide](http://rocketjob.github.io/iostreams)
+Start with the [IOStreams tutorial](https://iostreams.rocketjob.io/tutorial) to get a great introduction to IOStreams.
+
+Next, checkout the remaining [IOStreams documentation](https://iostreams.rocketjob.io/)
 
 ## Versioning
 

data/lib/io_streams/builder.rb

@@ -20,7 +20,7 @@ module IOStreams
       raise(ArgumentError, "Cannot call #option unless the `file_name` was already set}") unless file_name
 
       @options ||= {}
-      if opts = @options[stream]
+      if (opts = @options[stream])
         opts.merge!(options)
       else
         @options[stream] = options.dup
@@ -40,7 +40,7 @@ module IOStreams
       raise(ArgumentError, "Invalid stream: #{stream.inspect}") unless IOStreams.extensions.include?(stream)
 
       @streams ||= {}
-      if opts = @streams[stream]
+      if (opts = @streams[stream])
         opts.merge!(options)
       else
         @streams[stream] = options.dup
@@ -91,7 +91,8 @@ module IOStreams
     private
 
     def class_for_stream(type, stream)
-      ext = IOStreams.extensions[stream.nil? ? nil : stream.to_sym] || raise(ArgumentError, "Unknown Stream type: #{stream.inspect}")
+      ext = IOStreams.extensions[stream.nil? ? nil : stream.to_sym] ||
+            raise(ArgumentError, "Unknown Stream type: #{stream.inspect}")
       ext.send("#{type}_class") || raise(ArgumentError, "No #{type} registered for Stream type: #{stream.inspect}")
     end
 
@@ -99,7 +100,7 @@ module IOStreams
     def parse_extensions
       parts      = ::File.basename(file_name).split(".")
       extensions = []
-      while extension = parts.pop
+      while (extension = parts.pop)
         sym = extension.downcase.to_sym
         break unless IOStreams.extensions[sym]
 
@@ -116,10 +117,12 @@ module IOStreams
         block.call(io_stream)
       elsif pipeline.size == 1
         stream, opts = pipeline.first
-        class_for_stream(type, stream).open(io_stream, opts, &block)
+        class_for_stream(type, stream).open(io_stream, **opts, &block)
       else
         # Daisy chain multiple streams together
-        last = pipeline.keys.inject(block) { |inner, stream_sym| ->(io) { class_for_stream(type, stream_sym).open(io, pipeline[stream_sym], &inner) } }
+        last = pipeline.keys.inject(block) do |inner, stream_sym|
+          ->(io) { class_for_stream(type, stream_sym).open(io, **pipeline[stream_sym], &inner) }
+        end
         last.call(io_stream)
       end
     end

data/lib/io_streams/deprecated.rb

@@ -206,7 +206,7 @@ module IOStreams
         elsif streams.is_a?(Array)
           streams.each { |stream| apply_old_style_streams(path, stream) }
         elsif streams.is_a?(Hash)
-          streams.each_pair { |stream, options| path.stream(stream, options) }
+          streams.each_pair { |stream, options| path.stream(stream, **options) }
         else
           raise ArgumentError, "Invalid old style stream supplied: #{params.inspect}"
         end

data/lib/io_streams/encode/reader.rb

@@ -73,7 +73,7 @@ module IOStreams
         # EOF reached?
         return unless block
 
-        block = block.encode(@encoding, @encoding_options) unless block.encoding == @encoding
+        block = block.encode(@encoding, **@encoding_options) unless block.encoding == @encoding
         block = @cleaner.call(block, @replace) if @cleaner
         block
       end

data/lib/io_streams/encode/writer.rb

@@ -66,7 +66,7 @@ module IOStreams
         return 0 if data.nil?
 
         data  = data.to_s
-        block = data.encoding == @encoding ? data : data.encode(@encoding, @encoding_options)
+        block = data.encoding == @encoding ? data : data.encode(@encoding, **@encoding_options)
         block = @cleaner.call(block, @replace) if @cleaner
         @output_stream.write(block)
       end

data/lib/io_streams/errors.rb

@@ -18,5 +18,15 @@ module IOStreams
     # When the specified delimiter is not found in the supplied stream / file
     class DelimiterNotFound < Error
     end
+
+    # Fixed length line has the wrong length
+    class InvalidLineLength < Error
+    end
+
+    class ValueTooLong < Error
+    end
+
+    class InvalidLayout < Error
+    end
   end
 end

data/lib/io_streams/io_streams.rb

@@ -58,7 +58,7 @@ module IOStreams
   end
 
   # For an existing IO Stream
-  # IOStreams.stream(io).file_name('blah.zip').encoding('BINARY').reader(&:read)
+  # IOStreams.stream(io).file_name('blah.zip').encoding('BINARY').read
   # IOStreams.stream(io).file_name('blah.zip').encoding('BINARY').each(:line){ ... }
   # IOStreams.stream(io).file_name('blah.csv.zip').each(:line) { ... }
   # IOStreams.stream(io).stream(:zip).stream(:pgp, passphrase: 'receiver_passphrase').read

data/lib/io_streams/paths/file.rb

@@ -15,16 +15,16 @@ module IOStreams
       # Examples:
       #
       # # Case Insensitive file name lookup:
-      # IOStreams::Paths::File.new("ruby").glob("r*.md") { |name| puts name }
+      # IOStreams.path("ruby").glob("r*.md") { |name| puts name }
       #
       # # Case Sensitive file name lookup:
-      # IOStreams::Paths::File.new("ruby").each("R*.md", case_sensitive: true) { |name| puts name }
+      # IOStreams.path("ruby").each("R*.md", case_sensitive: true) { |name| puts name }
       #
       # # Also return the names of directories found during the search:
-      # IOStreams::Paths::File.new("ruby").each("R*.md", directories: true) { |name| puts name }
+      # IOStreams.path("ruby").each("R*.md", directories: true) { |name| puts name }
       #
       # # Case Insensitive recursive file name lookup:
-      # IOStreams::Paths::File.new("ruby").glob("**/*.md") { |name| puts name }
+      # IOStreams.path("ruby").glob("**/*.md") { |name| puts name }
       #
       # Parameters:
       #   pattern [String]

data/lib/io_streams/paths/http.rb

@@ -26,16 +26,19 @@ module IOStreams
       #
       #   http_redirect_count: [Integer]
       #     Maximum number of http redirects to follow.
-      def initialize(url, username: nil, password: nil, http_redirect_count: 10)
+      def initialize(url, username: nil, password: nil, http_redirect_count: 10, parameters: nil)
         uri = URI.parse(url)
         unless %w[http https].include?(uri.scheme)
-          raise(ArgumentError, "Invalid URL. Required Format: 'http://<host_name>/<file_name>', or 'https://<host_name>/<file_name>'")
+          raise(
+            ArgumentError,
+            "Invalid URL. Required Format: 'http://<host_name>/<file_name>', or 'https://<host_name>/<file_name>'"
+          )
         end
 
         @username            = username || uri.user
         @password            = password || uri.password
         @http_redirect_count = http_redirect_count
-        @url                 = url
+        @url                 = parameters ? "#{url}?#{URI.encode_www_form(parameters)}" : url
         super(uri.path)
       end
 

data/lib/io_streams/paths/s3.rb

@@ -92,7 +92,7 @@ module IOStreams
       #   encrypting data. This value is used to store the object and then it is
       #   discarded; Amazon does not store the encryption key. The key must be
       #   appropriate for use with the algorithm specified in the
-      #   x-amz-server-side​-encryption​-customer-algorithm header.
+      #   x-amz-server-side-encryption-customer-algorithm header.
       #
       # @option params [String] :sse_customer_key_md5
       #   Specifies the 128-bit MD5 digest of the encryption key according to

data/lib/io_streams/paths/sftp.rb

@@ -173,7 +173,10 @@ module IOStreams
               writer.close
               out = reader.read.chomp
               unless waith_thr.value.success?
-                raise(Errors::CommunicationsFailure, "Download failed calling #{self.class.sftp_bin} via #{self.class.sshpass_bin}: #{out}")
+                raise(
+                  Errors::CommunicationsFailure,
+                  "Download failed calling #{self.class.sftp_bin} via #{self.class.sshpass_bin}: #{out}"
+                )
               end
 
               out
@@ -183,7 +186,10 @@ module IOStreams
                     rescue StandardError
                       nil
                     end
-              raise(Errors::CommunicationsFailure, "Download failed calling #{self.class.sftp_bin} via #{self.class.sshpass_bin}: #{out}")
+              raise(
+                Errors::CommunicationsFailure,
+                "Download failed calling #{self.class.sftp_bin} via #{self.class.sshpass_bin}: #{out}"
+              )
             end
           end
         end
@@ -201,7 +207,10 @@ module IOStreams
               writer.close
               out = reader.read.chomp
               unless waith_thr.value.success?
-                raise(Errors::CommunicationsFailure, "Upload failed calling #{self.class.sftp_bin} via #{self.class.sshpass_bin}: #{out}")
+                raise(
+                  Errors::CommunicationsFailure,
+                  "Upload failed calling #{self.class.sftp_bin} via #{self.class.sshpass_bin}: #{out}"
+                )
               end
 
               out
@@ -211,7 +220,10 @@ module IOStreams
                     rescue StandardError
                       nil
                     end
-              raise(Errors::CommunicationsFailure, "Upload failed calling #{self.class.sftp_bin} via #{self.class.sshpass_bin}: #{out}")
+              raise(
+                Errors::CommunicationsFailure,
+                "Upload failed calling #{self.class.sftp_bin} via #{self.class.sshpass_bin}: #{out}"
+              )
             end
           end
         end

data/lib/io_streams/pgp.rb

@@ -46,7 +46,15 @@ module IOStreams
     #     `SecureRandom.urlsafe_base64(128)`
     #
     # See `man gpg` for the remaining options
-    def self.generate_key(name:, email:, comment: nil, passphrase:, key_type: "RSA", key_length: 4096, subkey_type: "RSA", subkey_length: key_length, expire_date: nil)
+    def self.generate_key(name:,
+                          email:,
+                          comment: nil,
+                          passphrase:,
+                          key_type: "RSA",
+                          key_length: 4096,
+                          subkey_type: "RSA",
+                          subkey_length: key_length,
+                          expire_date: nil)
       version_check
       params = ""
       params << "Key-Type: #{key_type}\n" if key_type
@@ -63,12 +71,11 @@ module IOStreams
 
       out, err, status = Open3.capture3(command, binmode: true, stdin_data: params)
       logger&.debug { "IOStreams::Pgp.generate_key: #{command}\n#{params}\n#{err}#{out}" }
-      if status.success?
-        if match = err.match(/gpg: key ([0-9A-F]+)\s+/)
-          match[1]
-        end
-      else
-        raise(Pgp::Failure, "GPG Failed to generate key: #{err}#{out}")
+
+      raise(Pgp::Failure, "GPG Failed to generate key: #{err}#{out}") unless status.success?
+
+      if (match = err.match(/gpg: key ([0-9A-F]+)\s+/))
+        match[1]
       end
     end
 
@@ -77,7 +84,8 @@ module IOStreams
     # Returns false if no key was found.
     # Raises an exception if it fails to delete the key.
     #
-    # email: [String] Email address for the key.
+    # email: [String] Optional email address for the key.
+    # key_id: [String] Optional id for the key.
     #
     # public: [true|false]
     #   Whether to delete the public key
@@ -86,12 +94,12 @@ module IOStreams
     # private: [true|false]
     #   Whether to delete the private key
     #   Default: false
-    def self.delete_keys(email:, public: true, private: false)
+    def self.delete_keys(email: nil, key_id: nil, public: true, private: false)
       version_check
       method_name = pgp_version.to_f >= 2.2 ? :delete_public_or_private_keys : :delete_public_or_private_keys_v1
       status      = false
-      status      = send(method_name, email: email, private: true) if private
-      status      = send(method_name, email: email, private: false) if public
+      status      = send(method_name, email: email, key_id: key_id, private: true) if private
+      status      = send(method_name, email: email, key_id: key_id, private: false) if public
       status
     end
 
@@ -150,16 +158,15 @@ module IOStreams
 
       out, err, status = Open3.capture3(command, binmode: true, stdin_data: key)
       logger&.debug { "IOStreams::Pgp.key_info: #{command}\n#{err}#{out}" }
-      if status.success? && out.length.positive?
-        # Sample Output:
-        #
-        #   pub  4096R/3A5456F5 2017-06-07
-        #   uid                            Joe Bloggs <j@bloggs.net>
-        #   sub  4096R/2C9B240B 2017-06-07
-        parse_list_output(out)
-      else
-        raise(Pgp::Failure, "GPG Failed extracting key details: #{err} #{out}")
-      end
+
+      raise(Pgp::Failure, "GPG Failed extracting key details: #{err} #{out}") unless status.success? && out.length.positive?
+
+      # Sample Output:
+      #
+      #   pub  4096R/3A5456F5 2017-06-07
+      #   uid                            Joe Bloggs <j@bloggs.net>
+      #   sub  4096R/2C9B240B 2017-06-07
+      parse_list_output(out)
     end
 
     # Returns [String] containing all the public keys for the supplied email address.
@@ -181,11 +188,10 @@ module IOStreams
 
       out, err, status = Open3.capture3(command, binmode: true)
       logger&.debug { "IOStreams::Pgp.export: #{command}\n#{err}" }
-      if status.success? && out.length.positive?
-        out
-      else
-        raise(Pgp::Failure, "GPG Failed reading key: #{email}: #{err}")
-      end
+
+      raise(Pgp::Failure, "GPG Failed reading key: #{email}: #{err}") unless status.success? && out.length.positive?
+
+      out
     end
 
     # Imports the supplied public/private key
@@ -251,11 +257,14 @@ module IOStreams
     def self.import_and_trust(key:)
       raise(ArgumentError, "Key cannot be empty") if key.nil? || (key == "")
 
-      email = key_info(key: key).last.fetch(:email)
-      raise(ArgumentError, "Recipient email cannot be extracted from supplied key") unless email
+      key_info = key_info(key: key).last
+
+      email = key_info.fetch(:email, nil)
+      key_id = key_info.fetch(:key_id, nil)
+      raise(ArgumentError, "Recipient email or key id cannot be extracted from supplied key") unless email || key_id
 
       import(key: key)
-      set_trust(email: email)
+      set_trust(email: email, key_id: key_id)
       email
     end
 
@@ -266,20 +275,19 @@ module IOStreams
     #
     # After importing keys, they are not trusted and the relevant trust level must be set.
     #   Default: 5 : Ultimate
-    def self.set_trust(email:, level: 5)
+    def self.set_trust(email: nil, key_id: nil, level: 5)
       version_check
-      fingerprint = fingerprint(email: email)
+      fingerprint = key_id || fingerprint(email: email)
       return unless fingerprint
 
       command          = "#{executable} --import-ownertrust"
       trust            = "#{fingerprint}:#{level + 1}:\n"
       out, err, status = Open3.capture3(command, stdin_data: trust)
       logger&.debug { "IOStreams::Pgp.set_trust: #{command}\n#{err}#{out}" }
-      if status.success?
-        err
-      else
-        raise(Pgp::Failure, "GPG Failed trusting key: #{err} #{out}")
-      end
+
+      raise(Pgp::Failure, "GPG Failed trusting key: #{err} #{out}") unless status.success?
+
+      err
     end
 
     # DEPRECATED - Use key_ids instead of fingerprints
@@ -287,18 +295,18 @@ module IOStreams
       version_check
       Open3.popen2e("#{executable} --list-keys --fingerprint --with-colons #{email}") do |_stdin, out, waith_thr|
         output = out.read.chomp
-        if waith_thr.value.success?
-          output.each_line do |line|
-            if match = line.match(/\Afpr.*::([^\:]*):\Z/)
-              return match[1]
-            end
+        unless waith_thr.value.success?
+          unless output =~ /(public key not found|No public key)/i
+            raise(Pgp::Failure, "GPG Failed calling #{executable} to list keys for #{email}: #{output}")
           end
-          nil
-        else
-          return if output =~ /(public key not found|No public key)/i
+        end
 
-          raise(Pgp::Failure, "GPG Failed calling #{executable} to list keys for #{email}: #{output}")
+        output.each_line do |line|
+          if (match = line.match(/\Afpr.*::([^\:]*):\Z/))
+            return match[1]
+          end
         end
+        nil
       end
     end
 
@@ -328,7 +336,7 @@ module IOStreams
           #           CAMELLIA128, CAMELLIA192, CAMELLIA256
           #   Hash: MD5, SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
           #   Compression: Uncompressed, ZIP, ZLIB, BZIP2
-          if match = out.lines.first.match(/(\d+\.\d+.\d+)/)
+          if (match = out.lines.first.match(/(\d+\.\d+.\d+)/))
             match[1]
           end
         else
@@ -348,9 +356,12 @@ module IOStreams
     end
 
     def self.version_check
-      if pgp_version.to_f >= 2.3
-        raise(Pgp::UnsupportedVersion, "Version #{pgp_version} of #{executable} is not yet supported. You are welcome to submit a Pull Request.")
-      end
+      return unless pgp_version.to_f >= 2.3
+
+      raise(
+        Pgp::UnsupportedVersion,
+        "Version #{pgp_version} of #{executable} is not yet supported. Please submit a Pull Request to support it."
+      )
     end
 
     # v2.2.1 output:
@@ -370,7 +381,7 @@ module IOStreams
       results = []
       hash    = {}
       out.each_line do |line|
-        if match = line.match(/(pub|sec)\s+(\D+)(\d+)\s+(\d+-\d+-\d+)\s+(.*)/)
+        if (match = line.match(/(pub|sec)\s+(\D+)(\d+)\s+(\d+-\d+-\d+)\s+(.*)/))
           # v2.2:    pub   rsa1024 2017-10-24 [SCEA]
           hash = {
             private:    match[1] == "sec",
@@ -382,7 +393,7 @@ module IOStreams
                            match[4]
                          end)
           }
-        elsif match = line.match(%r{(pub|sec)\s+(\d+)(.*)/(\w+)\s+(\d+-\d+-\d+)(\s+(.+)<(.+)>)?})
+        elsif (match = line.match(%r{(pub|sec)\s+(\d+)(.*)/(\w+)\s+(\d+-\d+-\d+)(\s+(.+)<(.+)>)?}))
           # Matches: pub  2048R/C7F9D9CB 2016-10-26
           # Or:      pub  2048R/C7F9D9CB 2016-10-26 Receiver <receiver@example.org>
           hash = {
@@ -403,7 +414,7 @@ module IOStreams
             results << hash
             hash = {}
           end
-        elsif match = line.match(/uid\s+(\[(.+)\]\s+)?(.+)<(.+)>/)
+        elsif (match = line.match(/uid\s+(\[(.+)\]\s+)?(.+)<(.+)>/))
           # Matches:  uid       [ unknown] Joe Bloggs <j@bloggs.net>
           # Or:       uid                  Joe Bloggs <j@bloggs.net>
           # v2.2:     uid           [ultimate] Joe Bloggs <pgp_test@iostreams.net>
@@ -412,7 +423,15 @@ module IOStreams
           hash[:trust] = match[2].to_s.strip if match[1]
           results << hash
           hash = {}
-        elsif match = line.match(/([A-Z0-9]+)/)
+        elsif (match = line.match(/uid\s+(\[(.+)\]\s+)?(.+)/))
+          # Matches:  uid       [ unknown] Joe Bloggs
+          # Or:       uid                  Joe Bloggs
+          # v2.2:     uid           [ultimate] Joe Bloggs
+          hash[:name]  = match[3].to_s.strip
+          hash[:trust] = match[2].to_s.strip if match[1]
+          results << hash
+          hash = {}
+        elsif (match = line.match(/([A-Z0-9]+)/))
           # v2.2  18A0FC1C09C0D8AE34CE659257DC4AE323C7368C
           hash[:key_id] ||= match[1]
         end
@@ -420,10 +439,10 @@ module IOStreams
       results
     end
 
-    def self.delete_public_or_private_keys(email:, private: false)
+    def self.delete_public_or_private_keys(email: nil, key_id: nil, private: false)
       keys = private ? "secret-keys" : "keys"
 
-      list = list_keys(email: email, private: private)
+      list = email ? list_keys(email: email, private: private) : list_keys(key_id: key_id)
       return false if list.empty?
 
       list.each do |key_info|
@@ -435,17 +454,17 @@ module IOStreams
         logger&.debug { "IOStreams::Pgp.delete_keys: #{command}\n#{err}#{out}" }
 
         unless status.success?
-          raise(Pgp::Failure, "GPG Failed calling #{executable} to delete #{keys} for #{email}: #{err}: #{out}")
+          raise(Pgp::Failure, "GPG Failed calling #{executable} to delete #{keys} for #{email || key_id}: #{err}: #{out}")
         end
-        raise(Pgp::Failure, "GPG Failed to delete #{keys} for #{email} #{err.strip}:#{out}") if out.include?("error")
+        raise(Pgp::Failure, "GPG Failed to delete #{keys} for #{email || key_id} #{err.strip}:#{out}") if out.include?("error")
       end
       true
     end
 
-    def self.delete_public_or_private_keys_v1(email:, private: false)
+    def self.delete_public_or_private_keys_v1(email: nil, key_id: nil, private: false)
       keys = private ? "secret-keys" : "keys"
 
-      command = "for i in `#{executable} --list-#{keys} --with-colons --fingerprint #{email} | grep \"^fpr\" | cut -d: -f10`; do\n"
+      command = "for i in `#{executable} --list-#{keys} --with-colons --fingerprint #{email || key_id} | grep \"^fpr\" | cut -d: -f10`; do\n"
       command << "#{executable} --batch --no-tty --yes --delete-#{keys} \"$i\" ;\n"
       command << "done"
 
@@ -454,9 +473,9 @@ module IOStreams
 
       return false if err =~ /(not found|no public key)/i
       unless status.success?
-        raise(Pgp::Failure, "GPG Failed calling #{executable} to delete #{keys} for #{email}: #{err}: #{out}")
+        raise(Pgp::Failure, "GPG Failed calling #{executable} to delete #{keys} for #{email || key_id}: #{err}: #{out}")
       end
-      raise(Pgp::Failure, "GPG Failed to delete #{keys} for #{email} #{err.strip}: #{out}") if out.include?("error")
+      raise(Pgp::Failure, "GPG Failed to delete #{keys} for #{email || key_id} #{err.strip}: #{out}") if out.include?("error")
 
       true
     end

data/lib/io_streams/stream.rb

@@ -17,7 +17,7 @@ module IOStreams
     #
     # Example:
     #
-    # IOStreams.path('tempfile2527').stream(:zip).stream(:pgp, passphrase: 'receiver_passphrase').reader(&:read)
+    # IOStreams.path("tempfile2527").stream(:zip).stream(:pgp, passphrase: "receiver_passphrase").read
     def stream(stream, **options)
       builder.stream(stream, **options)
       self
@@ -27,12 +27,12 @@ module IOStreams
     # If the relevant stream is not found for this file it is ignored.
     # For example, if the file does not have a pgp extension then the pgp option is not relevant.
     #
-    # IOStreams.path('keep_safe.pgp').option(:pgp, passphrase: 'receiver_passphrase').reader(&:read)
+    # IOStreams.path("keep_safe.pgp").option(:pgp, passphrase: "receiver_passphrase").read
     #
     # # In this case the file is not pgp so the `passphrase` option is ignored.
-    # IOStreams.path('keep_safe.enc').option(:pgp, passphrase: 'receiver_passphrase').reader(&:read)
+    # IOStreams.path("keep_safe.enc").option(:pgp, passphrase: "receiver_passphrase").read
     #
-    # IOStreams.path(output_file_name).option(:pgp, passphrase: 'receiver_passphrase').reader(&:read)
+    # IOStreams.path(output_file_name).option(:pgp, passphrase: "receiver_passphrase").read
     def option(stream, **options)
       builder.option(stream, **options)
       self
@@ -282,7 +282,12 @@ module IOStreams
     def line_reader(embedded_within: nil, **args)
       embedded_within = '"' if embedded_within.nil? && builder.file_name&.include?(".csv")
 
-      stream_reader { |io| yield IOStreams::Line::Reader.new(io, original_file_name: builder.file_name, embedded_within: embedded_within, **args) }
+      stream_reader do |io|
+        yield IOStreams::Line::Reader.new(io,
+                                          original_file_name: builder.file_name,
+                                          embedded_within:    embedded_within,
+                                          **args)
+      end
     end
 
     # Iterate over a file / stream returning each line as an array, one at a time.
@@ -306,19 +311,25 @@ module IOStreams
     def line_writer(**args, &block)
       return block.call(io_stream) if io_stream&.is_a?(IOStreams::Line::Writer)
 
-      writer { |io| IOStreams::Line::Writer.stream(io, original_file_name: builder.file_name, **args, &block) }
+      writer do |io|
+        IOStreams::Line::Writer.stream(io, original_file_name: builder.file_name, **args, &block)
+      end
     end
 
     def row_writer(delimiter: $/, **args, &block)
       return block.call(io_stream) if io_stream&.is_a?(IOStreams::Row::Writer)
 
-      line_writer(delimiter: delimiter) { |io| IOStreams::Row::Writer.stream(io, original_file_name: builder.file_name, **args, &block) }
+      line_writer(delimiter: delimiter) do |io|
+        IOStreams::Row::Writer.stream(io, original_file_name: builder.file_name, **args, &block)
+      end
     end
 
     def record_writer(delimiter: $/, **args, &block)
       return block.call(io_stream) if io_stream&.is_a?(IOStreams::Record::Writer)
 
-      line_writer(delimiter: delimiter) { |io| IOStreams::Record::Writer.stream(io, original_file_name: builder.file_name, **args, &block) }
+      line_writer(delimiter: delimiter) do |io|
+        IOStreams::Record::Writer.stream(io, original_file_name: builder.file_name, **args, &block)
+      end
     end
   end
 end

data/lib/io_streams/tabular.rb

@@ -89,7 +89,7 @@ module IOStreams
         else
           self.class.parser_class(format)
         end
-      @parser = format_options ? klass.new(format_options) : klass.new
+      @parser = format_options ? klass.new(**format_options) : klass.new
     end
 
     # Returns [true|false] whether a header is still required in order to parse or render the current format.
@@ -142,7 +142,10 @@ module IOStreams
       return unless requires_header?
 
       if IOStreams::Utils.blank?(header.columns)
-        raise(Errors::MissingHeader, "Header columns must be set before attempting to render a header for format: #{format.inspect}")
+        raise(
+          Errors::MissingHeader,
+          "Header columns must be set before attempting to render a header for format: #{format.inspect}"
+        )
       end
 
       parser.render(header.columns, header)

data/lib/io_streams/tabular/header.rb

@@ -109,7 +109,10 @@ module IOStreams
         end
 
         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.")
+          raise(
+            IOStreams::Errors::TypeMismatch,
+            "Don't know how to convert #{row.class.name} to an Array without the header columns being set."
+          )
         end
 
         row

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

@@ -3,31 +3,66 @@ module IOStreams
     module Parser
       # Parsing and rendering fixed length data
       class Fixed < Base
-        attr_reader :fixed_layout
+        attr_reader :layout, :truncate
 
         # Returns [IOStreams::Tabular::Parser]
         #
         # Parameters:
         #   layout: [Array<Hash>]
         #     [
-        #       {key: 'name',    size: 23 },
-        #       {key: 'address', size: 40 },
-        #       {key: 'zip',     size: 5 }
+        #       {size: 23, key: "name"},
+        #       {size: 40, key: "address"},
+        #       {size:  2},
+        #       {size:  5, key: "zip"},
+        #       {size:  8, key: "age", type: :integer},
+        #       {size: 10, key: "weight", type: :float, decimals: 2}
         #     ]
-        def initialize(layout:)
-          @fixed_layout = parse_layout(layout)
+        #
+        # Notes:
+        # * Leave out the name of the key to ignore that column during parsing,
+        #   and to space fill when rendering. For example as a filler.
+        #
+        # Types:
+        #    :string
+        #      This is the default type.
+        #      Applies space padding and the value is left justified.
+        #      Returns value as a String
+        #    :integer
+        #      Applies zero padding to the left.
+        #      Returns value as an Integer
+        #      Raises Errors::ValueTooLong when the supplied value cannot be rendered in `size` characters.
+        #    :float
+        #      Applies zero padding to the left.
+        #      Returns value as a float.
+        #      The :size is the total size of this field including the `.` and the decimals.
+        #      Number of :decimals
+        #      Raises Errors::ValueTooLong when the supplied value cannot be rendered in `size` characters.
+        def initialize(layout:, truncate: true)
+          @layout   = Layout.new(layout)
+          @truncate = truncate
+        end
+
+        # The required line length for every fixed length line
+        def line_length
+          layout.length
         end
 
         # Returns [String] fixed layout values extracted from the supplied hash.
-        # String will be encoded to `encoding`
+        #
+        # Notes:
+        # * A nil value is considered an empty string
+        # * When a supplied value exceeds the column size it is truncated.
         def render(row, header)
           hash = header.to_hash(row)
 
           result = ""
-          fixed_layout.each do |map|
-            # A nil value is considered an empty string
-            value = hash[map.key].to_s
-            result << format("%-#{map.size}.#{map.size}s", value)
+          layout.columns.each do |column|
+            value = hash[column.key].to_s
+            if !truncate && (value.length > column.size)
+              raise(Errors::ValueTooLong, "Value: #{value.inspect} is too long to fit into column #{column.key} of size #{column.size}")
+            end
+
+            result << column.render(value)
           end
           result
         end
@@ -36,32 +71,102 @@ module IOStreams
         # String will be encoded to `encoding`
         def parse(line)
           unless line.is_a?(String)
-            raise(IOStreams::Errors::TypeMismatch, "Format is :fixed. Invalid parse input: #{line.class.name}")
+            raise(Errors::TypeMismatch, "Line must be a String when format is :fixed. Actual: #{line.class.name}")
+          end
+
+          if line.length != layout.length
+            raise(Errors::InvalidLineLength, "Expected line length: #{layout.length}, actual line length: #{line.length}")
           end
 
           hash  = {}
           index = 0
-          fixed_layout.each do |map|
-            value = line[index..(index + map.size - 1)]
-            index += map.size
-            hash[map.key] = value.to_s.strip
+          layout.columns.each do |column|
+            # Ignore "columns" that have no keys. E.g. Fillers
+            hash[column.key] = column.parse(line[index, column.size]) if column.key
+            index += column.size
           end
           hash
         end
 
         private
 
-        FixedLayout = Struct.new(:key, :size)
+        class Layout
+          attr_reader :columns, :length
+
+          # Returns [Array<FixedLayout>] the layout for this fixed width file.
+          # Also validates values
+          def initialize(layout)
+            @length  = 0
+            @columns = parse_layout(layout)
+          end
+
+          private
+
+          def parse_layout(layout)
+            @length = 0
+            layout.collect do |hash|
+              raise(Errors::InvalidLayout, "Missing required :size in: #{hash.inspect}") unless hash.key?(:size)
+
+              column = Column.new(**hash)
+              @length += column.size
+              column
+            end
+          end
+        end
+
+        class Column
+          TYPES = %i[string integer float].freeze
+
+          attr_reader :key, :size, :type, :decimals
+
+          def initialize(key: nil, size:, type: :string, decimals: 2)
+            @key      = key
+            @size     = size.to_i
+            @type     = type.to_sym
+            @decimals = decimals
+
+            raise(Errors::InvalidLayout, "Size #{size.inspect} must be positive") unless @size.positive?
+            raise(Errors::InvalidLayout, "Unknown type: #{type.inspect}") unless TYPES.include?(type)
+          end
+
+          def parse(value)
+            return if value.nil?
+
+            stripped_value = value.to_s.strip
+
+            case type
+            when :string
+              stripped_value
+            when :integer
+              stripped_value.length.zero? ? nil : value.to_i
+            when :float
+              stripped_value.length.zero? ? nil : value.to_f
+            else
+              raise(Errors::InvalidLayout, "Unsupported type: #{type.inspect}")
+            end
+          end
+
+          def render(value)
+            case type
+            when :string
+              format("%-#{size}.#{size}s", value.to_s)
+            when :integer
+              formatted = format("%0#{size}d", value.to_i)
+              if formatted.length > size
+                raise(Errors::ValueTooLong, "Value: #{value} is too large to fit into column:#{key} of size:#{size}")
+              end
 
-        # Returns [Array<FixedLayout>] the layout for this fixed width file.
-        # Also validates values
-        def parse_layout(layout)
-          layout.collect do |map|
-            size = map[:size]
-            key  = map[:key]
-            raise(ArgumentError, "Missing required :key and :size in: #{map.inspect}") unless size && key
+              formatted
+            when :float
+              formatted = format("%0#{size}.#{decimals}f", value.to_f)
+              if formatted.length > size
+                raise(Errors::ValueTooLong, "Value: #{value} is too large to fit into column:#{key} of size:#{size}")
+              end
 
-            FixedLayout.new(key, size)
+              formatted
+            else
+              raise(Errors::InvalidLayout, "Unsupported type: #{type.inspect}")
+            end
           end
         end
       end

data/lib/io_streams/utils.rb

@@ -49,10 +49,10 @@ module IOStreams
         @user     = uri.user
         @password = uri.password
         @port     = uri.port
-        if uri.query
-          @query = {}
-          ::URI.decode_www_form(uri.query).each { |key, value| @query[key] = value }
-        end
+        return unless uri.query
+
+        @query = {}
+        ::URI.decode_www_form(uri.query).each { |key, value| @query[key] = value }
       end
     end
   end

data/lib/io_streams/version.rb

@@ -1,3 +1,3 @@
 module IOStreams
-  VERSION = "1.2.1".freeze
+  VERSION = "1.3.0".freeze
 end

data/lib/io_streams/zip/reader.rb

@@ -38,7 +38,7 @@ module IOStreams
             return true
           end
 
-          while entry = zin.get_next_entry
+          while (entry = zin.get_next_entry)
             return true if entry.name == entry_file_name
           end
           false

data/test/io_streams_test.rb

@@ -16,7 +16,7 @@ module IOStreams
       end
 
       let :json_file_name do
-        "/tmp/io_streams/abc.json"
+        "/tmp/iostreams_abc.json"
       end
 
       describe ".root" do
@@ -90,7 +90,7 @@ module IOStreams
         it "hash reader detects json format from file name" do
           ::File.open(json_file_name, "wb") { |file| file.write(expected_json) }
           rows = []
-          path = IOStreams.path("/tmp/io_streams/abc.json")
+          path = IOStreams.path(json_file_name)
           path.each(:hash) do |row|
             rows << row
           end

data/test/paths/file_test.rb

@@ -171,7 +171,7 @@ module Paths
 
       describe "reader" do
         it "reads file" do
-          assert_equal data, file_path.reader(&:read)
+          assert_equal data, file_path.read
         end
       end
 

data/test/paths/s3_test.rb

@@ -73,7 +73,7 @@ module Paths
 
       describe "#reader" do
         it "reads" do
-          assert_equal raw, existing_path.reader(&:read)
+          assert_equal raw, existing_path.read
         end
       end
 
@@ -89,7 +89,7 @@ module Paths
 
       describe "#writer" do
         it "writes" do
-          assert_equal raw.size, write_path.writer { |io| io.write(raw) }
+          assert_equal(raw.size, write_path.writer { |io| io.write(raw) })
           assert write_path.exist?
           assert_equal raw, write_path.read
         end

data/test/paths/sftp_test.rb

@@ -42,7 +42,7 @@ module Paths
 
       describe "#reader" do
         it "reads" do
-          assert_equal raw, existing_path.reader(&:read)
+          assert_equal raw, existing_path.read
         end
 
         it "fails when the file does not exist" do
@@ -60,7 +60,7 @@ module Paths
 
       describe "#writer" do
         it "writes" do
-          assert_equal raw.size, write_path.writer { |io| io.write(raw) }
+          assert_equal(raw.size, write_path.writer { |io| io.write(raw) })
           assert_equal raw, write_path.read
         end
 
@@ -77,7 +77,7 @@ module Paths
 
           it "writes" do
             skip "No identity file env var set: SFTP_IDENTITY_FILE" unless ENV["SFTP_IDENTITY_FILE"]
-            assert_equal raw.size, write_path.writer { |io| io.write(raw) }
+            assert_equal(raw.size, write_path.writer { |io| io.write(raw) })
             assert_equal raw, write_path.read
           end
         end
@@ -90,7 +90,7 @@ module Paths
 
           it "writes" do
             skip "No identity file env var set: SFTP_IDENTITY_FILE" unless ENV["SFTP_IDENTITY_FILE"]
-            assert_equal raw.size, write_path.writer { |io| io.write(raw) }
+            assert_equal(raw.size, write_path.writer { |io| io.write(raw) })
             assert_equal raw, write_path.read
           end
         end

data/test/pgp_test.rb

@@ -70,7 +70,7 @@ class PgpTest < Minitest::Test
         refute IOStreams::Pgp.delete_keys(email: "random@iostreams.net", public: true, private: true)
       end
 
-      it "deletes existing keys" do
+      it "deletes existing keys with specified email" do
         generated_key_id
         # There is a timing issue with creating and then deleting keys.
         # Call list_keys again to give GnuPGP time.
@@ -78,7 +78,16 @@ class PgpTest < Minitest::Test
         assert IOStreams::Pgp.delete_keys(email: email, public: true, private: true)
       end
 
-      it "deletes just the private key" do
+      it "deletes existing keys with specified key_id" do
+        generated_key_id
+
+        # There is a timing issue with creating and then deleting keys.
+        # Call list_keys again to give GnuPGP time.
+        IOStreams::Pgp.list_keys(key_id: generated_key_id, private: true)
+        assert IOStreams::Pgp.delete_keys(key_id: generated_key_id, public: true, private: true)
+      end
+
+      it "deletes just the private key with specified email" do
         generated_key_id
         # There is a timing issue with creating and then deleting keys.
         # Call list_keys again to give GnuPGP time.
@@ -87,6 +96,16 @@ class PgpTest < Minitest::Test
         refute IOStreams::Pgp.key?(key_id: generated_key_id, private: true)
         assert IOStreams::Pgp.key?(key_id: generated_key_id, private: false)
       end
+
+      it "deletes just the private key with specified key_id" do
+        generated_key_id
+        # There is a timing issue with creating and then deleting keys.
+        # Call list_keys again to give GnuPGP time.
+        IOStreams::Pgp.list_keys(key_id: generated_key_id, private: true)
+        assert IOStreams::Pgp.delete_keys(key_id: generated_key_id, public: false, private: true)
+        refute IOStreams::Pgp.key?(key_id: generated_key_id, private: true)
+        assert IOStreams::Pgp.key?(key_id: generated_key_id, private: false)
+      end
     end
 
     describe ".export" do
@@ -113,7 +132,7 @@ class PgpTest < Minitest::Test
         IOStreams::Pgp.list_keys(email: email)
       end
 
-      it "lists public keys" do
+      it "lists public keys for email" do
         assert keys = IOStreams::Pgp.list_keys(email: email)
         assert_equal 1, keys.size
         assert key = keys.first
@@ -130,7 +149,24 @@ class PgpTest < Minitest::Test
         assert_equal "ultimate", key[:trust] if (ver.to_f >= 2) && (maint >= 30)
       end
 
-      it "lists private keys" do
+      it "lists public keys for key_id" do
+        assert keys = IOStreams::Pgp.list_keys(key_id: generated_key_id)
+        assert_equal 1, keys.size
+        assert key = keys.first
+
+        assert_equal Date.today, key[:date]
+        assert_equal email, key[:email]
+        assert_includes key[:key_id], generated_key_id
+        assert_equal 1024, key[:key_length]
+        assert_includes %w[R rsa], key[:key_type]
+        assert_equal user_name, key[:name]
+        refute key[:private], key
+        ver   = IOStreams::Pgp.pgp_version
+        maint = ver.split(".").last.to_i
+        assert_equal "ultimate", key[:trust] if (ver.to_f >= 2) && (maint >= 30)
+      end
+
+      it "lists private keys for email" do
         assert keys = IOStreams::Pgp.list_keys(email: email, private: true)
         assert_equal 1, keys.size
         assert key = keys.first
@@ -143,6 +179,20 @@ class PgpTest < Minitest::Test
         assert_equal user_name, key[:name]
         assert key[:private], key
       end
+
+      it "lists private keys for key_id" do
+        assert keys = IOStreams::Pgp.list_keys(key_id: generated_key_id, private: true)
+        assert_equal 1, keys.size
+        assert key = keys.first
+
+        assert_equal Date.today, key[:date]
+        assert_equal email, key[:email]
+        assert_includes key[:key_id], generated_key_id
+        assert_equal 1024, key[:key_length]
+        assert_includes %w[R rsa], key[:key_type]
+        assert_equal user_name, key[:name]
+        assert key[:private], key
+      end
     end
 
     describe ".key_info" do

data/test/pgp_writer_test.rb

@@ -53,9 +53,9 @@ class PgpWriterTest < Minitest::Test
       end
 
       it "supports multiple recipients" do
-          IOStreams::Pgp::Writer.file(file_name, recipient: %w[receiver@example.org receiver2@example.org], signer: "sender@example.org", signer_passphrase: "sender_passphrase") do |io|
-            io.write(decrypted)
-          end
+        IOStreams::Pgp::Writer.file(file_name, recipient: %w[receiver@example.org receiver2@example.org], signer: "sender@example.org", signer_passphrase: "sender_passphrase") do |io|
+          io.write(decrypted)
+        end
 
         result = IOStreams::Pgp::Reader.file(file_name, passphrase: "receiver_passphrase", &:read)
         assert_equal decrypted, result

data/test/tabular_test.rb

@@ -138,33 +138,47 @@ class TabularTest < Minitest::Test
       describe ":fixed format" do
         let :tabular do
           layout = [
-            {key: "name", size: 23},
-            {key: "address", size: 40},
-            {key: "zip", size: 5}
+            {size: 23, key: :name},
+            {size: 40, key: :address},
+            {size: 2},
+            {size: 5, key: :zip, type: :integer},
+            {size: 8, key: :age, type: :integer},
+            {size: 10, key: :weight, type: :float, decimals: 2}
           ]
           IOStreams::Tabular.new(format: :fixed, format_options: {layout: layout})
         end
 
         it "parses to hash" do
-          assert hash = tabular.record_parse("Jack                   over there                              34618")
-          assert_equal({"name" => "Jack", "address" => "over there", "zip" => "34618"}, hash)
+          assert hash = tabular.record_parse("Jack                   over there                              XX34618012345670012345.01")
+          assert_equal({name: "Jack", address: "over there", zip: 34_618, age: 1_234_567, weight: 12_345.01}, hash)
         end
 
         it "parses short string" do
-          # TODO: Raise exception on lines that are too short?
-          assert hash = tabular.record_parse("Jack                   over th")
-          assert_equal({"name" => "Jack", "address" => "over th", "zip" => ""}, hash)
+          assert_raises IOStreams::Errors::InvalidLineLength do
+            tabular.record_parse("Jack                   over th")
+          end
         end
 
         it "parses longer string" do
-          # TODO: Raise exception on lines that are too long?
-          assert hash = tabular.record_parse("Jack                   over there                              34618........................................")
-          assert_equal({"name" => "Jack", "address" => "over there", "zip" => "34618"}, hash)
+          assert_raises IOStreams::Errors::InvalidLineLength do
+            tabular.record_parse("Jack                   over there                              XX34618012345670012345.01............")
+          end
+        end
+
+        it "parses zero values" do
+          assert hash = tabular.record_parse("                                                                 00000000000000000000000")
+          assert_equal({name: "", address: "", zip: 0, age: 0, weight: 0.0}, hash)
+        end
+
+        it "parses empty values" do
+          assert hash = tabular.record_parse("                                                               XX                       ")
+          assert_equal({name: "", address: "", zip: nil, age: nil, weight: nil}, hash)
         end
 
-        it "parses empty strings" do
-          assert hash = tabular.record_parse("                                                               34618")
-          assert_equal({"name" => "", "address" => "", "zip" => "34618"}, hash)
+        it "parses blank strings" do
+          skip "TODO: Part of tabular refactor to get this working"
+          assert hash = tabular.record_parse("                                                                                        ")
+          assert_equal({name: "", address: "", zip: nil, age: nil, weight: nil}, hash)
         end
 
         it "parses nil data as nil" do
@@ -224,31 +238,46 @@ class TabularTest < Minitest::Test
       describe ":fixed format" do
         let :tabular do
           layout = [
-            {key: "name", size: 23},
-            {key: "address", size: 40},
-            {key: "zip", size: 5}
+            {size: 23, key: :name},
+            {size: 40, key: :address},
+            {size: 2},
+            {size: 5, key: :zip, type: :integer},
+            {size: 8, key: :age, type: :integer},
+            {size: 10, key: :weight, type: :float, decimals: 2}
           ]
           IOStreams::Tabular.new(format: :fixed, format_options: {layout: layout})
         end
 
         it "renders fixed data" do
-          assert string = tabular.render({"name" => "Jack", "address" => "over there", "zip" => 34_618, "phone" => "5551231234"})
-          assert_equal "Jack                   over there                              34618", string
+          assert string = tabular.render(name: "Jack", address: "over there", zip: 34_618, weight: 123_456.789123, age: 21)
+          assert_equal "Jack                   over there                                34618000000210123456.79", string
         end
 
-        it "truncates long data" do
-          assert string = tabular.render({"name" => "Jack", "address" => "over there", "zip" => 3_461_832_653_653_265, "phone" => "5551231234"})
-          assert_equal "Jack                   over there                              34618", string
+        it "truncates long strings" do
+          assert string = tabular.render(name: "Jack ran up the beanstalk and when jack reached the top it was truncated", address: "over there", zip: 34_618)
+          assert_equal "Jack ran up the beanstaover there                                34618000000000000000.00", string
+        end
+
+        it "when integer is too large" do
+          assert_raises IOStreams::Errors::ValueTooLong do
+            tabular.render(zip: 3_461_832_653_653_265)
+          end
+        end
+
+        it "when float is too large" do
+          assert_raises IOStreams::Errors::ValueTooLong do
+            tabular.render(weight: 3_461_832_653_653_265.234)
+          end
         end
 
         it "renders nil as empty string" do
-          assert string = tabular.render("zip" => 3_461_832_653_653_265)
-          assert_equal "                                                               34618", string
+          assert string = tabular.render(zip: 34_618)
+          assert_equal "                                                                 34618000000000000000.00", string
         end
 
         it "renders boolean" do
-          assert string = tabular.render({"name" => true, "address" => false, "zip" => nil, "phone" => "5551231234"})
-          assert_equal "true                   false                                        ", string
+          assert string = tabular.render(name: true, address: false)
+          assert_equal "true                   false                                     00000000000000000000.00", string
         end
 
         it "renders no data as nil" do

data/test/test_helper.rb

@@ -4,7 +4,7 @@ require "yaml"
 require "minitest/autorun"
 require "minitest/reporters"
 require "iostreams"
-require "awesome_print"
+require "amazing_print"
 require "symmetric-encryption"
 
 # Since PGP libraries use UTC for Dates

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iostreams
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-19 00:00:00.000000000 Z
+date: 2020-07-13 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -130,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Input and Output streaming for Ruby.