clamp 1.4.0 → 1.5.1

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

data/spec/clamp/command_option_reordering_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Clamp::Command do
-
-  extend CommandFactory
-  include OutputCapture
-
-  context "with allow_options_after_parameters enabled" do
-
-    before do
-      Clamp.allow_options_after_parameters = true
-    end
-
-    after do
-      Clamp.allow_options_after_parameters = false
-    end
-
-    given_command("cmd") do
-
-      option ["-v", "--verbose"], :flag, "Be noisy"
-
-      subcommand "say", "Say something" do
-
-        option "--loud", :flag, "say it loud"
-
-        parameter "WORDS ...", "the thing to say", attribute_name: :words
-
-        def execute
-          message = words.join(" ")
-          message = message.upcase if loud?
-          message *= 3 if verbose?
-          $stdout.puts message
-        end
-
-      end
-
-    end
-
-    it "still works" do
-      command.run(%w[say foo])
-      expect(stdout).to eq "foo\n"
-    end
-
-    it "honours options after positional arguments" do
-      command.run(%w[say blah --verbose])
-      expect(stdout).to eq "blahblahblah\n"
-    end
-
-    it "honours options declared on subcommands" do
-      command.run(%w[say --loud blah])
-      expect(stdout).to eq "BLAH\n"
-    end
-
-  end
-
-end