helpema 2.0.200124 → 3.1.210909

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99e52f3d2144ddf05fe8d83ef1a3929a62c43bd68fb8c7db11d360dd2288fe5a
-  data.tar.gz: 636874ab3c6c109751825ec67fd08ae8aff7a18e7adf37b134f4c9ede3c6cc5f
+  metadata.gz: 06db87416d69a4ed736c20927d8f9d3c379d7654cbd3e85f57e6e44a5571098e
+  data.tar.gz: e0f8202e576a5ba7d7fb30ec1b045bc8da3bf1c696bf98874b30c032820e45a8
 SHA512:
-  metadata.gz: 2a22a1de5d55755b4b8481f73d9710cf8472c1e8ad5bcd73418147014432641b8d632085efeaf52d9758e536dce79b2d3b295f686ac172c525ea1fca59c3c9c1
-  data.tar.gz: a5e908afbed85d4812f2b9284d3535334c07ccdaf4c78799a0d32c103bac33ec99edb4b36e2f72321aa9c9bd7f37725b4b88a23b051051b88419c54304c49d83
+  metadata.gz: 0e59e80e64f0c88ac0a0948ff773b9238f7334939231d70c70aec105217962cc4e3e68276b29013cb4e22eec57e392031b2f927c690d29d35999ca236860b1ee
+  data.tar.gz: aaddb40d73e6d372d50ff61244232dbc998076806dcc3903fefd1c46647e3f739bfd9b0b0d6d29ab4b56c8bfb0411d2314bee2505ceae11c90ffeb717b2cf781

data/README.md

@@ -1,64 +1,149 @@
-# helpema
+# Helpema
 
