paperback 0.0.3 → 0.0.5

data/lib/paperback/preparer.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require 'base64'
@@ -12,37 +13,67 @@ module Paperback
   # Class wrapping functions to prepare data for paperback storage, including
   # QR code and sixword encoding.
   class Preparer
+    extend T::Sig
+
+    sig {returns(String)}
     attr_reader :data
+
+    sig {returns(T::Hash[String, T.untyped])}
     attr_reader :labels
+
+    sig {returns(T::Boolean)}
     attr_reader :qr_base64
+
+    sig {returns(T::Boolean)}
     attr_reader :encrypt
+
+    sig {returns(T.nilable(String))}
     attr_reader :passphrase_file
 
+    sig do
+      params(
+        filename: String,
+        encrypt: T::Boolean,
+        qr_base64: T::Boolean,
+        qr_level: T.nilable(Symbol),
+        comment: T.nilable(String),
+        passphrase_file: T.nilable(String),
+        include_base64: T::Boolean,
+      ).void
+    end
     def initialize(filename:, encrypt: true, qr_base64: false, qr_level: nil,
-                   comment: nil, passphrase_file: nil)
+                   comment: nil, passphrase_file: nil, include_base64: true)
 
       log.debug('Preparer#initialize')
 
+      # lazy initializers, all explicitly set to nil
+      @log = T.let(nil, T.nilable(Logger))
+      @qr_code = T.let(nil, T.nilable(RQRCode::QRCode))
+      @sixword_lines = T.let(nil, T.nilable(T::Array[String]))
+      @passphrase = T.let(nil, T.nilable(String))
+
       log.info("Reading #{filename.inspect}")
       plain_data = File.read(filename)
 
       log.debug("Read #{plain_data.bytesize} bytes")
 
-      @encrypt = encrypt
+      @encrypt = T.let(encrypt, T::Boolean)
 
       if encrypt
         @data = self.class.gpg_encrypt(filename: filename, password: passphrase)
       else
-        @data = plain_data
+        @data = T.let(plain_data, String)
       end
-      @sha256 = Digest::SHA256.hexdigest(plain_data)
+      @sha256 = T.let(Digest::SHA256.hexdigest(plain_data), String)
 
-      @qr_base64 = qr_base64
-      @qr_level = qr_level
+      @qr_base64 = T.let(qr_base64, T::Boolean)
+      @qr_level = T.let(qr_level, T.nilable(Symbol))
 
-      @passphrase_file = passphrase_file
+      @passphrase_file = T.let(passphrase_file, T.nilable(String))
 
-      @labels = {}
+      @include_base64 = T.let(!!include_base64, T::Boolean)
+
+      @labels = T.let({}, T::Hash[String, T.untyped])
       @labels['Filename'] = filename
       @labels['Backed up'] = Time.now.to_s
 
@@ -53,16 +84,21 @@ module Paperback
 
       @labels['SHA256'] = Digest::SHA256.hexdigest(plain_data)
 
-      @document = Paperback::Document.new
+      @document = T.let(Paperback::Document.new, Paperback::Document)
     end
 
+    @log = T.let(nil, T.nilable(Logger))
+
+    sig {returns(Logger)}
     def log
       @log ||= Paperback.class_log(self.class)
     end
+    sig {returns(Logger)}
     def self.log
       @log ||= Paperback.class_log(self)
     end
 
+    sig {params(output_filename: String, extra_draw_opts: T::Hash[T.untyped, T.untyped]).void}
     def render(output_filename:, extra_draw_opts: {})
       log.debug('Preparer#render')
 
@@ -73,12 +109,20 @@ module Paperback
         sixword_bytes: data.bytesize,
       }
 
+      if include_base64?
+        opts[:base64_content] = base64_content
+        opts[:base64_bytes] = data.bytesize
+      end
+
       if encrypt
         opts[:passphrase_sha] = self.class.truncated_sha256(passphrase)
         opts[:passphrase_len] = passphrase.length
         if passphrase_file
