blackbox 1.1.2 → 3.1.1

data/lib/blackbox/gem.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+module BB
+  # Gem utilities.
+  module Gem
+    class << self
+      # Return information about the currently installed gem
+      # version and the latest available version on rubygems.org.
+      #
+      # @param [Hash] opts the options to create a message with.
+      # @option opts [Fixnum] :check_interval how frequently to query rubygems.org (default: 3600)
+      # @option opts [String] :disabling_env_var (default: #{GEMNAME}_DISABLE_VERSION_CHECK)
+      # @option opts [] :from ('nobody') From address
+      # @return [Hash] result
+      #   * :gem_name                => name of current gem
+      #   * :gem_installed_version   => installed version
+      #   * :gem_latest_version      => latest version on rubygems.org
+      #   * :last_checked_for_update => timestamp of last query to rubygems.org
+      #   * :next_check_for_update   => timestamp of next query to rubygems.org
+      #   * :gem_update_available    => update available?
+      #   * :installed_is_latest     => is installed version == latest available version?
+      def version_info(*_, **opts)
+        ret = {
+          gem_name: :unknown,
+          gem_installed_version: :unknown,
+          gem_latest_version: :unknown,
+          gem_update_available: false,
+          last_checked_for_update: :unknown,
+          next_check_for_update: :unknown,
+          installed_is_latest: true
+        }
+
+        spec = ::Gem::Specification.find do |s|
+          File.fnmatch(File.join(s.full_gem_path, '*'), __FILE__)
+        end
+
+        ret[:gem_installed_version] = spec&.version.to_s || :unknown
+        ret[:gem_name] = spec&.name || :unknown
+
+        opts = { # defaults
+          check_interval: 3600,
+          disabling_env_var: "#{spec.name.upcase}_DISABLE_VERSION_CHECK"
+        }.merge(opts)
+
+        return ret if ret[:gem_name] == :unknown
+        return ret if ret[:gem_installed_version] == :unknown
+        if opts[:disabling_env_var] && ENV.include?(opts[:disabling_env_var])
+          ret[:next_check_for_update] = :never
+          return ret
+        end
+
+        require 'gem_update_checker'
+        require 'tmpdir'
+        require 'fileutils'
+
+        statefile_path = File.join(Dir.tmpdir, "#{ret[:gem_name]}-#{ret[:gem_installed_version]}.last_update_check")
+
+        last_check_at = nil
+        begin
+          last_check_at = File.stat(statefile_path).mtime
+        rescue
+          last_check_at = Time.at(0)
+        end
+        return ret if last_check_at > Time.now - opts[:check_interval]
+
+        checker = GemUpdateChecker::Client.new(ret[:gem_name], ret[:gem_installed_version])
+        last_check_at = Time.now
+
+        ret.merge!(
+          gem_latest_version: checker.latest_version,
+          last_checked_for_update: last_check_at,
+          next_check_for_update: last_check_at + opts[:check_interval],
+          installed_is_latest: ret[:gem_installed_version] == checker.latest_version,
+          gem_update_available: checker.update_available
+        )
+
+        FileUtils.touch(statefile_path) if ret[:installed_is_latest]
+
+        ret
+      end
+    end
+  end
+end

data/lib/blackbox/hash.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module BB
   # Hash utilities.
   module Hash
@@ -7,7 +8,7 @@ module BB
       # @param [Hash] hash Input hash
       # @return [Hash] Output hash (with symbolized keys)
       def symbolize_keys(hash)
-        hash.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+        hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
       end
 
       # Recursively flatten a hash to property-style format.
@@ -29,12 +30,12 @@ module BB
       #   Key delimiter (Default: '.')
       # @param [Hash] output (leave this blank)
       # @return [Hash] Output hash (flattened)
-      def flatten_prop_style(input={}, opts={}, output={})
+      def flatten_prop_style(input = {}, opts = {}, output = {})
         input.each do |key, value|
-          key = opts[:prefix].nil? ? "#{key}" : "#{opts[:prefix]}#{opts[:delimiter]||'.'}#{key}"
+          key = opts[:prefix].nil? ? key.to_s : "#{opts[:prefix]}#{opts[:delimiter] || '.'}#{key}"
           case value
           when ::Hash
