helpema 3.1.210909 → 4.0.221210

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06db87416d69a4ed736c20927d8f9d3c379d7654cbd3e85f57e6e44a5571098e
-  data.tar.gz: e0f8202e576a5ba7d7fb30ec1b045bc8da3bf1c696bf98874b30c032820e45a8
+  metadata.gz: a67c2f9a3a5481f978441ef416a1728d754002990dfb03237c949631836ead05
+  data.tar.gz: 54b942322fa0059c494a45d7ba8a63b2266ea83a2486cfa32beb0c27f95c1fd4
 SHA512:
-  metadata.gz: 0e59e80e64f0c88ac0a0948ff773b9238f7334939231d70c70aec105217962cc4e3e68276b29013cb4e22eec57e392031b2f927c690d29d35999ca236860b1ee
-  data.tar.gz: aaddb40d73e6d372d50ff61244232dbc998076806dcc3903fefd1c46647e3f739bfd9b0b0d6d29ab4b56c8bfb0411d2314bee2505ceae11c90ffeb717b2cf781
+  metadata.gz: a36106b836f299738037425d8087c51fbb977783d3b76ccfe18235ac07f2b0a5dfcdbaf8f1996fedf04793f88d2864ae04c05ba1edb158117797d7dee92d13f6
+  data.tar.gz: 10c6abdeb86321c0b64f8fd275dc25e12c9cd4d2ae2e82dfb864f9898f42c3633202b79afe88f962732e5be9b97638a4cc181c1ce2eb3860a3b2ae967fbbf645

data/README.md

@@ -1,6 +1,6 @@
 # Helpema
 