-          File.open(passphrase_file, File::CREAT|File::EXCL|File::WRONLY,
-                   0400) do |f|
+          File.open(
+            T.must(passphrase_file),
+            File::CREAT | File::EXCL | File::WRONLY,
+            0o400
+          ) do |f|
             f.write(passphrase)
           end
           log.info("Wrote passphrase to #{passphrase_file.inspect}")
@@ -91,18 +135,30 @@ module Paperback
 
       log.info('Render complete')
 
-      if encrypt && !passphrase_file
-        puts "Passphrase: #{passphrase}"
+      if encrypt
+        puts 'SHA256(passphrase)[0...16]: ' + opts.fetch(:passphrase_sha)
+        if !passphrase_file
+          puts "Passphrase: #{passphrase}"
+        end
+      else
+        log.info('Content was not encrypted')
       end
     end
 
+    sig {returns(String)}
     def passphrase
       raise "Can't have passphrase without encrypt" unless encrypt
       @passphrase ||= self.class.random_passphrase
     end
 
-    PassChars = [*'a'..'z', *'A'..'Z', *'0'..'9'].freeze
+    PassChars = T.let(
+      [*'a'..'z', *'A'..'Z', *'0'..'9'].freeze, T::Array[String]
+    )
 
+    sig do
+      params(entropy_bits: Integer, char_set: T::Array[String])
+        .returns(String)
+    end
     def self.random_passphrase(entropy_bits: 256, char_set: PassChars)
       chars_needed = (entropy_bits / Math.log2(char_set.length)).ceil
       (0...chars_needed).map {
@@ -111,35 +167,40 @@ module Paperback
     end
 
     # Compute a truncated SHA256 digest
+    sig {params(content: String).returns(String)}
     def self.truncated_sha256(content)
       Digest::SHA256.hexdigest(content)[0...16]
     end
 
+    sig {params(filename: String, password: String).returns(String)}
     def self.gpg_encrypt(filename:, password:)
       cmd = %w[
         gpg -c -o - --batch --cipher-algo aes256 --passphrase-fd 0 --
       ] + [filename]
-      out = nil
+      out = T.let(nil, T.nilable(String))
 
       log.debug('+ ' + cmd.join(' '))
       Subprocess.check_call(cmd, stdin: Subprocess::PIPE,
-                            stdout: Subprocess::PIPE) do |p|
+                                 stdout: Subprocess::PIPE) do |p|
         out, _err = p.communicate(password)
       end
 
-      out
+      T.must(out)
     end
 
+    sig {params(data: String, strip_comments: T::Boolean).returns(String)}
     def self.gpg_ascii_enarmor(data, strip_comments: true)
       cmd = %w[gpg --batch --enarmor]
-      out = nil
+      out = T.let(nil, T.nilable(String))
 
       log.debug('+ ' + cmd.join(' '))
       Subprocess.check_call(cmd, stdin: Subprocess::PIPE,
-                            stdout: Subprocess::PIPE) do |p|
+                                 stdout: Subprocess::PIPE) do |p|
         out, _err = p.communicate(data)
       end
 
+      out = T.must(out)
+
       if strip_comments
         out = out.each_line.select { |l| !l.start_with?('Comment: ') }.join
       end
@@ -147,37 +208,42 @@ module Paperback
       out
     end
 
+    sig {params(data: String).returns(String)}
     def self.gpg_ascii_dearmor(data)
       cmd = %w[gpg --batch --dearmor]
-      out = nil
+      out = T.let(nil, T.nilable(String))
 
       log.debug('+ ' + cmd.join(' '))
       Subprocess.check_call(cmd, stdin: Subprocess::PIPE,
-                            stdout: Subprocess::PIPE) do |p|
+                                 stdout: Subprocess::PIPE) do |p|
         out, _err = p.communicate(data)
       end
 