-            flatten_prop_style(value, opts.merge({:prefix => key}), output)
+            flatten_prop_style(value, opts.merge(prefix: key), output)
           when Array
             output[key] = value.join(',')
           else
@@ -46,4 +47,3 @@ module BB
     end
   end
 end
-

data/lib/blackbox/number.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
 require 'blackbox/hash'
 
 module BB
   # String utilities.
   module Number
     class << self
-      STORAGE_UNITS = ['byte', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'].freeze
+      STORAGE_UNITS = %w(byte k M G T P E Z Y).freeze
 
       ##
-      # Formats the bytes in +size+ into a more understandable representation
+      # Formats the bytes in +number+ into a more understandable representation
       # (e.g., giving it 1500 yields 1.5k). This method is useful for
       # reporting file sizes to users. This method returns nil if
-      # +size+ cannot be converted into a number. You can customize the
+      # +number+ cannot be converted into a number. You can customize the
       # format in the +options+ hash.
       #
       # @overload to_human_size(number, options={})
@@ -42,124 +43,140 @@ module BB
       #   to_human_size(483989, :precision => 0)                      # => 473k
       #   to_human_size(1234567, :precision => 2, :separator => ',')  # => 1,18M
       #
-      def to_human_size(number, args={})
-         return nil if number.nil?
-
-         options = BB::Hash.symbolize_keys(args)
-
-         precision ||= (options[:precision] || 1)
-         separator ||= (options[:separator] || '.')
-         delimiter ||= (options[:delimiter] || '')
-         kilo      ||= (options[:kilo] || 1024)
-         storage_units_format ||= (options[:format] || '%n%u')
+      def to_human_size(number, args = {})
+        begin
+           Float(number)
+         rescue
+           return nil
+         end
 
-         if number.to_i < kilo
-           storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, '')
-         else
-           max_exp  = STORAGE_UNITS.size - 1
-           number   = Float(number)
-           exponent = (Math.log(number) / Math.log(kilo)).to_i # Convert to base
-           exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
-           number  /= kilo ** exponent
+        options = BB::Hash.symbolize_keys(args)
 
-           unit = STORAGE_UNITS[exponent]
+        precision ||= (options[:precision] || 1)
+        separator ||= (options[:separator] || '.')
+        delimiter ||= (options[:delimiter] || '')
+        kilo      ||= (options[:kilo] || 1024)
+        storage_units_format ||= (options[:format] || '%n%u')
 
-           begin
-             escaped_separator = Regexp.escape(separator)
-             formatted_number = with_precision(number,
-               :precision => precision,
-               :separator => separator,
-               :delimiter => delimiter
-             ).sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
-             storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
-           rescue => e
-             number
-           end
-         end
-       end
+        begin
+          if number.to_i < kilo
+            storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, '')
+          else
+            max_exp  = STORAGE_UNITS.size - 1
+            number   = Float(number)
+            exponent = (Math.log(number) / Math.log(kilo)).to_i # Convert to base
+            exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
+            number  /= kilo**exponent
 
-       ##
-       # Formats a +number+ with the specified level of <tt>:precision</tt> (e.g., 112.32 has a precision of 2).
-       # You can customize the format in the +options+ hash.
-       #
-       # @overload with_precision(number, options={})
-       #   @param [Fixnum, Float] number
-       #     Number value to format.
-       #   @param [Hash] options
-       #     Options for formatter.
-       #   @option options [Fixnum] :precision (3)
-       #     Sets the level of precision.
-       #   @option options [String] :separator (".")
-       #     Sets the separator between the units.
-       #   @option options [String] :delimiter ("")
-       #     Sets the thousands delimiter.
-       #
-       # @return [String] The formatted representation of the number.
-       #
-       # @example
-       #   with_precision(111.2345)                    # => 111.235
-       #   with_precision(111.2345, :precision => 2)   # => 111.23
-       #   with_precision(13, :precision => 5)         # => 13.00000
-       #   with_precision(389.32314, :precision => 0)  # => 389
-       #   with_precision(1111.2345, :precision => 2, :separator => ',', :delimiter => '.')
-       #   # => 1.111,23
-       #
-       def with_precision(number, args)
-         options = BB::Hash.symbolize_keys(args)
+            unit = STORAGE_UNITS[exponent]
 
