gli 2.18.2 → 2.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ce48a9dbc23454ebd42678e837bab21aab64a6d9e9bc1713d3ce57ddd8a802a
-  data.tar.gz: 74e014e219d5ade2ff39bdf8ad69c0a19a258bc2208566438f3b3f87fbf98d2e
+  metadata.gz: 5d3bbbc287b9e950b0e466400f14518010968c40a444cfa22486a51fa734134d
+  data.tar.gz: d4414c2e6c9f981a7ccbad490fea52f0519ec45a6a7634f44d9ed4cfad3b1c24
 SHA512:
-  metadata.gz: 326911ec59ad5867f0a9acc3fac254258d59514b0efb99327834a6c2f79941f505f5cae9d284d330f4f32a80f4f9bea07146f48009940a7848a047899f8fcc71
-  data.tar.gz: '0585ba1acb20eb2f9a743a4e5c3e715f3a10a0d9cc60b6ba2003f4034cd9c75c9347f0c91894fc0535bc32d32871a63cb7418d326d23ab732fbd7141eec4b462'
+  metadata.gz: b432b2e5d295bf7b3cf61683b1819353bca64158c5d07ed11135cd94ae8917dd352653f169f3306e1b26fcc9bce2199a5898d889f0819961b1260ee31fe5d710
+  data.tar.gz: 60d93d19cfdc621cbfee7189140447f0fa074354153c6d840e67fff516a6bf06ebb9668d3c420b6e66e6103c4ccfd969742cf26760c68c6f091f660b8d40a6aa

data/.circleci/config.yml

@@ -0,0 +1,28 @@
+version: 2.1
+orbs:
+  # See https://circleci.com/developer/orbs/orb/circleci/ruby
+  ruby: circleci/ruby@1.1.2
+jobs:                # keyword
+  test:              # my name for the job
+    parameters:      # keyword
+      ruby-version:  # my parameter name
+        type: string # type is a keyword
+    docker:          # keyword
+      - image: cimg/base:stable
+    steps:                                       # keyword
+      - checkout                                 # magic name
+      - ruby/install:                            # ruby/ is from the orb name, install is a command in that orb
+          version: << parameters.ruby-version >> # magic nonsense for param subst (version param to the command)
+      - run:
+          command: "bin/setup"
+      - run:
+          command: "bin/ci"
+workflows:              # keyword
+  all-rubies:           # my name for the workflow
+    jobs:               # keyword
+      - test:           # my name for the job
+          matrix:       # keyword
+            parameters: # keyword
+              # All rubies being maintained per this page:
+              # https://www.ruby-lang.org/en/downloads/branches/
+              ruby-version: [ "2.5", "2.6", "2.7", "3.0" ]

data/.gitignore

@@ -5,11 +5,9 @@ pkg
 coverage
 .bundle
 tmp
-cruddo.rdoc
-gli.wiki
 Gemfile.lock
 *.gem
 results.html
-.rbx
 .DS_Store
 Session.vim
+scaffold_test

data/.tool-versions

@@ -1 +1 @@
-ruby 2.6.3
+ruby 2.7.1

data/Gemfile

@@ -2,11 +2,5 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem "rcov", ">= 0.9.8", :platforms => :mri_18
 gem "simplecov", "~> 0.6.4", :platforms => :mri_19
 gem "psych", :platforms => :mri_19
-
-major,minor = RUBY_VERSION.split(/\./)
-if major.to_i >=2 && minor.to_i >= 2
-  gem "test-unit"
-end

data/README.rdoc

@@ -1,32 +1,51 @@
-= Git-Like Interface Command Line Parser
+= GLI, the Git-Like Interface Command Line Parser
 
