clamp 1.3.3 → 1.5.0

data/.editorconfig

@@ -1,10 +0,0 @@
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-max_line_length = 120

data/.gitignore

@@ -1,9 +0,0 @@
-*.gem
-.bundle
-.markdownlint*
-.rvmrc
-.ruby-version
-.yardoc
-doc
-pkg/*
-Gemfile.lock

data/.rspec

@@ -1,2 +0,0 @@
---color
---warnings

data/.rubocop.yml

@@ -1,71 +0,0 @@
-plugins:
-  - rubocop-rake
-  - rubocop-rspec
-
-AllCops:
-  TargetRubyVersion: 2.5
-  NewCops: enable
-
-Layout/LineLength:
-  Max: 120
-
-Layout/EmptyLinesAroundBlockBody:
-  Enabled: false
-
-Layout/EmptyLinesAroundClassBody:
-  EnforcedStyle: empty_lines
-
-Layout/EmptyLinesAroundModuleBody:
-  Enabled: false
-
-Metrics/AbcSize:
-  Enabled: false
-
-Metrics/BlockLength:
-  Exclude:
-    - "spec/**/*"
-
-Metrics/MethodLength:
-  Max: 30
-
-Naming/AccessorMethodName:
-  Enabled: false
-
-Naming/FileName:
-  Exclude:
-    - "bin/*"
-
-Naming/PredicatePrefix:
-  Enabled: false
-
-Style/ClassAndModuleChildren:
-  EnforcedStyle: nested
-  Exclude:
-    - "spec/**/*"
-
-Style/Documentation:
-  Exclude:
-    - "lib/**/version.rb"
-    - "examples/*"
-    - "spec/**/*"
-
-Style/Encoding:
-  Enabled: true
-
-Style/Lambda:
-  Enabled: false
-
-Style/NumericLiterals:
-  Enabled: false
-
-Style/StderrPuts:
-  Enabled: false
-
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
-
-Style/WordArray:
-  Enabled: false
-
-RSpec/NestedGroups:
-  Enabled: false

data/.travis.yml

@@ -1,6 +0,0 @@
-language: ruby
-rvm:
-  - 2.5
-  - 2.6
-  - 2.7
-  - 3.0

data/CODEOWNERS

@@ -1 +0,0 @@
-*	@mdub

data/Gemfile

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-gemspec
-
-group :development do
-  gem "guard-rspec", "~> 4.7", require: false
-  gem "highline"
-  gem "listen", "~> 3.9"
-  gem "pry-byebug", "~> 3.11"
-  gem "rake", "~> 13.3"
-  gem "rubocop", "~> 1.79.0", require: false
-  gem "rubocop-rake", "~> 0.7.1", require: false
-  gem "rubocop-rspec", "~> 3.6.0", require: false
-end
-
-group :test do
-  gem "rspec", "~> 3.13"
-end

data/Guardfile

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-# A sample Guardfile
-# More info at https://github.com/guard/guard#readme
-
-## Uncomment and set this to only include directories you want to watch
-# directories %w(app lib config test spec features) \
-#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
-
-## NOTE: if you are using the `directories` clause above and you are not
-## watching the project directory ('.'), then you will want to move
-## the Guardfile to a watched dir and symlink it back, e.g.
-#
-#  $ mkdir config
-#  $ mv Guardfile config/
-#  $ ln -s config/Guardfile .
-#
-# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
-
-# NOTE: The cmd option is now required due to the increasing number of ways
-#       rspec may be run, below are examples of the most common uses.
-#  * bundler: 'bundle exec rspec'
-#  * bundler binstubs: 'bin/rspec'
-#  * spring: 'bin/rspec' (This will use spring if running and you have
-#                          installed the spring binstubs per the docs)
-#  * zeus: 'zeus rspec' (requires the server to be started separately)
-#  * 'just' rspec: 'rspec'
-
-guard :rspec, cmd: "bundle exec rspec" do
-  require "guard/rspec/dsl"
-  dsl = Guard::RSpec::Dsl.new(self)
-
-  # Feel free to open issues for suggestions and improvements
-
-  # RSpec files
-  rspec = dsl.rspec
-  watch(rspec.spec_helper) { rspec.spec_dir }
-  watch(rspec.spec_support) { rspec.spec_dir }
-  watch(rspec.spec_files)
-
-  # Ruby files
-  ruby = dsl.ruby
-  dsl.watch_spec_files_for(ruby.lib_files)
-
-end