-         precision ||= (options[:precision] || 3)
-         separator ||= (options[:separator] || '.')
-         delimiter ||= (options[:delimiter] || '')
+            escaped_separator = Regexp.escape(separator)
+            formatted_number = with_precision(number,
+                                              precision: precision,
+                                              separator: separator,
+                                              delimiter: delimiter
+                                             ).sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
+            storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
+          end
+        rescue
+          number
+        end
+      end
 
-         begin
-           rounded_number = (Float(number) * (10 ** precision)).round.to_f / 10 ** precision
-           with_delimiter("%01.#{precision}f" % rounded_number,
-             :separator => separator,
-             :delimiter => delimiter)
+      ##
+      # Formats a +number+ with the specified level of <tt>:precision</tt> (e.g., 112.32 has a precision of 2).
+      # This method returns nil if +number+ cannot be converted into a number.
+      # You can customize the format in the +options+ hash.
+      #
+      # @overload with_precision(number, options={})
+      #   @param [Fixnum, Float] number
+      #     Number value to format.
+      #   @param [Hash] options
+      #     Options for formatter.
+      #   @option options [Fixnum] :precision (3)
+      #     Sets the level of precision.
+      #   @option options [String] :separator (".")
+      #     Sets the separator between the units.
+      #   @option options [String] :delimiter ("")
+      #     Sets the thousands delimiter.
+      #
+      # @return [String] The formatted representation of the number.
+      #
+      # @example
+      #   with_precision(111.2345)                    # => 111.235
+      #   with_precision(111.2345, :precision => 2)   # => 111.23
+      #   with_precision(13, :precision => 5)         # => 13.00000
+      #   with_precision(389.32314, :precision => 0)  # => 389
+      #   with_precision(1111.2345, :precision => 2, :separator => ',', :delimiter => '.')
+      #   # => 1.111,23
+      #
+      def with_precision(number, args)
+        begin
+           Float(number)
          rescue
-           number
+           return nil
          end
-       end
 
-       ##
-       # Formats a +number+ with grouped thousands using +delimiter+ (e.g., 12,324). You can
-       # customize the format in the +options+ hash.
-       #
-       # @overload with_delimiter(number, options={})
-       #   @param [Fixnum, Float] number
-       #     Number value to format.
-       #   @param [Hash] options
-       #     Options for formatter.
-       #   @option options [String] :delimiter (", ")
-       #     Sets the thousands delimiter.
-       #   @option options [String] :separator (".")
-       #     Sets the separator between the units.
-       #
-       # @return [String] The formatted representation of the number.
-       #
-       # @example
-       #   with_delimiter(12345678)                        # => 12,345,678
-       #   with_delimiter(12345678.05)                     # => 12,345,678.05
-       #   with_delimiter(12345678, :delimiter => ".")     # => 12.345.678
-       #   with_delimiter(12345678, :separator => ",")     # => 12,345,678
-       #   with_delimiter(98765432.98, :delimiter => " ", :separator => ",")
-       #   # => 98 765 432,98
-       #
-       def with_delimiter(number, args)
-         options = BB::Hash.symbolize_keys(args)
+        options = BB::Hash.symbolize_keys(args)
+
+        precision ||= (options[:precision] || 3)
+        separator ||= (options[:separator] || '.')
+        delimiter ||= (options[:delimiter] || '')
 
-         delimiter ||= (options[:delimiter] || '.')
-         separator ||= (options[:separator] || ',')
+        begin
+          rounded_number = (Float(number) * (10**precision)).round.to_f / 10**precision
+          with_delimiter("%01.#{precision}f" % rounded_number,
+                         separator: separator,
+                         delimiter: delimiter)
+        rescue
+          number
+        end
+      end
 