-      out
+      T.must(out)
+    end
+
+    # Whether to add the Base64 encoding to the generated document.
+    #
+    # @return [Boolean]
+    sig {returns(T::Boolean)}
+    def include_base64?
+      !!@include_base64
     end
 
     private
 
+    sig {returns(RQRCode::QRCode)}
     def qr_code
       @qr_code ||= qr_code!
     end
 
+    sig {returns(RQRCode::QRCode)}
     def qr_code!
       log.info('Generating QR code')
 
       # Base64 encode data prior to QR encoding as requested
       if qr_base64
-        if encrypt
-          # If data is already GPG encrypted, use GPG's base64 armor
-          input = self.class.gpg_ascii_enarmor(data)
-        else
-          # Otherwise do plain Base64
-          input = Base64.encode64(data)
-        end
+        input = base64_content
       else
         input = data
       end
@@ -198,11 +264,23 @@ module Paperback
       RQRCode::QRCode.new(input, level: @qr_level)
     end
 
+    sig {returns(T::Array[String])}
     def sixword_lines
       log.info('Encoding with Sixword')
       @sixword_lines ||=
         Sixword.pad_encode_to_sentences(data).map(&:downcase)
     end
 
+    sig {returns(String)}
+    def base64_content
+      log.debug('Encoding with Base64')
+      if encrypt
+        # If data is already GPG encrypted, use GPG's base64 armor
+        self.class.gpg_ascii_enarmor(data)
+      else
+        # Otherwise do plain Base64
+        Base64.encode64(data)
+      end
+    end
   end
 end

data/lib/paperback/version.rb

@@ -1,5 +1,6 @@
+# typed: strong
 # frozen_string_literal: true
 module Paperback
   # version string
-  VERSION = '0.0.3'
+  VERSION = '0.0.5'
 end

data/lib/paperback.rb

@@ -1,7 +1,14 @@
+# typed: strict
 require 'logger'
+require 'sorbet-runtime'
 
 # Paperback is a library for creating paper backups of sensitive data.
 module Paperback
+  extend T::Sig
+
+  @log = T.let(nil, T.nilable(Logger))
+
+  sig {returns(Logger)}
   def self.log
     return @log if @log
     @log = Logger.new(STDERR)
@@ -10,6 +17,7 @@ module Paperback
     @log
   end
 
+  sig {params(klass: Class, stream: IO).returns(Logger)}
   def self.class_log(klass, stream=STDERR)
     log = Logger.new(stream)
     log.progname = klass.name
@@ -17,10 +25,14 @@ module Paperback
     log
   end
 
+  @log_level = T.let(nil, T.nilable(Integer))
+
+  sig {returns(Integer)}
   def self.log_level
     @log_level ||= Logger::INFO
   end
 
+  sig {params(val: Integer).returns(Integer)}
   def self.log_level=(val)
     @log_level = val
   end

data/paperback.gemspec

@@ -1,8 +1,6 @@
-# coding: utf-8
+# frozen_string_literal: true
 
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'paperback/version'
+require_relative 'lib/paperback/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'paperback'
@@ -17,22 +15,27 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/ab/paperback'
   spec.license       = 'GPL-3'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($/).reject { |s|
+    s.start_with?('sample/')
+  }
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.50'
+  spec.add_development_dependency 'sorbet', '~> 0.5'
+  spec.add_development_dependency 'tapioca', '~> 0.10'
   spec.add_development_dependency 'yard'
 
   spec.add_dependency('prawn', '~> 1.3')
   spec.add_dependency('rqrcode', '~> 0.10')
   spec.add_dependency('sixword', '~> 0.3')
+  spec.add_dependency('sorbet-runtime', '~> 0.5')
   spec.add_dependency('subprocess', '~> 1.3')
 
-  spec.required_ruby_version = '>= 2.0'
+  spec.required_ruby_version = '>= 2.7'
 end

data/sorbet/config

@@ -0,0 +1,3 @@
+--dir
+.
+--ignore=vendor/

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end