cielli 4.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a879b0879f37e07178e19a7a5c2bd444ba2b0e52816ee65447fd20e889ffa620
+  data.tar.gz: 9dae86ada4ae248e61156b8d5b32da04411656b775e9ea767d04c058038c1484
+SHA512:
+  metadata.gz: c5c19a68907b8e0c4f00d90edb0255f87bc68dc583bc9f629e6da3f01a3a3d47e8256583e56e50a09d6812d7a7faf9aa6e47b0a22f89547ccb3b203b8eb4be8c
+  data.tar.gz: 649d20e2a90c9762da2d5c276a20a65d2481e9793982855a5ed343d3dd9604111dcbe298147ab5546343640b0c568c7846c1ce1dba3c4cca4dd5c9955915411b

data/README.md

@@ -0,0 +1,40 @@
+NAME
+====
+cielli
+
+SYNOPSIS
+========
+a minimalist's toolkit for quickly writing well behaved CLI/cee-el-ahy programs
+  
+DESCRIPTION
+===========
+
+cielli is the command line tool your mother wanted you to use.  i learned this [the hard way](https://github.com/ahoward/main].
+
+
+SAMPLES
+=======
+
+  <========< samples/a.rb >========>
+
+  ~ > cat samples/a.rb
+
+    #! /usr/bin/env ruby
+    
+    require 'cielli'
+    
+    cli do
+      run do
+        p [@argv, @options]
+      end
+    end
+
+  ~ > ruby samples/a.rb
+
+    [[], {}]
+
+
+
+INSTALL
+=======
+gem install cielli -v 0.4.2

data/README.md.erb

@@ -0,0 +1,21 @@
+NAME
+====
+<%= This.lib %>
+
+SYNOPSIS
+========
+<%= This.summary %>
+  
+DESCRIPTION
+===========
+
+cielli is the command line tool your mother wanted you to use.  i learned this [the hard way](https://github.com/ahoward/main].
+
+
+SAMPLES
+=======
+<%= samples %>
+
+INSTALL
+=======
+gem install <%= lib %> -v <%= version %>

data/Rakefile

@@ -0,0 +1,389 @@
+This.author = "Ara T. Howard"
+This.email = "ara.t.howard@gmail.com"
+This.homepage = "https://github.com/ahoward/#{ This.lib }"
+
+task :license do
+  open('LICENSE', 'w'){|fd| fd.puts "Ruby"}
+end
+
+task :default do
+  puts((Rake::Task.tasks.map{|task| task.name.gsub(/::/,':')} - ['default']).sort)
+end
+
+task :test do
+  run_tests!
+end
+
+namespace :test do
+  task(:unit){ run_tests!(:unit) }
+  task(:functional){ run_tests!(:functional) }
+  task(:integration){ run_tests!(:integration) }
+end
+
+def run_tests!(which = nil)
+  which ||= '**'
+  test_dir = File.join(This.dir, "test")
+  test_glob ||= File.join(test_dir, "#{ which }/**_test.rb")
+  test_rbs = Dir.glob(test_glob).sort
+        
+  div = ('=' * 119)
+  line = ('-' * 119)
+
+  test_rbs.each_with_index do |test_rb, index|
+    testno = index + 1
+    command = "#{ This.ruby } -w -I ./lib -I ./test/lib #{ test_rb }"
+
+    puts
+    say(div, :color => :cyan, :bold => true)
+    say("@#{ testno } => ", :bold => true, :method => :print)
+    say(command, :color => :cyan, :bold => true)
+    say(line, :color => :cyan, :bold => true)
+
+    system(command)
+
+    say(line, :color => :cyan, :bold => true)
+
+    status = $?.exitstatus
+
+    if status.zero? 
+      say("@#{ testno } <= ", :bold => true, :color => :white, :method => :print)
+      say("SUCCESS", :color => :green, :bold => true)
+    else
+      say("@#{ testno } <= ", :bold => true, :color => :white, :method => :print)
+      say("FAILURE", :color => :red, :bold => true)
+    end
+    say(line, :color => :cyan, :bold => true)
+
+    exit(status) unless status.zero?
+  end
+end
+
+
+task :gemspec do
+  ignore_extensions = ['git', 'svn', 'tmp', /sw./, 'bak', 'gem']
+  ignore_directories = ['pkg']
+  ignore_files = ['test/log']
+
+  shiteless = 
+    lambda do |list|
+      list.delete_if do |entry|
+        next unless test(?e, entry)
+        extension = File.basename(entry).split(%r/[.]/).last
+        ignore_extensions.any?{|ext| ext === extension}
+      end
+      list.delete_if do |entry|
+        next unless test(?d, entry)
+        dirname = File.expand_path(entry)
+        ignore_directories.any?{|dir| File.expand_path(dir) == dirname}
+      end
+      list.delete_if do |entry|
+        next unless test(?f, entry)
+        filename = File.expand_path(entry)
+        ignore_files.any?{|file| File.expand_path(file) == filename}
+      end
+    end
+
+  lib         = This.lib
+  object      = This.object
+  version     = This.version
+  files       = shiteless[Dir::glob("**/**")]
+  executables = shiteless[Dir::glob("bin/*")].map{|exe| File.basename(exe)}
+  #has_rdoc    = true #File.exist?('doc')
+  test_files  = "test/#{ lib }.rb" if File.file?("test/#{ lib }.rb")
+  summary     = object.respond_to?(:summary) ? object.summary : "summary: #{ lib } kicks the ass"
+  description = object.respond_to?(:description) ? object.description : "description: #{ lib } kicks the ass"
+  license     = object.respond_to?(:license) ? object.license : "Ruby"
+
+  if This.extensions.nil?
+    This.extensions = []
+    extensions = This.extensions
+    %w( Makefile configure extconf.rb ).each do |ext|
+      extensions << ext if File.exists?(ext)
+    end
+  end
+  extensions = [extensions].flatten.compact
+
+  if This.dependencies.nil?
+    dependencies = []
+  else
+    case This.dependencies
+      when Hash
+        dependencies = This.dependencies.values
+      when Array
+        dependencies = This.dependencies
+    end
+  end
+
+  template = 
+    if test(?e, 'gemspec.erb')
+      Template{ IO.read('gemspec.erb') }
+    else
+      Template {
+        <<-__
+          ## <%= lib %>.gemspec
+          #
+
+          Gem::Specification::new do |spec|
+            spec.name = <%= lib.inspect %>
+            spec.version = <%= version.inspect %>
+            spec.platform = Gem::Platform::RUBY
+            spec.summary = <%= lib.inspect %>
+            spec.description = <%= description.inspect %>
+            spec.license = <%= license.inspect %>
+
+            spec.files =\n<%= files.sort.pretty_inspect %>
+            spec.executables = <%= executables.inspect %>
+            
+            spec.require_path = "lib"
+
+            spec.test_files = <%= test_files.inspect %>
+
+            <% dependencies.each do |lib_version| %>
+              spec.add_dependency(*<%= Array(lib_version).flatten.inspect %>)
+            <% end %>
+
+            spec.extensions.push(*<%= extensions.inspect %>)
+
+            spec.author = <%= This.author.inspect %>
+            spec.email = <%= This.email.inspect %>
+            spec.homepage = <%= This.homepage.inspect %>
+          end
+        __
+      }
+    end
+
+  Fu.mkdir_p(This.pkgdir)
+  gemspec = "#{ lib }.gemspec"
+  open(gemspec, "w"){|fd| fd.puts(template)}
+  This.gemspec = gemspec
+end
+
+task :gem => [:clean, :gemspec] do
+  Fu.mkdir_p(This.pkgdir)
+  before = Dir['*.gem']
+  cmd = "gem build #{ This.gemspec }"
+  `#{ cmd }`
+  after = Dir['*.gem']
+  gem = ((after - before).first || after.first) or abort('no gem!')
+  Fu.mv(gem, This.pkgdir)
+  This.gem = File.join(This.pkgdir, File.basename(gem))
+end
+
+task :readme do
+  lib = This.lib
+  version = This.version
+
+  samples = nil
+  prompt = '~ > '
+
+  Dir['sample*/*'].sort.each do |sample|
+    samples ||= ''
+
+    samples << "\n" << "  <========< #{ sample } >========>" << "\n\n"
+
+    cmd = "cat #{ sample }"
+    samples << Util.indent(prompt + cmd, 2) << "\n\n"
+    samples << Util.indent(`#{ cmd }`, 4) << "\n"
+
+    cmd = "ruby #{ sample }"
+    samples << Util.indent(prompt + cmd, 2) << "\n\n"
+
+    cmd = "ruby -e'STDOUT.sync=true; exec %(ruby -I ./lib #{ sample })'"
+    samples << Util.indent(`#{ cmd } 2>&1`, 4) << "\n"
+  end
+
+  template = 
+    if test(?e, 'README.md.erb')
+      Template{ IO.read('README.md.erb') }
+    else
+      IO.binread('README.md')
+    end
+
+  open("README.md", "w"){|fd| fd.puts template}
+
+  puts IO.binread("README.md")
+end
+
+task :clean do
+  Dir[File.join(This.pkgdir, '**/**')].each{|entry| Fu.rm_rf(entry)}
+end
+
+task :release => [:clean, :readme, :gemspec, :gem] do
+  gems = Dir[File.join(This.pkgdir, '*.gem')].flatten
+  raise "which one? : #{ gems.inspect }" if gems.size > 1
+  raise "no gems?" if gems.size < 1
+
+  cmd = "gem push #{ This.gem }"
+  puts cmd
+  puts
+  system(cmd)
+  abort("cmd(#{ cmd }) failed with (#{ $?.inspect })") unless $?.exitstatus.zero?
+end
+
+
+
+
+
+BEGIN {
+# support for this rakefile
+#
+  $VERBOSE = nil
+
+  require 'ostruct'
+  require 'erb'
+  require 'fileutils'
+  require 'rbconfig'
+  require 'pp'
+
+# fu shortcut
+#
+  Fu = FileUtils
+
+# cache a bunch of stuff about this rakefile/environment
+#
+  This = OpenStruct.new
+
+  This.file = File.expand_path(__FILE__)
+  This.dir = File.dirname(This.file)
+  This.pkgdir = File.join(This.dir, 'pkg')
+  This.lib = File.basename(Dir.pwd).sub(/[-].*$/, '')
+
+# load _lib
+#
+  _lib = ["./lib/#{ This.lib }/_lib.rb", "./lib/#{ This.lib }.rb"].detect{|l| test(?s, l)}
+  unless _lib
+    abort "could not find a _lib in ./lib!?"
+  end
+  This._lib = _lib
+  require This._lib
+
+
+# extract name from _lib
+#
+  lines = IO.binread(This._lib).split("\n")
+  re = %r`\A \s* (module|class) \s+ ([^\s]+) \s* \z`iomx
+  name = nil
+  lines.each do |line|
+    match = line.match(re)
+    if match
+      name = match.to_a.last
+      break
+    end
+  end
+  unless name
+    abort "could not extract `name` from #{ This._lib }"
+  end
+  This.name = name
+
+# now, fully grok This 
+#
+  This.object = eval(This.name)
+
+  version = This.object.send(:version)
+  This.version = version
+
+  if This.object.respond_to?(:dependencies)
+    This.dependencies = This.object.dependencies
+  end
+
+  if This.object.respond_to?(:summary)
+    This.summary = This.object.summary
+  end
+
+# discover full path to this ruby executable
+#
+  c = RbConfig::CONFIG
+  bindir = c["bindir"] || c['BINDIR']
+  ruby_install_name = c['ruby_install_name'] || c['RUBY_INSTALL_NAME'] || 'ruby'
+  ruby_ext = c['EXEEXT'] || ''
+  ruby = File.join(bindir, (ruby_install_name + ruby_ext))
+  This.ruby = ruby
+
+# some utils
+#
+  module Util
+    def indent(s, n = 2)
+      s = unindent(s)
+      ws = ' ' * n
+      s.gsub(%r/^/, ws)
+    end
+
+    def unindent(s)
+      indent = nil
+      s.each_line do |line|
+      next if line =~ %r/^\s*$/
+      indent = line[%r/^\s*/] and break
+    end
+    indent ? s.gsub(%r/^#{ indent }/, "") : s
+  end
+    extend self
+  end
+
+# template support
+#
+  class Template
+    def initialize(&block)
+      @block = block
+      @template = block.call.to_s
+    end
+    def expand(b=nil)
+      ERB.new(Util.unindent(@template)).result((b||@block).binding)
+    end
+    alias_method 'to_s', 'expand'
+  end
+  def Template(*args, &block) Template.new(*args, &block) end
+
+# colored console output support
+#
+  This.ansi = {
+    :clear      => "\e[0m",
+    :reset      => "\e[0m",
+    :erase_line => "\e[K",
+    :erase_char => "\e[P",
+    :bold       => "\e[1m",
+    :dark       => "\e[2m",
+    :underline  => "\e[4m",
+    :underscore => "\e[4m",
+    :blink      => "\e[5m",
+    :reverse    => "\e[7m",
+    :concealed  => "\e[8m",
+    :black      => "\e[30m",
+    :red        => "\e[31m",
+    :green      => "\e[32m",
+    :yellow     => "\e[33m",
+    :blue       => "\e[34m",
+    :magenta    => "\e[35m",
+    :cyan       => "\e[36m",
+    :white      => "\e[37m",
+    :on_black   => "\e[40m",
+    :on_red     => "\e[41m",
+    :on_green   => "\e[42m",
+    :on_yellow  => "\e[43m",
+    :on_blue    => "\e[44m",
+    :on_magenta => "\e[45m",
+    :on_cyan    => "\e[46m",
+    :on_white   => "\e[47m"
+  }
+  def say(phrase, *args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    options[:color] = args.shift.to_s.to_sym unless args.empty?
+    keys = options.keys
+    keys.each{|key| options[key.to_s.to_sym] = options.delete(key)}
+
+    color = options[:color]
+    bold = options.has_key?(:bold)
+
+    parts = [phrase]
+    parts.unshift(This.ansi[color]) if color
+    parts.unshift(This.ansi[:bold]) if bold
+    parts.push(This.ansi[:clear]) if parts.size > 1
+
+    method = options[:method] || :puts
+
+    Kernel.send(method, parts.join)
+  end
+
+# always run out of the project dir
+#
+  Dir.chdir(This.dir)
+}

data/bin/cielli

@@ -0,0 +1,35 @@
+#! /usr/bin/env ruby
+#  encoding: utf-8
+
+require_relative '../lib/cielli.rb'
+
+cielli do
+  run do
+    puts CLI
+  end
+
+  CLI = <<~________
+    #! /usr/bin/env ruby
+    #  encoding: utf-8
+
+    require 'cielli'
+
+    cielli do
+      help <<~____
+        #{ Cielli.utils.indent(Cielli::DEFAULT_HELP, 4).strip }
+      ____
+
+      run do
+        p [@argv, @options]
+      end
+
+      run(:foo) do
+        p [@mode, @argv, @options]
+      end
+
+      run(:bar) do
+        p [@mode, @argv, @options]
+      end
+    end
+  ________
+end

data/cielli.gemspec

@@ -0,0 +1,41 @@
+## cielli.gemspec
+#
+
+Gem::Specification::new do |spec|
+  spec.name = "cielli"
+  spec.version = "4.2.2"
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = "cielli"
+  spec.description = "description: cielli kicks the ass"
+  spec.license = "Ruby"
+
+  spec.files =
+["README.md",
+ "README.md.erb",
+ "Rakefile",
+ "bin",
+ "bin/cielli",
+ "cielli.gemspec",
+ "lib",
+ "lib/cielli",
+ "lib/cielli.rb",
+ "lib/cielli/_lib.rb",
+ "lib/cielli/slug.rb",
+ "lib/cielli/utils.rb",
+ "samples",
+ "samples/a.rb"]
+
+  spec.executables = ["cielli"]
+  
+  spec.require_path = "lib"
+
+  spec.test_files = nil
+
+  
+
+  spec.extensions.push(*[])
+
+  spec.author = "Ara T. Howard"
+  spec.email = "ara.t.howard@gmail.com"
+  spec.homepage = "https://github.com/ahoward/cielli"
+end

data/lib/cielli.rb

@@ -0,0 +1,240 @@
+#
+  Object.send(:remove_const, :Cielli) if Object.const_defined?(:Cielli)
+
+#
+  require 'json'
+  require 'yaml'
+  require 'base64'
+  require 'securerandom'
+  require 'fileutils'
+  require 'pathname'
+  require 'set'
+  require 'openssl'
+  require 'uri'
+  require 'cgi'
+  require 'shellwords'
+  require 'tmpdir'
+  require 'tempfile'
+  require 'pp'
+  require 'open3'
+
+#
+  require_relative 'cielli/_lib'
+
+#
+  class Cielli
+    attr_accessor :source
+    attr_accessor :root
+    attr_accessor :env
+    attr_accessor :argv
+    attr_accessor :stdout
+    attr_accessor :stdin
+    attr_accessor :stderr
+    attr_accessor :help
+
+    def run!(env = ENV, argv = ARGV)
+      init!(env, argv)
+      parse_command_line!
+      set_mode!
+      run_mode!
+    end
+
+    def init!(env, argv)
+      @klass = self.class
+      @env = env.to_hash.dup
+      @argv = argv.map{|arg| arg.dup}
+      @stdout = $stdout.dup
+      @stdin = $stdin.dup
+      @stderr = $stderr.dup
+      @help = @klass.help || utils.unindent(EXAMPLE_HELP)
+    end
+
+    EXAMPLE_HELP = <<-__
+      NAME
+        #TODO
+
+      SYNOPSIS
+        #TODO
+         
+      DESCRIPTION
+        #TODO
+         
+      EXAMPLES
+        #TODO
+    __
+
+    def parse_command_line!
+      @options = Hash.new
+      @opts = Hash.new
+
+      argv = []
+      head = []
+      tail = []
+
+      %w[ :: -- ].each do |stop|
+        if((i = @argv.index(stop)))
+          head = @argv.slice(0 ... i)
+          tail = @argv.slice((i + 1) ... @argv.size) 
+          @argv = head
+          break
+        end
+      end
+
+      @argv.each do |arg|
+        case
+          when arg =~ %r`^\s*:([^:\s]+)[=](.+)`
+            key = $1
+            val = $2
+            @options[key] = val
+          when arg =~ %r`^\s*(:+)(.+)`
+            leader = $1
+            key = $2
+            val = leader.size.odd?
+            @options[key] = val
+          else
+            argv.push(arg)
+        end
+      end
+
+      argv += tail
+
+      @argv.replace(argv)
+
+      @options.each do |key, val|
+        @opts[key.to_s.to_sym] = val
+      end
+      
+      [@options, @opts]
+    end
+
+    def set_mode!
+      case
+        when respond_to?("run_#{ @argv[0] }")
+          @mode = @argv.shift
+        else
+          @mode = nil
+      end
+    end
+
+    def run_mode!
+      if @mode
+        return send("run_#{ @mode }")
+      else
+        if respond_to?(:run)
+          return send(:run)
+        end
+
+        if @argv.empty?
+          run_help!
+        else
+          abort("#{ $0 } help")
+        end
+      end
+    end
+
+    def run_help!
+      STDOUT.puts(@help)
+    end
+
+    def help!
+      run_help!
+      abort
+    end
+
+  #
+    def Cielli.help(*args)
+      @help ||= nil
+
+      unless args.empty?
+        @help = utils.unindent(args.join)
+      end
+
+      @help
+    end
+
+    def Cielli.run(*args, &block)
+      modes =
+        if args.empty?
+          [nil]
+        else
+          args
+        end
+
+      modes.each do |mode|
+        method_name =
+          if mode
+            "run_#{ mode }"
+          else
+            "run"
+          end
+
+        define_method(method_name, &block)
+      end
+    end
+
+  #
+    def Cielli.klass_for(&block)
+      Class.new(Cielli) do |klass|
+        def klass.name; "Cielli::Klass__#{ SecureRandom.uuid.to_s.gsub('-', '_') }"; end
+        klass.class_eval(&block)
+      end
+    end
+
+    def Cielli.run!(*args, &block)
+      STDOUT.sync = true
+      STDERR.sync = true
+
+      %w[ PIPE INT ].each{|signal| Signal.trap(signal, "EXIT")}
+
+      cielli = (
+        source = 
+          if binding.respond_to?(:source_location)
+            File.expand_path(binding.source_location.first)
+          else
+            File.expand_path(eval('__FILE__', block.binding))
+          end
+
+        root = File.dirname(source)
+
+        klass = Cielli.klass_for(&block)
+
+        instance = klass.new
+
+        instance.source = source
+
+        instance.root = root
+
+        instance
+      )
+
+      cielli.run!(*args)
+    end
+  end
+
+#
+  require_relative 'cielli/utils'
+
+  def Cielli.utils(&block)
+    block ? Cielli::Utils.module_eval(&block) : Cielli::Utils
+  end
+
+  def Cielli.u(&block)
+    Cielli.utils(&block)
+  end
+
+  def utils
+    Cielli::Utils
+  end
+
+  def u
+    Cielli::Utils
+  end
+
+#
+  class << self
+    def cielli(*args, &block)
+      Cielli.run!(*args, &block)
+    end
+    
+    alias_method :cli, :cielli
+  end

data/lib/cielli/_lib.rb

@@ -0,0 +1,49 @@
+class Cielli
+  Version = '4.2.2' unless defined?(Version)
+
+  class << self
+    def version
+      Version
+    end
+
+    def summary
+      "a minimalist's toolkit for quickly writing well behaved CLI/cee-el-ahy programs"
+    end
+
+    def dependencies
+      { }
+    end
+
+    def load_dependencies!
+      begin 
+        require 'rubygems'
+      rescue LoadError
+        nil
+      end
+
+      dependencies.each do |lib, dependency|
+        gem(*dependency) if defined?(gem)
+        require(lib)
+      end
+    end
+
+    def libdir(*args, &block)
+      @libdir ||= File.dirname(File.expand_path(__FILE__).sub(/\.rb$/,''))
+      args.empty? ? @libdir : File.join(@libdir, *args)
+    ensure
+      if block
+        begin
+          $LOAD_PATH.unshift(@libdir)
+          block.call()
+        ensure
+          $LOAD_PATH.shift()
+        end
+      end
+    end
+
+    def load(*libs)
+      libs = libs.join(' ').scan(/[^\s+]+/)
+      libdir{ libs.each{|lib| Kernel.load(lib) } }
+    end
+  end
+end

data/lib/cielli/slug.rb

@@ -0,0 +1,25 @@
+class Cielli
+  class Slug < ::String
+    Join = '-'
+
+    def Slug.for(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+
+      join = (options[:join] || options['join'] || Join).to_s
+
+      string = args.flatten.compact.join(' ')
+
+      tokens = string.scan(%r`[^\s#{ join }]+`)
+
+      tokens.map! do |token|
+        token.gsub(%r`[^\p{L}/.]`, '').downcase
+      end
+
+      tokens.map! do |token|
+        token.gsub(%r`[/.]`, join * 2)
+      end
+
+      tokens.join(join)
+    end
+  end
+end

data/lib/cielli/utils.rb

@@ -0,0 +1,277 @@
+class Cielli
+  module Utils
+    def unindent(arg)
+      string = arg.to_s.dup
+      margin = nil
+      string.each_line do |line|
+        next if line =~ %r/^\s*$/
+        margin = line[%r/^\s*/] and break
+      end
+      string.gsub!(%r/^#{ margin }/, "") if margin
+      margin ? string : nil
+    end
+
+    def indent(arg, *args)
+      opts = extract_options!(args)
+      n = (args.shift || opts[:n] || 2).to_i
+
+      string = unindent(arg)
+
+      indentation = ' ' * n
+
+      string.gsub(/^/, indentation)
+    end
+
+    def esc(*args)
+      args.flatten.compact.map{|arg| Shellwords.escape(arg)}.join(' ')
+    end
+
+    def uuid
+      SecureRandom.uuid
+    end
+
+    def tmpname(*args)
+      opts = extract_options!(*args)
+
+      base = opts.fetch(:base){ uuid }.to_s.strip
+      ext = opts.fetch(:ext){ 'tmp' }.to_s.strip.sub(/^[.]+/, '')
+      basename = opts.fetch(:basename){ "#{ base }.#{ ext }" }
+
+      File.join(Dir.tmpdir, basename)
+    end
+
+    def tmpfile(*args, &block)
+      opts = extract_options!(args)
+
+      path = tmpname(opts)
+
+
+      tmp = open(path, 'w+')
+      tmp.binmode
+      tmp.sync = true
+
+      unless args.empty?
+        src = args.join
+        tmp.write(src)
+        tmp.flush
+        tmp.rewind
+      end
+
+      if block
+        begin
+          block.call(tmp)
+        ensure
+          FileUtilss.rm_rf(path)
+        end
+      else
+        at_exit{ Kernel.system("rm -rf #{ esc(path) }") }
+        return tmp
+      end
+    end
+
+    def extract_options!(args)
+      unless args.is_a?(Array)
+        args = [args]
+      end
+
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+
+      symbolize_keys!(opts)
+
+      return opts
+    end
+
+    def extract_options(args)
+      opts = extract_options!(args)
+
+      args.push(opts)
+
+      opts
+    end
+
+    def symbolize_keys!(hash)
+      hash.keys.each do |key|
+        if key.is_a?(String)
+          val = hash.delete(key)
+
+          if val.is_a?(Hash)
+            symbolize_keys!(val)
+          end
+
+          hash[key.to_s.gsub('-', '_').to_sym] = val
+        end
+      end
+
+      return hash
+    end
+
+    def symbolize_keys(hash)
+      symbolize_keys!(deepcopy(hash))
+    end
+
+    def deepcopy(object)
+      Marshal.load(Marshal.dump(object))
+    end
+
+    def debug!(arg)
+      if arg.is_a?(String)
+        warn "[DEBUG] #{ arg }"
+      else
+        warn "[DEBUG] >\n#{ arg.to_yaml rescue arg.pretty_inspect }"
+      end
+    end
+
+    def debug(arg)
+      debug!(arg) if debug?
+    end
+
+    def debug?
+      ENV['CIELLI_DEBUG'] || ENV['DEBUG']
+    end
+
+    def noop
+      ENV['CIELLI_NOOP'] || ENV['NOOP']
+    end
+    alias_method :noop?, :noop
+
+    def sys!(*args, &block)
+      opts = extract_options!(args)
+
+      cmd = args
+
+      debug(:cmd => cmd)
+
+      open3 = (
+        block ||
+        opts[:stdin] ||
+        opts[:quiet] ||
+        opts[:capture]
+      )
+
+      die = proc do |command, *args|
+        status = args.shift || $?
+        warn("#{ [command].join(' ') } #=> status=#{ status.exitstatus }") unless opts[:quiet]
+        exit(1)
+      end
+
+      if(open3)
+        stdin = opts[:stdin]
+        stdout = ''
+        stderr = ''
+        status = nil
+
+        begin
+          Open3.popen3(*cmd) do |i, o, e, t|
+            ot = async_reader_thread_for(o, stdout) 
+            et = async_reader_thread_for(e, stderr) 
+
+            i.write(stdin) if stdin
+            i.close
+
+            ot.join
+            et.join
+
+            status = t.value
+          end
+        rescue
+          die[cmd]
+        end
+
+        if status.exitstatus == 0
+          result = nil
+
+          if opts[:capture]
+            result = stdout.to_s.strip
+          else
+            if block
+              result = block.call(status, stdout, stderr)
+            else
+              result = [status, stdout, stderr]
+            end
+          end
+
+          return(result)
+        else
+          die[cmd, status]
+        end
+      else
+        env = opts[:env] || {}
+        argv = [env, *cmd]
+        system(*argv) || die[cmd]
+        return true
+      end
+    end
+
+    def sys(*args, &block)
+      opts = extract_options!(args)
+      opts[:quiet] = true
+
+      args.push(opts)
+
+      begin
+        sys!(*args, &block)
+      rescue Object
+        false
+      end
+    end
+
+    def async_reader_thread_for(io, accum)
+      Thread.new(io, accum) do |i, a|
+        Thread.current.abort_on_exception = true
+
+        while true
+          buf = i.read(8192)
+
+          if buf
+            a << buf
+          else
+            break
+          end
+        end
+      end
+    end
+
+    def realpath(path)
+      Pathname.new(path.to_s).expand_path.realpath.to_s
+    end
+
+    def filelist(*args, &block)
+      accum = (block || proc{ Set.new }).call
+      raise ArgumentError.new('accum.class != Set') unless accum.is_a?(Set)
+
+      _ = args.last.is_a?(Hash) ? args.pop : {}
+
+      entries = args.flatten.compact.map{|arg| realpath("#{ arg }")}.uniq.sort
+
+      entries.each do |entry|
+        case
+          when test(?f, entry)
+            file = realpath(entry)
+            accum << file
+
+          when test(?d, entry)
+            glob = File.join(entry, '**/**')
+
+            Dir.glob(glob) do |_entry|
+              case
+                when test(?f, _entry)
+                  filelist(_entry){ accum }
+                when test(?d, entry)
+                  filelist(_entry){ accum }
+              end
+            end
+        end
+      end
+
+      accum.to_a
+    end
+
+    require_relative 'slug.rb'
+
+    def slug_for(*args, &block)
+      Slug.for(*args, &block)
+    end
+
+    extend Utils
+  end
+end

data/samples/a.rb

@@ -0,0 +1,9 @@
+#! /usr/bin/env ruby
+
+require 'cielli'
+
+cli do
+  run do
+    p [@argv, @options]
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: cielli
+version: !ruby/object:Gem::Version
+  version: 4.2.2
+platform: ruby
+authors:
+- Ara T. Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-12-20 00:00:00.000000000 Z
+dependencies: []
+description: 'description: cielli kicks the ass'
+email: ara.t.howard@gmail.com
+executables:
+- cielli
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- README.md.erb
+- Rakefile
+- bin/cielli
+- cielli.gemspec
+- lib/cielli.rb
+- lib/cielli/_lib.rb
+- lib/cielli/slug.rb
+- lib/cielli/utils.rb
+- samples/a.rb
+homepage: https://github.com/ahoward/cielli
+licenses:
+- Ruby
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: cielli
+test_files: []