-* [VERSION 3.1.210909](https://github.com/carlosjhr64/helpema/releases)
+* [VERSION 4.0.221210](https://github.com/carlosjhr64/helpema/releases)
 * [github](https://github.com/carlosjhr64/helpema)
 * [rubygems](https://rubygems.org/gems/helpema)
 
@@ -8,7 +8,7 @@
 
 Meant to be an eclectic collection of useful single functions and wrappers.
 
-Featured method: `requires "good ~>3.0", "bad ~>2.7", "ugly ~>1.8"`
+Featured function: `Helpema.requires "good ~>3.0", "bad ~>2.7", "ugly ~>1.8"`
 
 ## INSTALL:
 
@@ -18,95 +18,132 @@ $ gem install helpema
 
 ## SYNOPSIS:
 
+### Helpema.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'
+Helpema.requires'
 ruby          ~>3.0
-helpema       ~>3.1
-base_convert  ~>4.0
-entropia      ~>0.1'
+helpema       ~>4.0
+base_convert  ~>6.0
+entropia      ~>1.0'
 #=> ["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"
-
+```
+### Helpema::Refinements
+```ruby
+using Helpema::Refinements
+RUBY_VERSION.satisfies?('~>3.1')  #=> true
+'2.7.5'.satisfies?('~>3.1')       #=> false
+begin
+  requires 'ruby ~>9000'
+rescue
+  msg = $!.message
+end
+msg #=> "ruby 3.1.2 not ~>9000"
+```
+### Helpema::Piper
+```ruby
+include Helpema
+# These will raise RuntimeError unless version matches:
+Piper.validate_command('ruby', '^ruby 3.1.2p20', '--version')
+Piper.validate_command('ssss-split', 'Version: 0\.[567]$', '-v')
+# Piper.run_command(cmd, options={}, script:nil, usage=nil, synonyms:nil,
+#                   mode:'r', exception:nil, forward_pass:nil **popt, &blk)
+# Too many features to fully cover in a synopsis...
+Piper.run_command('date',{d: 'Dec 31, 2020',I: true}) #=> "2020-12-31\n"
+Piper.run_command('bash',script:'echo "Hello"',mode:'w+') #=> "Hello\n"
+Piper.run_command('fish',script:'false',mode:'w',exception:false) #=> false
+begin
+  Piper.run_command('fish',script:'false',mode:'w',exception:'Ooops!')
+rescue
+  msg = $!.message
+end
+msg #=> "Ooops!"
+```
+### Helpema::Piper::Refinements
+```ruby
+using Piper::Refinements
+{d: 'Dec 31, 2020',I: true}.to_args        #=> ["-d", "Dec 31, 2020", "-I"]
+{'date=': '2022-12-10', wut: true}.to_args #=> ["--date=2022-12-10", "--wut"]
+```
+### extend Helpema::Piper
+```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 ###
-# 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/]}
-
+# Create a method out of a system command.
+module System
+  extend Helpema::Piper
+  define_command(:date, cmd: 'date', usage: {d: nil, I: true}, synonyms: {string: :d})
+  extend self
+end
+System.date(string: 'Dec 31, 2020') #=> "2020-12-31\n"
+```
+### Helpema::Rubish
+```ruby
+# Predefined Rubish:
+Rubish.bash 'echo "Hello!"' #=> "Hello!\n"
+Rubish.bash? 'which ruby' #=> true
+Rubish.fish? 'false'      #=> false
+# Define you own Rubish shell call:
+Rubish.shell('ruby', default:'puts RUBY_VERSION')
+Rubish.ruby #=> "3.1.2\n"
+Rubish.ruby('puts "Hello!"') #=> "Hello!\n"
+# And define you own Rubish command call:
+Rubish.command('which', usage:{arg0:nil})
+def which(cmd) = Rubish.which(arg0:cmd)
+which 'echo' # "/usr/bin/echo\n"
+```
+### Helpema::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}
+Helpema::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
-
+string_or_nil = Helpema::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)
+encrypted = Helpema::GPG.encrypt(passphrase: '<Secret>', string: '<Plain Text>')
+decrypted = Helpema::GPG.decrypt(passphrase: '<Secret>', string: encrypted)
 #=> "<Plain Text>"
 ## File to File
 # Got a text file...
@@ -115,9 +152,9 @@ decrypted = GPG.decrypt(passphrase: '<Secret>', string: encrypted)
 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') #=> ""
+Helpema::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') #=> ""
+Helpema::GPG.decrypt(passphrase: '<Secret>', input: 'tmp/text.enc', output: 'tmp/text.dec') #=> ""
 # Decrypted file should match...
 `md5sum tmp/text.dec` #~> ^d27b3111fdeb72f2862909c216214bc1
 ## IO to IO
@@ -125,25 +162,20 @@ require 'stringio'
 pio = StringIO.new '<Plain>'
 eio = StringIO.new ''
 dio = StringIO.new ''
-GPG.encrypt(passphrase: '<Secret>', ioin: pio, ioout: eio)
+Helpema::GPG.encrypt(passphrase: '<Secret>', ioin: pio, ioout: eio)
 eio.rewind
-GPG.decrypt(passphrase: '<Secret>', ioin: eio, ioout: dio)
+Helpema::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.
++ Command version mismatch: set `Helpema::WRAPPER.version = "your.version"` or just nil it.
 
 ## LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2021 CarlosJHR64
+Copyright (c) 2022 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 Piper
+
+    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

@@ -1,8 +1,9 @@
 module Helpema
   module GPG
-    extend Helpema
+    extend Piper
     class << self; attr_accessor :version; end
-    GPG.version = '^gpg \\(GnuPG\\) 2\.[234]\.' # version as of this writing is 2.2.27
+    # version as of this writing is 2.2.27
+    GPG.version = '^gpg \\(GnuPG\\) 2\.[234]\.'
 
     GPG.define_command(:cryptor,
       cmd: 'gpg', version: GPG.version,

data/lib/helpema/piper.rb

@@ -0,0 +1,104 @@
+module Helpema
+  module Piper
+    module Refinements
+      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 ::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
+      refine ::Array do
+        def to_arg
+          Piper.to_arg(*self)
+        end
+      end
+    end
+
+    def Piper.validate_command(cmd, version, flag='--version')
+      raise "`#{cmd} #{flag}` !~ #{version}" unless
+      `#{cmd} #{flag}`.strip.match?(version)
+    end
+
+    # Note: popt is IO.popen's options(think of it as "pipe's options").
+    def define_command(name,
+                       cmd:name.to_s.chomp('?').chomp('!'),
+                       version:nil, v:nil,
+                       usage:nil,   synonyms:nil,
+                       mode:'r',    exception:nil, default:nil,
+                       **popt,      &forward_pass)
+      raise "bad name or cmd" unless name=~/^\w+[?!]?$/ and cmd=~/^[\w.\-]+$/
+      Piper.validate_command(cmd, version) if version
+      Piper.validate_command(cmd, v, '-v') if v
+      define_method(name) do |script=default, **options, &blk|
+        if mode[0]=='w'
+          raise 'need script to write' unless script or blk or forward_pass
+        else
+          raise 'cannot write script' if script
+        end
+        Piper.run_command(cmd, options, script:script,
+          usage:usage, synonyms:synonyms, mode:mode,
+          exception:exception, forward_pass:forward_pass, **popt, &blk)
+      end
+    end
+
+    using Refinements
+
+    def Piper.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
+
+    # Assume caller knows what it's doing(no dummy proofing here)
+    def Piper.run_command(cmd, options={}, script:nil,
+      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|
+        pipe.write script if script
+        if forward_pass
+          ret = forward_pass.call(pipe, options, blk)
+        elsif blk
+          ret = blk.call(pipe, options)
+        elsif mode=='r'
+          ret = pipe.read
+        elsif mode=='w+'
+          pipe.close_write
+          ret = pipe.read
+        end
+      end
+      # False exception instead of nil or "an error message"
+      # flags the expected behavior as defined:
+      success = ($?.exitstatus==0)
+      raise(exception) if exception and not success
+      return success if exception==false
+      return ret
+    end
+  end
+end

data/lib/helpema/rubish.rb

@@ -0,0 +1,40 @@
+module Helpema
+  module Rubish
+    extend Piper
+    def Rubish.shell(name,
+                     cmd:name.to_s.chomp('?').chomp('!'),
+                     version:nil,    v:nil,
+                     usage:nil,      synonyms:nil,
+                     exception:nil,  default:nil)
+      if name[-1]=='?'
+        mode = 'w'
+        exception = false unless exception
+      else
+        mode = 'w+'
+      end
+      Rubish.define_command(name.to_sym,
+                            cmd:cmd,
+                            version:version, v:v,
+                            usage:usage,     synonyms:synonyms,
+                            mode:mode,       exception:exception,
+                            default:default) # default script
+    end
+    Rubish.shell :fish
+    Rubish.shell :fish?
+    Rubish.shell :bash
+    Rubish.shell :bash?
+    def Rubish.command(name,
+                      cmd:name.to_s.chomp('?').chomp('!'),
+                      version:nil, v:nil,
+                      usage:nil,   synonyms:nil, exception:nil)
+      mode = 'r'
+      exception = false if name[-1]=='?' and not exception
+      Rubish.define_command(name.to_sym,
+                            cmd:cmd,
+                            version:version, v:v,
+                            usage:usage,     synonyms:synonyms,
+                            mode:mode,       exception:exception)
+    end
+    extend self
+  end
+end

data/lib/helpema/ssss.rb

@@ -1,9 +1,13 @@
 module Helpema
   module SSSS
-    extend Helpema
+    extend Piper
     class << self; attr_accessor :version; end
     SSSS.version = 'Version: 0\.[567]\b' # version as of this writing is 0.5
 
+    # To enforce a method signature, I wrap a `public` method around a
+    # `_private` `define_command` method.  A `define_command` method looks like
+    # `_private(script=default,**options,&blk)`
+
     SSSS.define_command(:_split,
       cmd: 'ssss-split', v: SSSS.version,
       usage: {Q:true,t:2,n:3,w:nil,s:nil,x:false},

data/lib/helpema/youtubedl.rb

@@ -2,7 +2,7 @@ require 'json'
 
 module Helpema
   module YouTubeDL
-    extend Helpema
+    extend Piper
     class << self; attr_accessor :version; end
     YouTubeDL.version = '^202\d\.[01]\d\.[0123]\d$'
 
@@ -21,6 +21,23 @@ module Helpema
     end
     def json(url, &blk) = YouTubeDL._json(url:url, &blk)
 
+    YouTubeDL.define_command(:_mp3,
+      cmd: 'youtube-dl', version: YouTubeDL.version,
+      usage: { output: nil,
+               format: true,
+               arg0: 'bestaudio',
+               'extract-audio': true,
+               'audio-format': true,
+               arg1: 'mp3',
+               'audio-quality': true,
+               arg2: 0,
+               arg3: nil },
+      synonyms: {url: :arg3},
+      err: '/dev/null')
+
+    def mp3(url, output:'%(id)s.%(ext)s') =
+      YouTubeDL._mp3(url:url, output:output)
+
     extend self
   end
 end

data/lib/helpema/zbar.rb

@@ -2,10 +2,10 @@ require 'tmpdir'
 
 module Helpema
   module ZBar
-    extend Helpema
+    extend Piper
     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']
+    ZBar.screenshot = ['scrot']
 
     def snapshot(filename)
       system(*ZBar.screenshot, filename)

data/lib/helpema.rb

@@ -1,12 +1,56 @@
 module Helpema
-  VERSION = '3.1.210909'
-
-  require_relative     'helpema/helpema'
+  VERSION = '4.0.221210'
 
+  autoload :Piper,     'helpema/piper.rb'
+  autoload :Rubish,    'helpema/rubish.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'
+
+  module Refinements
+    refine ::String do
+      def satisfies?(*reqs)
+        Gem::Requirement.new(*reqs).satisfied_by? Gem::Version.new(self)
+      end
+    end
+
+    refine ::Kernel do
+      def requires(*list)
+        loaded = []
+        list.each do |gems|
+          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
+        return loaded
+      end
+    end
+  end
+
+  using Refinements
+  def Helpema.requires(*list)
+    Kernel.requires(*list)
+  end
 end
 
 # Requires:
@@ -16,5 +60,5 @@ end
 #`ssss-combine`
 #`zbarcam`
 #`zbarimg`
-#`gnome-screenshot`
+#`scrot`
 #`gpg`

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: helpema
 version: !ruby/object:Gem::Version
-  version: 3.1.210909
+  version: 4.0.221210
 platform: ruby
 authors:
 - CarlosJHR64
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-09 00:00:00.000000000 Z
+date: 2022-12-10 00:00:00.000000000 Z
 dependencies: []
 description: |
   Meant to be an eclectic collection of useful single functions and wrappers.
 
-  Featured method: `requires "good ~>3.0", "bad ~>2.7", "ugly ~>1.8"`
+  Featured function: `Helpema.requires "good ~>3.0", "bad ~>2.7", "ugly ~>1.8"`
 email: carlosjhr64@gmail.com
 executables: []
 extensions: []
@@ -21,8 +21,10 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/helpema.rb
+- lib/helpema/ffmpeg.rb
 - lib/helpema/gpg.rb
-- lib/helpema/helpema.rb
+- lib/helpema/piper.rb
+- lib/helpema/rubish.rb
 - lib/helpema/ssss.rb
 - lib/helpema/youtubedl.rb
 - lib/helpema/zbar.rb
@@ -30,7 +32,7 @@ homepage: https://github.com/carlosjhr64/helpema
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -45,16 +47,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 3.0.2p107 (2021-07-07 revision 0db68f0233) [x86_64-linux]'
+- 'ruby: ruby 3.1.2p20 (2022-04-12 revision 4491bb740a) [aarch64-linux]'
 - 'youtube-dl: 2021.06.06'
 - 'ssss-split: 0.5'
 - 'ssss-combine: 0.5'
-- 'zbarcam: 0.23'
-- 'zbarimg: 0.23'
-- 'gnome-screenshot: gnome-screenshot 40.0'
+- 'zbarcam: 0.23.90'
+- 'zbarimg: 0.23.90'
+- 'scrot: scrot version 1.5'
 - 'gpg: gpg (GnuPG) 2.2.27'
-rubygems_version: 3.2.22
-signing_key:
+rubygems_version: 3.3.7
+signing_key: 
 specification_version: 4
 summary: Meant to be an eclectic collection of useful single functions and wrappers.
 test_files: []

data/lib/helpema/helpema.rb

@@ -1,118 +0,0 @@
-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_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
-    return loaded
-  end
-
-  extend self
-end