data/Rakefile

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler"
-
-Bundler::GemHelper.install_tasks
-
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new do |t|
-  t.pattern = "spec/**/*_spec.rb"
-  t.rspec_opts = ["--colour", "--format", "documentation"]
-end
-
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
-task "default" => ["spec", "rubocop"]

data/clamp.gemspec

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.push File.expand_path("lib", __dir__)
-require "clamp/version"
-
-Gem::Specification.new do |s|
-
-  s.name          = "clamp"
-  s.version       = Clamp::VERSION.dup
-  s.platform      = Gem::Platform::RUBY
-  s.authors       = ["Mike Williams"]
-  s.email         = "mdub@dogbiscuit.org"
-  s.homepage      = "https://github.com/mdub/clamp"
-
-  s.license       = "MIT"
-
-  s.summary       = "a minimal framework for command-line utilities"
-  s.description   = <<-TEXT.gsub(/^\s+/, "")
-    Clamp provides an object-model for command-line utilities.
-    It handles parsing of command-line options, and generation of usage help.
-  TEXT
-
-  s.files         = `git ls-files`.split("\n")
-  s.require_paths = ["lib"]
-
-  s.required_ruby_version = ">= 2.5", "< 4"
-  s.metadata["rubygems_mfa_required"] = "true"
-end

data/spec/clamp/command_group_spec.rb