-         begin
-           parts = number.to_s.split('.')
-           parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
-           parts.join(separator)
+      ##
+      # Formats a +number+ with grouped thousands using +delimiter+ (e.g., 12,324).
+      # This method returns nil if +number+ cannot be converted into a number.
+      # You can customize the format in the +options+ hash.
+      #
+      # @overload with_delimiter(number, options={})
+      #   @param [Fixnum, Float] number
+      #     Number value to format.
+      #   @param [Hash] options
+      #     Options for formatter.
+      #   @option options [String] :delimiter (", ")
+      #     Sets the thousands delimiter.
+      #   @option options [String] :separator (".")
+      #     Sets the separator between the units.
+      #
+      # @return [String] The formatted representation of the number.
+      #
+      # @example
+      #   with_delimiter(12345678)                        # => 12,345,678
+      #   with_delimiter(12345678.05)                     # => 12,345,678.05
+      #   with_delimiter(12345678, :delimiter => ".")     # => 12.345.678
+      #   with_delimiter(12345678, :separator => ",")     # => 12,345,678
+      #   with_delimiter(98765432.98, :delimiter => " ", :separator => ",")
+      #   # => 98 765 432,98
+      #
+      def with_delimiter(number, args = {})
+        begin
+           Float(number)
          rescue
-           number
+           return nil
          end
-       end
-     end
-   end
-end
+        options = BB::Hash.symbolize_keys(args)
 
+        delimiter ||= (options[:delimiter] || ',')
+        separator ||= (options[:separator] || '.')
+
+        begin
+          parts = number.to_s.split('.')
+          parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+          parts.join(separator)
+        rescue
+          number
+        end
+      end
+    end
+  end
+end

data/lib/blackbox/string.rb

@@ -1,17 +1,17 @@
+# frozen_string_literal: true
 module BB
   # String utilities.
   module String
-    class << self 
+    class << self
       # Strip ANSI escape sequences from String.
       #
       # @param [String] text Input string (dirty)
       # @return [String] Output string (cleaned)
       def strip_ansi(text)
