helpema 2.1.200129 → 3.2.210924

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d18fa86fd912cfcc45ebb9efbdae0f9ae2a207399660fca0b3f0e3ce3b2bad64
-  data.tar.gz: c18e1447a10e90e878644d982e1578965309264eae84c7badc3676c31e1c018b
+  metadata.gz: 958027b0a2546243bae724c0a543197d7632385c0f9049d8e59ed53349b18f4d
+  data.tar.gz: d57d402890e736b580fc052c66308df90a6e29202d467cd4e26714ad11b64331
 SHA512:
-  metadata.gz: e7b98dfb0588da2070870131947cff69d9777d586fe72a7d513e3156c3f78b405e9d513d195ae18a952d099894965c44d0ba06fddd605825c6f06fe86297f604
-  data.tar.gz: f9cedadc0afe83aa718c637fe017555f50931023343ebc24519742b8cc17f89fe87367f4de4eafbfdcf30305b66ce4e0d23c8355ad344e62efa89e3827d42239
+  metadata.gz: dd576603c81835d9610eac6d15487d25d82491eec8de717fcfbe6a16c51c865968d8ac259dddc45e02f2148f7653c6fa5b9ed5be55eb05c878b184df3bc5cdec
+  data.tar.gz: 65f36c77c56ded75225ecd35fe6f6f4bb3581aeff1c3ce1de855f423e65de78e3e69d1131a63e7b18760b1224f27eda14a33c0a41e40e55bef67d8c0cb89b488

data/README.md

@@ -1,90 +1,176 @@
-# helpema
+# Helpema
 
-* [VERSION 2.1.200129](https://github.com/carlosjhr64/helpema/releases)
-* [github](https://github/carlosjhr64/helpema)
-* [rubygems](https://rubygems/gems/helpema)
+* [VERSION 3.2.210924](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
-
-Functions:
-
-* requires("gemname version",...)
-* params(arg,...){|h Hash[Class,Obj]|...}
-
-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?
-
-    s0 = s1  = i = f0 = f1 = r = nil
-    Helpema.params(1, 2.0, 3, "Five", /Six/, "Seven", /Eight/) do |params|
-      s0 = params[String][0]
-      s1 = params[String][1]
-      i  = params[Integer][0]
-      f0 = params[Float][0]
-      f1 = params[Float][1]
-      r  = params[Regexp][0]
-    end
-    s0 #=> "Five"
-    s1 #=> "Seven"
-    i  #=> 1
-    f0 #=> 2.0
-    f1 #=> nil
-    r  #=> /Six/
-
-    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.
+### requires
+```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?
+```ruby
+### 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
+```ruby
+### 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
+```ruby
+### 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
+```ruby
+### 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
+```ruby
+### 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
+```ruby
+### 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
+```ruby
+### 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.
+```
+### SSS.combine
+```ruby
+#### SSSS.combine ###
+# Pregenerated splits combine to reproduce the secret.
+SSSS.combine(secrets: ["3-055562917c41e68c6ab2c8", "1-27bf3cbfe8d2c25c7e8928"],
+             threshold: 2)
+#=> "Top Secret!"
+```
+### YouTubeDL.json
+```ruby
+### 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"
+```
+### YouTubeDL.mp3(url, output: '%(id)s.%(ext)s')
+### FFMPEG.hash(filename, digest: 'sha160')
+### ZBar.screen
+```ruby
+### ZBar.screen ###
+# Reads qrcodes on screen.
+string_or_nil = ZBar.screen
+```
+### ZBar.cam
+```ruby
+### ZBar.cam ###
+# Reads qrcodes from camera.
+# You may want to wrap this one in a Timeout block.
+#     string = ZBar.cam
+```
+### GPG.encrypt and GPG.decrypt
+```ruby
+### 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/ffmpeg.rb

@@ -0,0 +1,23 @@
+module Helpema
+  module FFMPEG
+    extend Helpema
+
+    FFMPEG.define_command(:_hash,
+      cmd: 'ffmpeg',
+      usage: {arg0: '-i',
+              arg1: nil,
+              arg2: '-f',
+              arg3: 'hash',
+              arg4: '-hash',
+              arg5: nil,
+              arg6: '-'},
+      synonyms: {filename: :arg1, digest: :arg5},
+      exception: 'ffmpeg failed',
+      err: '/dev/null')
+    def hash(filename, digest:'sha160')
+      FFMPEG._hash(filename:filename, digest:digest).strip.split('=').last
+    end
+
+    extend self
+  end
+end

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,21 +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
-  end
-
-  def params(*args)
-    yield args.inject(Hash.new{|h,k|h[k]=[]}){|h,v|h[v.class].push(v) && h}
+    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,37 @@
 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)
+
+    YouTubeDL.define_command(:_mp3,
+      cmd: 'youtube-dl', version: YouTubeDL.version,
+      usage: { output: nil,
+               'extract-audio': true,
+               'audio-format': true,
+               arg0: 'mp3',
+               arg1: nil },
+      synonyms: {url: :arg1},
+      err: '/dev/null')
+    def mp3(url, output:'%(id)s.%(ext)s') = YouTubeDL._mp3(url:url, output:output)
+
+    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,21 @@
-module HELPEMA
-  VERSION = '2.1.200129'
+module Helpema
+  VERSION = '3.2.210924'
+
+  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'
+  autoload :FFMPEG,    'helpema/ffmpeg.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.1.200129
+  version: 3.2.210924
 platform: ruby
 authors:
-- carlosjhr64
-autorequire: 
+- CarlosJHR64
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-29 00:00:00.000000000 Z
+date: 2021-09-24 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,8 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/helpema.rb
+- lib/helpema/ffmpeg.rb
+- lib/helpema/gpg.rb
 - lib/helpema/helpema.rb
 - lib/helpema/ssss.rb
 - lib/helpema/youtubedl.rb
@@ -31,7 +31,7 @@ homepage: https://github.com/carlosjhr64/helpema
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -46,15 +46,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: []