@@ -1,438 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Clamp::Command do
-
-  extend CommandFactory
-  include OutputCapture
-
-  context "with subcommands" do
-
-    given_command "flipflop" do
-
-      def execute
-        puts message
-      end
-
-      subcommand "flip", "flip it" do
-        def message
-          "FLIPPED"
-        end
-      end
-
-      subcommand "flop", "flop it\nfor extra flop" do
-        def message
-          "FLOPPED"
-        end
-      end
-
-    end
-
-    describe "flip command" do
-      before do
-        command.run(["flip"])
-      end
-
-      it "delegates to sub-commands" do
-        expect(stdout).to match(/FLIPPED/)
-      end
-    end
-
-    describe "flop command" do
-      before do
-        command.run(["flop"])
-      end
-
-      it "delegates to sub-commands" do
-        expect(stdout).to match(/FLOPPED/)
-      end
-    end
-
-    context "when executed with no subcommand" do
-
-      it "triggers help" do
-        expect do
-          command.run([])
-        end.to raise_error(Clamp::HelpWanted)
-      end
-
-    end
-
-    describe "#help" do
-
-      it "shows subcommand parameters in usage" do
-        expect(command.help).to include("flipflop [OPTIONS] SUBCOMMAND [ARG] ...")
-      end
-
-      it "lists subcommands" do
-        expect(command.help).to match(/Subcommands:\n +flip +flip it\n +flop +flop it/)
-      end
-
-      it "handles new lines in subcommand descriptions" do
-        expect(command.help).to match(/flop +flop it\n +for extra flop/)
-      end
-
-    end
-
-    describe ".find_subcommand_class" do
-
-      it "finds subcommand classes" do
-        flip_class = command_class.find_subcommand_class("flip")
-        expect(flip_class.new("xx").message).to eq("FLIPPED")
-      end
-
-    end
-
-  end
-
-  context "with an aliased subcommand" do
-
-    given_command "blah" do
-
-      subcommand ["say", "talk"], "Say something" do
-
-        parameter "WORD ...", "stuff to say"
-
-        def execute
-          puts word_list
-        end
-
-      end
-
-    end
-
-    describe "the first alias" do
-
-      before do
-        command.run(["say", "boo"])
-      end
-
-      it "responds to it" do
-        expect(stdout).to match(/boo/)
-      end
-
-    end
-
-    describe "the second alias" do
-
-      before do
-        command.run(["talk", "jive"])
-      end
-
-      it "responds to it" do
-        expect(stdout).to match(/jive/)
-      end
-
-    end
-
-    describe "#help" do
-
-      it "lists all aliases" do
-        help = command.help
-        expect(help).to match(/say, talk .* Say something/)
-      end
-
-    end
-
-  end
-
-  context "with nested subcommands" do
-
-    given_command "fubar" do
-
-      subcommand "foo", "Foo!" do
-
-        subcommand "bar", "Baaaa!" do
-
-          def self.this_is_bar; end
-
-          def execute
-            puts "FUBAR"
-          end
-
-        end
-
-      end
-
-    end
-
-    it "delegates multiple levels" do
-      command.run(["foo", "bar"])
-      expect(stdout).to match(/FUBAR/)
-    end
-
-    describe ".find_subcommand_class" do
-
-      it "finds nested subcommands" do
-        expect(command_class.find_subcommand_class("foo", "bar")).to respond_to(:this_is_bar)
-      end
-
-    end
-
-  end
-
-  context "with a default subcommand" do
-
-    given_command "admin" do
-
-      self.default_subcommand = "status"
-
-      subcommand "status", "Show status" do
-
-        def execute
-          puts "All good!"
-        end
-
-      end
-
-    end
-
-    context "when executed with no subcommand" do
-
-      it "invokes the default subcommand" do
-        command.run([])
-        expect(stdout).to match(/All good/)
-      end
-
-    end
-
-  end
-
-  context "with a default subcommand, declared the old way" do
-
-    given_command "admin" do
-
-      default_subcommand "status", "Show status" do
-
-        def execute
-          puts "All good!"
-        end
-
-      end
-
-    end
-
-    context "when executed with no subcommand" do
-
-      it "invokes the default subcommand" do
-        command.run([])
-        expect(stdout).to match(/All good/)
-      end
-
-    end
-
-  end
-
-  context "when declaring a default subcommand after subcommands" do
-
-    let(:command) do
-      Class.new(Clamp::Command) do
-
-        subcommand "status", "Show status" do
-
-          def execute
-            puts "All good!"
-          end
-
-        end
-
-      end
-    end
-
-    it "is not supported" do
-
-      expect do
-        command.default_subcommand = "status"
-      end.to raise_error(/default_subcommand must be defined before subcommands/)
-
-    end
-
-  end
-
-  context "with subcommands, declared after a parameter" do
-
-    given_command "with" do
-
-      parameter "THING", "the thing"
-
-      subcommand "spit", "spit it" do
-        def execute
-          puts "spat the #{thing}"
-        end
-      end
-
-      subcommand "say", "say it" do
-        subcommand "loud", "yell it" do
-          def execute
-            puts thing.upcase
-          end
-        end
-      end
-
-    end
-
-    it "allows the parameter to be specified first" do
-      command.run(["dummy", "spit"])
-      expect(stdout.strip).to eq "spat the dummy"
-    end
-
-    it "passes the parameter down the stack" do
-      command.run(["money", "say", "loud"])
-      expect(stdout.strip).to eq "MONEY"
-    end
-
-    it "shows parameter in usage help" do
-      command.run(["stuff", "say", "loud", "--help"])
-    rescue Clamp::HelpWanted => e
-      expect(e.command.invocation_path).to eq "with THING say loud"
-    end
-
-  end
-
-  describe "each subcommand" do
-
-    let(:command_class) do
-
-      speed_options = Module.new do
-        extend Clamp::Option::Declaration
-
-        option "--speed", "SPEED", "how fast", default: "slowly"
-      end
-
-      Class.new(Clamp::Command) do
-
-        option "--direction", "DIR", "which way", default: "home"
-
-        include speed_options
-
-        subcommand "move", "move in the appointed direction" do
-
-          def execute
-            motion = context[:motion] || "walking"
-            puts "#{motion} #{direction} #{speed}"
-          end
-
-        end
-
-      end
-    end
-
-    let(:command) do
-      command_class.new("go")
-    end
-
-    it "accepts options defined in superclass (specified after the subcommand)" do
-      command.run(["move", "--direction", "north"])
-      expect(stdout).to match(/walking north/)
-    end
-
-    it "accepts options defined in superclass (specified before the subcommand)" do
-      command.run(["--direction", "north", "move"])
-      expect(stdout).to match(/walking north/)
-    end
-
-    it "accepts options defined in included modules" do
-      command.run(["move", "--speed", "very quickly"])
-      expect(stdout).to match(/walking home very quickly/)
-    end
-
-    it "has access to command context" do
-      command = command_class.new("go", motion: "wandering")
-      command.run(["move"])
-      expect(stdout).to match(/wandering home/)
-    end
-
-  end
-
-  context "with a subcommand, with options" do
-
-    given_command "weeheehee" do
-      option "--json", "JSON", "a json blob" do |option|
-        print "parsing!"
-        option
-      end
-
-      subcommand "woohoohoo", "like weeheehee but with more o" do
-        def execute; end
-      end
-    end
-
-    it "only parses options once" do
-      command.run(["--json", '{"a":"b"}', "woohoohoo"])
-      expect(stdout).to eq "parsing!"
-    end
-
-  end
-
-  context "with an unknown subcommand" do
-
-    let(:subcommand_missing) do
-      Module.new do
-        def subcommand_missing(_name)
-          abort "there is no such thing"
-        end
-      end
-    end
-
-    let(:subcommand_missing_with_return) do
-      Module.new do
-        def subcommand_missing(_name)
-          self.class.recognised_subcommands.first.subcommand_class
-        end
-      end
-    end
-
-    let(:command_class) do
-
-      Class.new(Clamp::Command) do
-        subcommand "test", "test subcommand" do
-          def execute
-            puts "known subcommand"
-          end
-        end
-
-        def execute; end
-      end
-    end
-
-    let(:command) do
-      command_class.new("foo")
-    end
-
-    it "signals no such subcommand usage error" do
-      expect { command.run(["foo"]) }.to raise_error(Clamp::UsageError, "No such sub-command 'foo'")
-    end
-
-    it "executes the subcommand missing method" do
-      command.extend subcommand_missing
-      expect { command.run(["foo"]) }.to raise_error(SystemExit, /there is no such thing/)
-    end
-
-    it "uses the subcommand class returned from subcommand_missing" do
-      command.extend subcommand_missing_with_return
-      command.run(["foo"])
-      expect(stdout).to match(/known subcommand/)
-    end
-
-  end
-
-  context "with a subcommand and required options" do
-
-    given_command "movements" do
-      option "--direction", "N|S|E|W", "bearing", required: true
-      subcommand "hop", "Hop" do
-        def execute
-          puts "Hopping #{direction}"
-        end
-      end
-    end
-
-    it "allows options after the subcommand" do
-      command.run(%w[hop --direction south])
-      expect(stdout).to eq "Hopping south\n"
-    end
-
-  end
-
-end

data/spec/clamp/command_option_module_spec.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Clamp::Command do
-
-  include OutputCapture
-
-  context "with included module" do
-
-    let(:command) do
-
-      shared_options = Module.new do
-        extend Clamp::Option::Declaration
-
-        option "--size", "SIZE", default: 4
-      end
-
-      command_class = Class.new(Clamp::Command) do
-
-        include shared_options
-
-        def execute
-          puts "size = #{size}"
-        end
-
-      end
-
-      command_class.new("foo")
-
-    end
-
-    it "accepts options from included module" do
-      command.run(["--size", "42"])
-      expect(stdout).to eq "size = 42\n"
-    end
-
-  end
-
-end