-        text.gsub(/\x1b(\[|\(|\))[;?0-9]*[0-9A-Za-z]/, '').
-                  gsub(/\x1b(\[|\(|\))[;?0-9]*[0-9A-Za-z]/, '').
-                  gsub(/(\x03|\x1a)/, '')
+        text.gsub(/\x1b(\[|\(|\))[;?0-9]*[0-9A-Za-z]/, '')
+            .gsub(/\x1b(\[|\(|\))[;?0-9]*[0-9A-Za-z]/, '')
+            .gsub(/(\x03|\x1a)/, '')
       end
     end
   end
 end
-

data/lib/blackbox/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module BB
-  VERSION = "1.1.2"
+  VERSION = '3.1.1'
 end

data/spec/blackbox_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 require 'blackbox/version'
 
@@ -6,4 +7,3 @@ describe BB do
     expect(BB::VERSION).not_to be_nil
   end
 end
-

data/spec/crypto_spec.rb

@@ -1,49 +1,50 @@
+# frozen_string_literal: true
 require 'spec_helper'
 require 'blackbox/crypto'
 require 'base64'
 
-OPENSSL_CIPHERS = %w[aes-128-cbc    aes-128-ecb    aes-192-cbc    aes-192-ecb    aes-256-cbc]+
-                  %w[aes-256-ecb    bf             bf-cbc         bf-cfb]+
-                  %w[bf-ecb         bf-ofb         cast           cast-cbc       cast5-cbc]+
-                  %w[cast5-cfb      cast5-ecb      cast5-ofb      des            des-cbc]+
-                  %w[des-cfb        des-ecb        des-ede        des-ede-cbc    des-ede-cfb]+
-                  %w[des-ede-ofb    des-ede3       des-ede3-cbc   des-ede3-cfb   des-ede3-ofb]+
-                  %w[des-ofb        des3           desx           rc2            rc2-40-cbc]+
-                  %w[rc2-64-cbc     rc2-cbc        rc2-cfb        rc2-ecb        rc2-ofb]+
-                  %w[rc4            rc4-40]
+OPENSSL_CIPHERS = %w(aes-128-cbc    aes-128-ecb    aes-192-cbc    aes-192-ecb    aes-256-cbc) +
+                  %w(aes-256-ecb    bf             bf-cbc         bf-cfb) +
+                  %w(bf-ecb         bf-ofb         cast           cast-cbc       cast5-cbc) +
+                  %w(cast5-cfb      cast5-ecb      cast5-ofb      des            des-cbc) +
+                  %w(des-cfb        des-ecb        des-ede        des-ede-cbc    des-ede-cfb) +
+                  %w(des-ede-ofb    des-ede3       des-ede3-cbc   des-ede3-cfb   des-ede3-ofb) +
+                  %w(des-ofb        des3           desx           rc2            rc2-40-cbc) +
+                  %w(rc2-64-cbc     rc2-cbc        rc2-cfb        rc2-ecb        rc2-ofb) +
+                  %w(rc4            rc4-40)
 
-TEST_KEY='12345678901234567890123456789012'
-TEST_IV ='x234567890123456789012345678901x'
-TEST_TEXT_SHORT='[SHORT_TEST]'*16
-TEST_TEXT_LONG='[LONG_TEST]'*8192
+TEST_KEY = '12345678901234567890123456789012'
+TEST_IV = 'x234567890123456789012345678901x'
+TEST_TEXT_SHORT = '[SHORT_TEST]' * 16
+TEST_TEXT_LONG = '[LONG_TEST]' * 8192
 
 describe BB::Crypto do
   OPENSSL_CIPHERS.each do |cipher|
-    describe "#{cipher}" do
+    describe cipher.to_s do
       [[:encrypt, :decrypt],
        [:encrypt_base64, :decrypt_base64],
        [:encrypt_urlsafe_base64, :decrypt_urlsafe_base64]].each do |e|
         m_enc, m_dec = e
         describe "#{m_enc}, #{m_dec}" do
-          it "can decrypt what it encrypted (short string, random iv)" do
+          it 'can decrypt what it encrypted (short string, random iv)' do
             ct = BB::Crypto.send(m_enc, TEST_TEXT_SHORT, TEST_KEY, cipher)
             pt = BB::Crypto.send(m_dec, ct, TEST_KEY, cipher)
             expect(pt).to eq(TEST_TEXT_SHORT)
           end
 
-          it "can decrypt what it encrypted (long string, random iv)" do
+          it 'can decrypt what it encrypted (long string, random iv)' do
             ct = BB::Crypto.send(m_enc, TEST_TEXT_LONG, TEST_KEY, cipher)
             pt = BB::Crypto.send(m_dec, ct, TEST_KEY, cipher)
             expect(pt).to eq(TEST_TEXT_LONG)
           end
 
-          it "can decrypt what it encrypted (long string, static iv)" do
+          it 'can decrypt what it encrypted (long string, static iv)' do
             ct = BB::Crypto.send(m_enc, TEST_TEXT_LONG, TEST_KEY, cipher, TEST_IV)
             pt = BB::Crypto.send(m_dec, ct, TEST_KEY, cipher, TEST_IV)
             expect(pt).to eq(TEST_TEXT_LONG)
           end
 
-          it "returns consistent output with static iv" do
+          it 'returns consistent output with static iv' do
             a = BB::Crypto.send(m_enc, TEST_TEXT_SHORT, TEST_KEY, cipher, TEST_IV)
             b = BB::Crypto.send(m_enc, TEST_TEXT_SHORT, TEST_KEY, cipher, TEST_IV)
             expect(a).to eq(b)
@@ -51,15 +52,15 @@ describe BB::Crypto do
         end
       end
 
-      describe "encrypt_base64" do
-        it "returns base64 string" do
+      describe 'encrypt_base64' do
+        it 'returns base64 string' do
           ct = BB::Crypto.encrypt_base64(TEST_TEXT_LONG, TEST_KEY)
           Base64.decode64(ct)
         end
       end
 
-      describe "encrypt_urlsafe_base64" do
-        it "returns urlsafe base64 string" do
+      describe 'encrypt_urlsafe_base64' do
+        it 'returns urlsafe base64 string' do
           ct = BB::Crypto.encrypt_urlsafe_base64(TEST_TEXT_LONG, TEST_KEY)
           Base64.urlsafe_decode64(ct)
         end
@@ -67,4 +68,3 @@ describe BB::Crypto do
     end
   end
 end
-