-* [VERSION 2.0.200124](https://github.com/carlosjhr64/helpema/releases)
-* [github](https://github/carlosjhr64/helpema)
-* [rubygems](https://rubygems/gems/helpema)
+* [VERSION 3.1.210909](https://github.com/carlosjhr64/helpema/releases)
+* [github](https://github.com/carlosjhr64/helpema)
+* [rubygems](https://rubygems.org/gems/helpema)
 
 ## DESCRIPTION:
 
 Meant to be an eclectic collection of useful single functions and wrappers.
-Wrappers: ssss-split, ssss-combine, zbarcam, youtube-dl -j.
-Funtions: requires("gemname version",...).
 
-More later.
-
-## SYNOPSIS:
-
-    require 'helpema'
-    include HELPEMA
-
-    Helpema.requires <<-GEMS
-      awesome_print ~>1.8
-      base_convert ~>4.0
-      entropia ~>0.1
-    GEMS
-    #=> ["awesome_print", "base_convert", "entropia"]
-    # Returns the list of loaded gems.
-    # For those quick little scripts one writes in one's bin
-    # that annoyingly keep falling out of maintainance... right?
-
-    SSSS.split("Top Secret!", threshold: 2, shares: 3)
-    #~> ^\["1-\h+", "2-\h+", "3-\h+"\]$
-    # Note that the split has random outputs on the same inputs.
-
-    SSSS.combine("3-055562917c41e68c6ab2c8", "1-27bf3cbfe8d2c25c7e8928")
-    #=> Top Secret!
-    # Pregenerated splits combine to reproduce the secret.
-
-    list = []
-    url = 'https://www.youtube.com/watch?v=u4oK3ZSccZI'
-    YouTubeDL.json(url){|json| list.push json}
-    # The url was for just one video
-    list.length #=> 1
-    json = list[0]
-    json['title'] #=> "Fortnite Easy Last Ten"
-
-    ZBar.cam( timeout=3 ) # Reads qrcodes on camera.
-    ZBar.screen # Reads qrcodes on screen.
+Featured method: `requires "good ~>3.0", "bad ~>2.7", "ugly ~>1.8"`
 
 ## INSTALL:
 
-    $ sudo gem install helpema
+```console
+$ gem install helpema
+```
 
-## FEATURES:
+## SYNOPSIS:
 
-* Autoloaded: no need to pick and choose which library component to require.
+```ruby
+require 'helpema'
+include Helpema
+using Helpema
+
+### requires ###
+# Ensure ruby's and helpema's version.
+# Returns the list of loaded gems.
+# For those quick little scripts one writes in one's bin
+# that annoyingly keep falling out of maintainance... right?
+requires'
+ruby          ~>3.0
+helpema       ~>3.1
+base_convert  ~>4.0
+entropia      ~>0.1'
+#=> ["base_convert", "entropia"]
+
+### String#satisfies? ###
+# Uses Gem::Requirement and Gem::Version to check version strings.
+'1.2.3'.satisfies? '~>1.1' #=> true
+'1.2.3'.satisfies? '~>1.3' #=> false
+
+### run_command ###
+# Automates pipe creation to a system command.
+# See the code for all available features.
+run_command('date',{d: 'Dec 31, 2020'}) #=> "Thu Dec 31 12:00:00 AM PST 2020\n"
+
+### define_command ###
+# Creates a method out of a system command.
+# See the code for all available features.
+define_command(:date, cmd: 'date', usage: {d: nil}, synonyms: {string: :d})
+date(string: 'Dec 31, 2020') #=> "Thu Dec 31 12:00:00 AM PST 2020\n"
+
+### to_arg ###
+# A helper function to do system command calls.
+to_arg :q, true             #=> "-q"
+to_arg :quiet, true         #=> "--quiet"
+to_arg :verbose, false      #=> nil
+to_arg :f, '/path-to/file'  #=> ["-f", "/path-to/file"]
+to_arg :geo=, '10x20'       #=> "--geo=10x20"
+to_arg :arg0, 'Hello World' #=> "Hello World"
+
+### Hash#to_args ###
+{ q:       true,
+  quiet:   true,
+	verbose: false,
+	f:       '/path-to/file',
+	:geo= => '10x20',
+  arg0:    'Hello World' }.to_args
+#=> ["-q", "--quiet", "-f", "/path-to/file", "--geo=10x20", "Hello World"]
+
+### Array#classify ###
+# Groups items in Array by class.
+[1, 2.0, :Three, 'Four', /Five/, :Six, 'Seven'].classify
+#=> {Integer=>[1], Float=>[2.0], Symbol=>[:Three, :Six], String=>["Four", "Seven"], Regexp=>[/Five/]}
+
+### SSSS.split ####
+SSSS.split(secret: "Top Secret!", threshold: 2, shares: 3)
+#~> ^\["1-\h+", "2-\h+", "3-\h+"\]$
+# Note that the split has random outputs on the same inputs.
+
+#### SSSS.combine ###
+# Pregenerated splits combine to reproduce the secret.
+SSSS.combine(secrets: ["3-055562917c41e68c6ab2c8", "1-27bf3cbfe8d2c25c7e8928"],
+             threshold: 2)
+#=> "Top Secret!"
+
+### YouTubeDL.json ###
+list = []
+url = 'https://www.youtube.com/watch?v=u4oK3ZSccZI'
+YouTubeDL.json(url){|json| list.push json}
+# The url was for just one video
+list.length #=> 1
+json = list[0]
+json['title'] #=> "Fortnite Easy Last Ten"
+
+### ZBar.screen ###
+# Reads qrcodes on screen.
+string_or_nil = ZBar.screen
+
+### ZBar.cam ###
+# Reads qrcodes from camera.
+# You may want to wrap this one in a Timeout block.
+#     string = ZBar.cam
+
+### GPG Symmetric ###
+## String to String
+encrypted = GPG.encrypt(passphrase: '<Secret>', string: '<Plain Text>')
+decrypted = GPG.decrypt(passphrase: '<Secret>', string: encrypted)
+#=> "<Plain Text>"
+## File to File
+# Got a text file...
+`md5sum tmp/text.txt` #~> ^d27b3111fdeb72f2862909c216214bc1
+# gpg wont overwrite, so need to remove existing...
+File.exist?(_='tmp/text.enc') and File.unlink(_)
+File.exist?(_='tmp/text.dec') and File.unlink(_)
+# Encrypt text file...
+GPG.encrypt(passphrase: '<Secret>', input: 'tmp/text.txt', output: 'tmp/text.enc') #=> ""
+# Decrypt encrypted file...
+GPG.decrypt(passphrase: '<Secret>', input: 'tmp/text.enc', output: 'tmp/text.dec') #=> ""
+# Decrypted file should match...
+`md5sum tmp/text.dec` #~> ^d27b3111fdeb72f2862909c216214bc1
+## IO to IO
+require 'stringio'
+pio = StringIO.new '<Plain>'
+eio = StringIO.new ''
+dio = StringIO.new ''
+GPG.encrypt(passphrase: '<Secret>', ioin: pio, ioout: eio)
+eio.rewind
+GPG.decrypt(passphrase: '<Secret>', ioin: eio, ioout: dio)
+dio.string #=> "<Plain>"
+```
+
+## TROUBLESHOOTING:
+
+Command version mismatch
+: set `Helpema::WRAPPER.version = "your.version"` or just nil it.
+
+More documentation
+: see [sig/helpema.rb](sig/helpema.rbs) for the expected method signatures.
 
 ## LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2020 carlosjhr64
+Copyright (c) 2021 CarlosJHR64
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/helpema/gpg.rb

@@ -0,0 +1,86 @@
+module Helpema
+  module GPG
+    extend Helpema
+    class << self; attr_accessor :version; end
+    GPG.version = '^gpg \\(GnuPG\\) 2\.[234]\.' # version as of this writing is 2.2.27
+
+    GPG.define_command(:cryptor,
+      cmd: 'gpg', version: GPG.version,
+      usage: {
+        quiet: true,
+        batch: true,
+        'passphrase-fd': 0,
+        output: nil,
+        symmetric: nil,
+        decrypt: nil,
+        arg0: nil,
+      },
+      synonyms: {
+        input: :arg0,
+      },
+      mode: 'w+',
+      exception: 'gpg failed'
+    ) do |pipe, options, blk|
+      passphrase, string, ioin, ioout =
+        options.fetch_values(:passphrase, :string, :ioin, :ioout)
+      pipe.puts passphrase
+      Thread.new do
+        if string
+          pipe.write string
+        elsif ioin
+          while c = ioin.getbyte
+            pipe.putc c
+          end
+        end
+        pipe.close_write
+      end
+      if ioout
+        while c = pipe.getbyte
+          ioout.putc c
+        end
+      else
+        pipe.read
+      end
+    end
+
+    def encrypt(passphrase:,
+                string:nil,
+                output:nil,
+                input:nil,
+                ioin:nil,
+                ioout:nil)
+      unless [string,input,ioin].count{_1} == 1
+        raise "Need only one of string, input, or ioin"
+      end
+      raise "Can't have both output and ioout" if output and ioout
+      GPG.cryptor(symmetric:  true,
+                  passphrase: passphrase,
+                  string:     string,
+                  input:      input,
+                  output:     output,
+                  ioin:       ioin,
+                  ioout:      ioout)
+    end
+
+    def decrypt(passphrase:,
+                string:nil,
+                output:nil,
+                input:nil,
+                ioin:nil,
+                ioout:nil)
+      unless [string,input,ioin].count{_1} == 1
+       raise "Need only one of string, input, or ioin"
+      end
+      raise "Can't have both output and ioout" if output and ioout
+      GPG.cryptor(decrypt:    true,
+                  passphrase: passphrase,
+                  string:     string,
+                  input:      input,
+                  output:     output,
+                  ioin:       ioin,
+                  ioout:      ioout)
+    end
+
+    extend self
+  end
+end

data/lib/helpema/helpema.rb

@@ -1,16 +1,118 @@
-module HELPEMA
 module Helpema
+  refine ::String do
+    def satisfies?(*reqs)
+      Gem::Requirement.new(*reqs).satisfied_by? Gem::Version.new(self)
+    end
+  end
+  refine ::Hash do
+    def to_args(usage:nil, synonyms:nil)
+      # create separate args from self with the translated synonyms
+      args = self.transform_keys(synonyms.to_h)
+      # pad usage's defaults to args
+      usage&.each{|key,default| args[key]=default unless args.has_key? key}
+      # order might be important so enforce usage
+      args = usage&.map{|k,v|[k,args[k]]} || args.to_a
+      # convert key,value tuples to final list of args
+      args.map!(&:to_arg)
+      # get rid of nil
+      args.compact!
+      # ...and finally flatten!
+      args.flatten!
+      return args
+    end
+  end
+  refine ::Array do
+    def classify(hash: Hash.new{|h,k|h[k]=[]})
+      self.each{|v| hash[v.class] << v}
+      return hash
+    end
+    def to_arg
+      Helpema.to_arg(*self)
+    end
+  end
+  refine ::Symbol do
+    def to_flag
+      return nil if self[-1].match?(/\d/) # like :arg0
+      (self.length > 1)? "--#{self}": "-#{self}" # like --verbose or -V
+    end
+  end
+  using Helpema
+
+  def to_arg(key,value)
+    # keep only keys with value(no false or nil)
+    return nil unless value
+    # assume nil0/--long/-short
+    key = key.to_flag
+    if key
+      return key if value==true # a flag
+      return "#{key}#{value}" if key[-1]=='=' # joined key=value
+      return [key,value.to_s]
+    end
+    # It's a Nth arg, like arg0...
+    return value.to_s
+  end
+
+  def run_command(cmd, options={},
+    usage:nil, synonyms:nil, mode:'r',
+    exception:nil, forward_pass:nil, **popt, &blk)
+    args,ret = options.to_args(usage:usage,synonyms:synonyms),nil
+    $stderr.puts "#{cmd} #{args.join(' ')}" if $DEBUG
+    IO.popen([cmd, *args], mode, **popt) do |pipe|
+      ret = forward_pass ? forward_pass.call(pipe, options, blk) :
+                     blk ? blk.call(pipe) :
+                           pipe.read
+    end
+    (exception.nil? or $?.exitstatus==0)? ret : raise(exception)
+  end
+
+  def define_command(name,
+    cmd: name.to_s, version: nil, v: nil,
+    usage: nil, synonyms: nil,
+    mode: 'r',exception: nil,
+    **popt, &forward_pass)
+
+    # which version? --version or -v
+    if version and not `#{cmd} --version`.strip.match?(version)
+      raise "`#{cmd} --version` !~ #{version}"
+    end
+    if v and not `#{cmd} -v`.strip.match?(v)
+      raise "`#{cmd} -v` !~ #{v}"
+    end
+
+    define_method(name) do |**options, &blk|
+      run_command(cmd, options,
+        usage:usage, synonyms:synonyms, mode:mode,
+        exception:exception, forward_pass:forward_pass, **popt, &blk)
+    end
+  end
+
   def requires(*list)
     loaded = []
     list.each do |gems|
-      gems.lines.each do |gemname_version|
-        gemname, *version = gemname_version.split
-        gem gemname, *version  unless version.empty?
+      gems.lines.each do |gemname_reqs|
+        gemname, *reqs = gemname_reqs.split
+        next unless gemname
+        unless reqs.empty?
+          case gemname
+          when 'helpema'
+            unless VERSION.satisfies?(*reqs)
+              raise "helpema #{VERSION} not #{reqs.join(', ')}"
+            end
+            next
+          when 'ruby'
+            unless RUBY_VERSION.satisfies?(*reqs)
+              raise "ruby #{RUBY_VERSION} not #{reqs.join(', ')}"
+            end
+            next
+          else
+            gem gemname, *reqs
+          end
+        end
         require gemname and loaded.push gemname
       end
     end
-    loaded
+    return loaded
   end
+
   extend self
 end
-end

data/lib/helpema/ssss.rb

@@ -1,34 +1,46 @@
-require 'open3'
+module Helpema
+  module SSSS
+    extend Helpema
+    class << self; attr_accessor :version; end
+    SSSS.version = 'Version: 0\.[567]\b' # version as of this writing is 0.5
 
-module HELPEMA
-module SSSS
-  # Note how the function mirrors the command line options.
-  def self.split(secret, t0=2, n0=3,
-                 t: t0, n: n0,
-                 threshold: t, shares: n,
-                 w: nil, s: nil, x: false,
-                 token: w, level: s, hexmode: x)
-    pwds = nil
-    command = "ssss-split -Q -t #{threshold} -n #{shares}"
-    command << " -w #{token}"  if token
-    command << " -s #{level}"  if level
-    command << " -x"           if hexmode
-    Open3.popen3(command) do |stdin, stdout, stderr|
-      stdin.puts secret
-      stdin.close
-      pwds = stdout.read.split("\n")
+    SSSS.define_command(:_split,
+      cmd: 'ssss-split', v: SSSS.version,
+      usage: {Q:true,t:2,n:3,w:nil,s:nil,x:false},
+      synonyms: {threshold: :t, shares: :n, token: :w,  level: :s, hexmode: :x},
+      mode: 'w+', exception: 'ssss-split failed.',
+      err: [:child, :out]
+    ) do |pipe, options, blk|
+      pipe.puts options.fetch(:secret)
+      pipe.read.split.last(options[:shares])
     end
-    return pwds
-  end
-
-  def self.combine(*pwds)
-    pwd = ''
-    Open3.popen3("ssss-combine -q -t #{pwds.length}") do |stdin, stdout, stderr|
-      pwds.each{|p| stdin.puts p}
-      stdin.close
-      pwd = stderr.read.split("\n").last
+    def split(
+      secret:, threshold:,
+      shares:, token:nil,
+      level:nil,
+      hexmode:false
+    ) = SSSS._split(
+      secret:secret,
+      threshold:threshold,
+      shares:shares,
+      token:token,
+      level:level,
+      hexmode:hexmode)
+    SSSS.define_command(:_combine,
+      cmd: 'ssss-combine', v: SSSS.version,
+      usage: {Q:true,t:2,x:false}, synonyms: {threshold: :t, hexmode: :x},
+      mode: 'w+', exception: 'ssss-combine failed.',
+      err: [:child, :out]
+    ) do |pipe, options, blk|
+      secrets,n = options.fetch_values(:secrets,:threshold)
+      secrets.first(n).each{pipe.puts _1}
+      pipe.read.lines.last.chomp
+    end
+    def combine(secrets:, threshold:, hexmode:false)
+      raise 'Need threshold number of secrets.' unless secrets.size >= threshold
+      SSSS._combine(secrets:secrets, threshold:threshold, hexmode:hexmode)
     end
-    return pwd
+
+    extend self
   end
 end
-end

data/lib/helpema/youtubedl.rb

@@ -1,20 +1,26 @@
 require 'json'
-require 'open3'
 
-module HELPEMA
-module YouTubeDL
-  def self.json(url, pwd=nil)
-    Open3.popen2e("youtube-dl -j '#{url}'") do |i, o|
-      i.puts pwd if pwd
-      i.close
-      o.each do |line|
+module Helpema
+  module YouTubeDL
+    extend Helpema
+    class << self; attr_accessor :version; end
+    YouTubeDL.version = '^202\d\.[01]\d\.[0123]\d$'
+
+    YouTubeDL.define_command(:_json,
+      cmd: 'youtube-dl', version: YouTubeDL.version,
+      usage: {j:true, arg0:nil}, synonyms: {url: :arg0},
+      err: '/dev/null'
+    ) do |pipe, options, blk|
+      pipe.each do |data|
         begin
-          yield JSON.parse line
-        rescue JSON::ParserError
-          yield line
+          data = JSON.parse data
+        ensure
+          blk.call data
         end
       end
     end
+    def json(url, &blk) = YouTubeDL._json(url:url, &blk)
+
+    extend self
   end
 end
-end

data/lib/helpema/zbar.rb

@@ -1,38 +1,46 @@
-require 'timeout'
 require 'tmpdir'
 
-module HELPEMA
-module ZBar
-  def self.cam(timeout=3)
-    raw = ''
-    IO.popen('zbarcam --nodisplay --raw --prescale=800x800', 'r') do |io|
+module Helpema
+  module ZBar
+    extend Helpema
+    class << self; attr_accessor :version, :screenshot; end
+    ZBar.version = '^0\.2[345]\b' # version as of this writing is 0.23
+    ZBar.screenshot = ['gnome-screenshot', '-f']
+
+    def snapshot(filename)
+      system(*ZBar.screenshot, filename)
+    end
+
+    ZBar.define_command(:_cam,
+                        cmd: 'zbarcam',
+                        version: ZBar.version,
+                        usage: {raw:true,quiet:true,nodisplay:true, :prescale= => '800x800'},
+                        synonyms: {prescale: :prescale=}
+    ) do |pipe, kw, blk|
       begin
-        Timeout.timeout(timeout) do
-          raw << io.gets
-          while q = io.gets
-            break if q=="\n"
-            raw << q
-          end
-          raw.strip!
-        end
-      rescue Timeout::Error
-        raw = nil
-        $stderr.puts $!
+        pipe.gets.chomp # This is the return value!
       ensure
-        Process.kill('INT', io.pid)
+        Process.kill('TERM', pipe.pid)
       end
     end
-    raw
-  end
+    def cam() = ZBar._cam()
 
-  def self.screen
-    raw = nil
-    Dir.mktmpdir do |tmpdir|
-      screenshot = File.join(tmpdir, "#{$$}.#{Time.now.to_f}.png")
-      system "gnome-screenshot -f #{screenshot}"
-      raw = `zbarimg -q --raw #{screenshot}`.strip
+    ZBar.define_command(:_img,
+                        cmd: 'zbarimg',
+                        version: ZBar.version,
+                        usage: {q:true,raw:true,arg0:nil},
+                        synonyms: {filename: :arg0})
+    def img(filename) = ZBar._img(filename:filename)
+
+    def screen
+      raw = nil
+      Dir.mktmpdir do |tmpdir|
+       _ = File.join(tmpdir, "#{$$}.#{Time.now.to_f}.png")
+       raw = _ if ZBar.snapshot(_) and not (_=ZBar.img(_).chomp).empty?
+      end
+      raw
     end
-    raw
+
+    extend self
   end
 end
-end

data/lib/helpema.rb

@@ -1,14 +1,20 @@
-module HELPEMA
-  VERSION = '2.0.200124'
+module Helpema
+  VERSION = '3.1.210909'
+
+  require_relative     'helpema/helpema'
 
-  autoload :Helpema,   'helpema/helpema.rb'
   autoload :SSSS,      'helpema/ssss.rb'
   autoload :YouTubeDL, 'helpema/youtubedl.rb'
   autoload :ZBar,      'helpema/zbar.rb'
+  autoload :GPG,       'helpema/gpg.rb'
 end
+
 # Requires:
 #`ruby`
+#`youtube-dl`
 #`ssss-split`
 #`ssss-combine`
 #`zbarcam`
+#`zbarimg`
 #`gnome-screenshot`
+#`gpg`

metadata

@@ -1,21 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: helpema
 version: !ruby/object:Gem::Version
-  version: 2.0.200124
+  version: 3.1.210909
 platform: ruby
 authors:
-- carlosjhr64
-autorequire: 
+- CarlosJHR64
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-24 00:00:00.000000000 Z
+date: 2021-09-09 00:00:00.000000000 Z
 dependencies: []
 description: |
   Meant to be an eclectic collection of useful single functions and wrappers.
-  Wrappers: ssss-split, ssss-combine, zbarcam, youtube-dl -j.
-  Funtions: requires("gemname version",...).
 
-  More later.
+  Featured method: `requires "good ~>3.0", "bad ~>2.7", "ugly ~>1.8"`
 email: carlosjhr64@gmail.com
 executables: []
 extensions: []
@@ -23,6 +21,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/helpema.rb
+- lib/helpema/gpg.rb
 - lib/helpema/helpema.rb
 - lib/helpema/ssss.rb
 - lib/helpema/youtubedl.rb
@@ -31,7 +30,7 @@ homepage: https://github.com/carlosjhr64/helpema
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -46,15 +45,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux]'
+- 'ruby: ruby 3.0.2p107 (2021-07-07 revision 0db68f0233) [x86_64-linux]'
+- 'youtube-dl: 2021.06.06'
 - 'ssss-split: 0.5'
 - 'ssss-combine: 0.5'
 - 'zbarcam: 0.23'
-- 'gnome-screenshot: gnome-screenshot 3.34.0'
-rubygems_version: 3.1.2
-signing_key: 
+- 'zbarimg: 0.23'
+- 'gnome-screenshot: gnome-screenshot 40.0'
+- 'gpg: gpg (GnuPG) 2.2.27'
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
-summary: 'Meant to be an eclectic collection of useful single functions and wrappers.
-  Wrappers: ssss-split, ssss-combine, zbarcam, youtube-dl -j. Funtions: requires("gemname
-  version",...).'
+summary: Meant to be an eclectic collection of useful single functions and wrappers.
 test_files: []