-GLI is the best way to make a "command-suite" command-line application, e.g. one like <tt>git</tt> (for the best way to make a
-simpler command-line application, check out methadone[http://www.github.com/davetron5000/methadone]).
+GLI allows you to create command-line app in Ruby that behaves like <tt>git</tt> in that it takes subcommands to perform a series of complex action, e.g. <tt>git remote add</tt>.
 
-GLI allows you to make a polished, easy-to-maintain command-line application without a lot
-of syntax, but without restricting you in any way from the power of +OptionParser+.
-
-* {Overview}[http://davetron5000.github.com/gli]
+* {Overview}[http://davetron5000.github.io/gli]
 * {Source on Github}[http://github.com/davetron5000/gli]
-* RDoc[http://davetron5000.github.com/gli/rdoc/index.html]
+* RDoc[http://davetron5000.github.io/gli/rdoc/index.html]
 
 {<img src="https://secure.travis-ci.org/davetron5000/gli.svg?branch=gli-2" alt="Build Status" />}[https://travis-ci.org/davetron5000/gli]
 
+== What Problem does GLI Solve?
+
+Creating a command-line app that uses subcommands, each of which might accept different command-line options, is somewhat difficult with Ruby's built-in <tt>OptionParser</tt>.  GLI provides an API that wraps <tt>OptionParser</tt> so that you can create a subcommand-based command-line app with minimal boilerplate. This API also produces complete documentation for your command-line app.
+
+== Why is GLI's solution different from others?
+
+There are other RubyGems that allow you to create a command-line app that takes subcommands.  These solutions are often quite limited (e.g. they don't allow deeply nested subcommand structures or sophisticated command-line options per subcommand), or require more code that we think is needed. Some solutions make it difficult or impossible to properly document your command-line  app.
+
+== What you need to know to use GLI
+
+You should know Ruby, and have a basic understanding of how the UNIX command line works: standard input, standard output, standard error, and exit codes.
+
 == Use
 
 Install if you need to:
 
     gem install gli
 
+You can validate you have installed it correctly by running <tt>gli help</tt>. You should see formatted help output.
+
+If you are using GLI in another application, add it to your <tt>Gemfile</tt>:
+
+    gem "gli"
+
+You can test your install via Bundler by running <tt>bundle exec gli help</tt>. This should produce formatted help output from GLI.
+
+== Getting Started
+
 The simplest way to get started is to create a scaffold project
 
     gli init todo list add complete
 
+(note if you installed via Bundler you will need to execute <tt>bundle exec gli init todo list add complete</tt>)
+
 This will create a basic scaffold project in <tt>./todo</tt> with:
 
 * executable in <tt>./todo/bin/todo</tt>.  This file demonstrates most of what you need to describe your command line interface.
 * an empty test in <tt>./todo/test/default_test.rb</tt> that can bootstrap your tests
-* an empty feature in <tt>./todo/features/todo.feature</tt> that can bootstrap testing your CLI via Aruba.
 * a gemspec shell
 * a README shell
 * Rakefile that can generate RDoc, package your Gem and run tests
@@ -69,28 +88,19 @@ Now, you are ready to go:
 
 All you need to do is fill in the documentation and your code; the help system, command-line parsing and many other awesome features are all handled for you.
 
-Get a more detailed walkthrough on the {main site}[http://davetron5000.github.com/gli]
+Get a more detailed walkthrough on the {main site}[http://davetron5000.github.io/gli]
 
 == Supported Platforms
 
-Tests should be passing supported MRI Rubies (see +.travis.yml+ for specifics).
-
-Due to the vagaries of Travis, I can't keep the test suite running on unsupported Rubies, but we currently support:
-
-* 2.1
-* 2.2
-* 2.3
-* 2.4
-* JRuby
-
-GLI likely works on older rubies, but the cost of keeping tests passing on those versions (which are now totally unsupported by Ruby core) is too high.
+See `.circleci/config.yml` for the supported rubies, but general we're running tests on the all MRI rubies receiving support, which tends to be the most recent four versions.
 
+GLI should work on older Rubies and JRuby, but it's too much work to keep tests passing for those.
 
 == Documentation
 
 Extensive documentation is {available at the wiki}[https://github.com/davetron5000/gli/wiki].
 
-API Documentation is available {here}[http://davetron5000.github.com/gli/rdoc/index.html].  Recommend starting with GLI::DSL or GLI::App.
+API Documentation is available {here}[http://davetron5000.github.io/gli/rdoc/index.html].  Recommend starting with GLI::DSL or GLI::App.
 
 == Credits
 
@@ -100,7 +110,7 @@ License:: Distributes under the Apache License, see LICENSE.txt in the source di
 
 == Links
 
-* [http://davetron5000.github.com/gli] - RubyDoc
+* [http://davetron5000.github.io/gli] - RubyDoc
 * [http://www.github.com/davetron5000/gli] - Source on GitHub
 * [http://www.github.com/davetron5000/gli/wiki] - Documentation Wiki
 * [http://www.github.com/davetron5000/gli/wiki/Changelog] - Changelog

data/Rakefile

@@ -3,8 +3,6 @@ require 'bundler'
 require 'rake/clean'
 require 'rake/testtask'
 require 'rdoc/task'
-require 'cucumber'
-require 'cucumber/rake/task'
 
 include Rake::DSL
 
@@ -75,48 +73,34 @@ end
 
 Bundler::GemHelper.install_tasks
 
-desc 'run unit tests'
-Rake::TestTask.new do |t|
+desc "run unit tests"
+Rake::TestTask.new("test:unit") do |t|
   t.libs << "test"
-  t.test_files = FileList['test/init_simplecov.rb','test/tc_*.rb']
-end
-
-CUKE_RESULTS = 'results.html'
-CLEAN << CUKE_RESULTS
-Cucumber::Rake::Task.new(:features) do |t|
-  opts = "features --format html -o #{CUKE_RESULTS} --format progress -x"
-  opts += " --tags #{ENV['TAGS']}" if ENV['TAGS']
-  t.cucumber_opts =  opts
-  t.fork = false
-end
-Cucumber::Rake::Task.new('features:wip') do |t|
-  tag_opts = ' --tags ~@pending'
-  tag_opts = ' --tags @wip'
-  t.cucumber_opts = "features --format html -o #{CUKE_RESULTS} --format pretty -x -s#{tag_opts}"
-  t.fork = false
+  t.libs << "lib"
+  ENV["RUBYOPT"].split(/\s/).each do |opt|
+    t.ruby_opts << opt
+  end
+  t.test_files = FileList["test/unit/**/*_test.rb"]
 end
 
-begin
-  require 'rcov/rcovtask'
-  task :clobber_coverage do
-    rm_rf "coverage"
+desc "run integration tests"
+Rake::TestTask.new("test:integration") do |t|
+  t.libs << "test"
+  ENV["RUBYOPT"].split(/\s/).each do |opt|
+    t.ruby_opts << opt
   end
-
-  desc 'Measures test coverage'
-  task :coverage => :rcov do
-    puts "coverage/index.html contains what you need"
+  explicitly_named_files = ARGV[1..-1]
+  if Array(explicitly_named_files).size == 0
+    t.test_files = FileList["test/integration/**/*_test.rb"]
+  else
+    t.test_files = explicitly_named_files
   end
+end
 
-  Rcov::RcovTask.new do |t|
-    t.libs << 'lib'
-    t.test_files = FileList['test/tc_*.rb']
-  end
+
+begin
+  require 'simplecov'
 rescue LoadError
-  begin
-    require 'simplecov'
-  rescue LoadError
-    $stderr.puts "neither rcov nor simplecov are installed; you won't be able to check code coverage"
-  end
 end
 
 desc 'Publish rdoc on github pages and push to github'

data/bin/ci

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+set -e
+if [ -z $1 ]; then
+  echo "[bin/ci] Running with default warnings"
+  export RUBYOPT=
+else
+  if [ $1 == 'warnings' ]; then
+    echo "[bin/ci] Running with all warnings on"
+    export RUBYOPT=-w
+  else
+    if [ $1 == 'none' ]; then
+      echo "[bin/ci] Running with all warnings off"
+      export RUBYOPT='-W0'
+    else
+      echo "[bin/ci] '$1' is not a supported option"
+      echo "[bin/ci] usage: $0          # run with default warnings"
+      echo "[bin/ci] usage: $0 warnings # run with all warnings"
+      echo "[bin/ci] usage: $0 none     # run with warnings disabled"
+      exit 1
+    fi
+  fi
+fi
+
+echo "[bin/ci] Running unit tests"
+bin/rake test:unit
+
+echo "[bin/ci] Running integration tests"
+bin/rake test:integration

data/bin/gli

@@ -1,68 +1,29 @@
 #!/usr/bin/env ruby
-
-require 'gli'
-require 'gli/commands/scaffold'
-
-class App
-  extend GLI::App
-
-  program_desc 'create scaffolding for a GLI-powered application'
-
-  version GLI::VERSION
-
-  # Can't use these without changing the current behavior of gli
-  # arguments :strict
-  # subcommand_option_handling :normal
-
-  switch :v, :desc => 'Be verbose'
-
-  switch :n, :desc => 'Dry run; don''t change the disk'
-
-  desc 'Root dir of project'
-long_desc <<EOS
-  This is the directory where the project''s directory will be made, so if you
-  specify a project name ''foo'' and the root dir of ''.'', the directory
-  ''./foo'' will be created'
-EOS
-
-  flag :r,:root, :default_value => '.'
-
-  desc 'Create a new GLI-based project'
-long_desc <<EOS
-  This will create a scaffold command line project that uses GLI
-  for command line processing.  Specifically, this will create
-  an executable ready to go, as well as a lib and test directory, all
-  inside the directory named for your project
-EOS
-  arg :project_name
-  arg :command_name, [:optional, :multiple]
-  arg_name "project_name [command_name][, [command_name]]*"
-  command [:init,:scaffold] do |c|
-
-    c.switch :e,:ext, :desc => 'Create an ext dir'
-
-    c.switch :notest, :desc => 'Do not create a test or features dir', :negatable => false
-
-    c.switch :force, :desc => 'Overwrite/ignore existing files and directories'
-
-    c.switch :rvmrc, :desc => 'Create an .rvmrc based on your current RVM setup'
-
-    c.action do |g,o,args|
-      if args.length < 1
-        raise 'You must specify the name of your project'
-      end
-      GLI::Commands::Scaffold.create_scaffold(g[:r],!o[:notest],o[:e],args[0],args[1..-1],o[:force],g[:n],o[:rvmrc])
-    end
-  end
-
-  pre do |global,command,options,args|
-    puts "Executing #{command.name}" if global[:v]
-    true
-  end
-
-  post do |global,command,options,args|
-    puts "Executed #{command.name}" if global[:v]
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'gli' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
   end
 end
 
-exit App.run(ARGV)
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("gli", "gli")

data/bin/rake

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/setup

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -e
+
+bundle check || bundle install

data/exe/gli

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require 'gli'
+require 'gli/commands/scaffold'
+
+class App
+  extend GLI::App
+
+  program_desc 'create scaffolding for a GLI-powered application'
+
+  version GLI::VERSION
+
+  # Can't use these without changing the current behavior of gli
+  # arguments :strict
+  # subcommand_option_handling :normal
+
+  switch :v, :desc => 'Be verbose'
+
+  switch :n, :desc => 'Dry run; don''t change the disk'
+
+  desc 'Root dir of project'
+long_desc <<EOS
+  This is the directory where the project''s directory will be made, so if you
+  specify a project name ''foo'' and the root dir of ''.'', the directory
+  ''./foo'' will be created'
+EOS
+
+  flag :r,:root, :default_value => '.'
+
+  desc 'Create a new GLI-based project'
+long_desc <<EOS
+  This will create a scaffold command line project that uses GLI
+  for command line processing.  Specifically, this will create
+  an executable ready to go, as well as a lib and test directory, all
+  inside the directory named for your project
+EOS
+  arg :project_name
+  arg :command_name, [:optional, :multiple]
+  arg_name "project_name [command_name]..."
+  command [:init,:scaffold] do |c|
+
+    c.switch :e,:ext, :desc => 'Create an ext dir'
+
+    c.switch :notest, :desc => 'Do not create a test or features dir', :negatable => false
+
+    c.switch :force, :desc => 'Overwrite/ignore existing files and directories'
+
+    c.switch :rvmrc, :desc => 'Create an .rvmrc based on your current RVM setup'
+
+    c.action do |g,o,args|
+      if args.length < 1
+        raise 'You must specify the name of your project'
+      end
+      GLI::Commands::Scaffold.create_scaffold(g[:r],!o[:notest],o[:e],args[0],args[1..-1],o[:force],g[:n],o[:rvmrc])
+    end
+  end
+
+  pre do |global,command,options,args|
+    puts "Executing #{command.name}" if global[:v]
+    true
+  end
+
+  post do |global,command,options,args|
+    puts "Executed #{command.name}" if global[:v]
+  end
+end
+
+exit App.run(ARGV)