RubyGems - command_mapper-gen - Versions diffs - 0.1.0.pre1 - Mend

command_mapper-gen 0.1.0.pre1

Files changed (55) hide show

checksums.yaml +7 -0
data/.github/workflows/ruby.yml +27 -0
data/.gitignore +10 -0
data/.rspec +1 -0
data/.yardopts +1 -0
data/ChangeLog.md +20 -0
data/Gemfile +17 -0
data/LICENSE.txt +20 -0
data/README.md +145 -0
data/Rakefile +15 -0
data/bin/command_mapper-gen +7 -0
data/commnad_mapper-gen.gemspec +61 -0
data/examples/grep.rb +63 -0
data/gemspec.yml +26 -0
data/lib/command_mapper/gen/arg.rb +43 -0
data/lib/command_mapper/gen/argument.rb +53 -0
data/lib/command_mapper/gen/cli.rb +233 -0
data/lib/command_mapper/gen/command.rb +202 -0
data/lib/command_mapper/gen/exceptions.rb +9 -0
data/lib/command_mapper/gen/option.rb +66 -0
data/lib/command_mapper/gen/option_value.rb +23 -0
data/lib/command_mapper/gen/parsers/common.rb +49 -0
data/lib/command_mapper/gen/parsers/help.rb +351 -0
data/lib/command_mapper/gen/parsers/man.rb +80 -0
data/lib/command_mapper/gen/parsers/options.rb +127 -0
data/lib/command_mapper/gen/parsers/usage.rb +141 -0
data/lib/command_mapper/gen/parsers.rb +2 -0
data/lib/command_mapper/gen/task.rb +90 -0
data/lib/command_mapper/gen/types/enum.rb +30 -0
data/lib/command_mapper/gen/types/key_value.rb +34 -0
data/lib/command_mapper/gen/types/list.rb +34 -0
data/lib/command_mapper/gen/types/map.rb +36 -0
data/lib/command_mapper/gen/types/num.rb +18 -0
data/lib/command_mapper/gen/types/str.rb +48 -0
data/lib/command_mapper/gen/types.rb +6 -0
data/lib/command_mapper/gen/version.rb +6 -0
data/lib/command_mapper/gen.rb +2 -0
data/spec/argument_spec.rb +92 -0
data/spec/cli_spec.rb +269 -0
data/spec/command_spec.rb +316 -0
data/spec/option_spec.rb +85 -0
data/spec/option_value_spec.rb +20 -0
data/spec/parsers/common_spec.rb +616 -0
data/spec/parsers/help_spec.rb +612 -0
data/spec/parsers/man_spec.rb +158 -0
data/spec/parsers/options_spec.rb +802 -0
data/spec/parsers/usage_spec.rb +1175 -0
data/spec/spec_helper.rb +6 -0
data/spec/task_spec.rb +69 -0
data/spec/types/enum_spec.rb +45 -0
data/spec/types/key_value_spec.rb +36 -0
data/spec/types/list_spec.rb +36 -0
data/spec/types/map_spec.rb +48 -0
data/spec/types/str_spec.rb +70 -0
metadata +133 -0

data/spec/parsers/common_spec.rb ADDED Viewed

@@ -0,0 +1,616 @@
+require 'spec_helper'
+require 'command_mapper/gen/parsers/common'
+describe CommandMapper::Gen::Parsers::Common do
+  describe "#space" do
+    subject { super().space }
+    context "when given a ' '" do
+      let(:string) { ' ' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given multiple spaces" do
+      let(:string) { '   ' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given a non-space character" do
+      let(:string) { 'A' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+  end
+  describe "#spaces" do
+    subject { super().spaces }
+    context "when given an empty string" do
+      let(:string) { '' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given one space" do
+      let(:string) { ' ' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given multiple spaces" do
+      let(:string) { '   ' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+  end
+  describe "#space?" do
+    subject { super().space? }
+    context "when given an empty string" do
+      let(:string) { '' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given one space" do
+      let(:string) { ' ' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given multiple spaces" do
+      let(:string) { '   ' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+  end
+  describe "#ellipsis" do
+    subject { super().ellipsis }
+    context "when given '...'" do
+      let(:string) { '...' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+  end
+  describe "#ellipsis?" do
+    subject { super().ellipsis? }
+    context "when given an empty string" do
+      let(:string) { '' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given '...'" do
+      let(:string) { '...' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq({repeats: string})
+      end
+    end
+    context "when given ' ...'" do
+      let(:string) { ' ...' }
+      it "must parse the '...'" do
+        expect(subject.parse(string)).to eq({repeats: string.strip})
+      end
+    end
+  end
+  describe "#capitalized_name" do
+    subject { super().capitalized_name }
+    context "when given a single lowercase character" do
+      let(:string) { 'a' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given a '-' character" do
+      let(:string) { '-' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given a '_' character" do
+      let(:string) { '_' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given one uppercase character" do
+      let(:string) { 'A' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when more than one uppercase character" do
+      let(:string) { 'AB' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given one uppercase character and a lowercase character" do
+      let(:string) { 'Ab' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given one uppercase character followed by multiple lowercase characters" do
+      let(:string) { 'Abbbb' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+      context "and it contains a '_' character" do
+        let(:string) { 'Abb_bb' }
+        it "must parse it" do
+          expect(subject.parse(string)).to eq(string)
+        end
+      end
+      context "but it contains repeating '_' characters" do
+        let(:string) { 'Abb__bb' }
+        it "must not parse it" do
+          expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+        end
+      end
+      context "and it contains a '-' character" do
+        let(:string) { 'Abb-bb' }
+        it "must parse it" do
+          expect(subject.parse(string)).to eq(string)
+        end
+      end
+      context "but it contains repeating '-' characters" do
+        let(:string) { 'Abb--bb' }
+        it "must not parse it" do
+          expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+        end
+      end
+    end
+    context "when given two uppercase characters" do
+      let(:string) { 'AB' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+  end
+  describe "#camelcase_name" do
+    subject { super().camelcase_name }
+    context "when given a single lowercase character" do
+      let(:string) { 'a' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given a '-' character" do
+      let(:string) { '-' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given a '_' character" do
+      let(:string) { '_' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given one uppercase character" do
+      let(:string) { 'A' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given one uppercase character and a lowercase character" do
+      let(:string) { 'Ab' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given one lowercase character" do
+      let(:string) { 'a' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given more than one lowercase characters" do
+      let(:string) { 'aaaaa' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given one or more lowercase characters then an uppercase character" do
+      let(:string) { 'aaaaaB' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given one or more lowercase characters, an uppercase character, then one or more lowercase characters" do
+      let(:string) { 'aaaaaBaaaa' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+      context "and it contains a '_' character" do
+        let(:string) { 'aaa_Baa' }
+        it "must not parse it" do
+          expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+        end
+      end
+      context "but it contains repeating '_' characters" do
+        let(:string) { 'aaa__Baa' }
+        it "must not parse it" do
+          expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+        end
+      end
+      context "and it contains a '-' character" do
+        let(:string) { 'aaa-Baa' }
+        it "must not parse it" do
+          expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+        end
+      end
+      context "but it contains repeating '-' characters" do
+        let(:string) { 'aaa--Baa' }
+        it "must not parse it" do
+          expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+        end
+      end
+    end
+  end
+  describe "#lowercase_name" do
+    subject { super().lowercase_name }
+    context "when given a '_' character" do
+      let(:string) { '_' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given one lowercase character" do
+      let(:string) { 'a' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given multiple lowercase characters" do
+      let(:string) { 'ab' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+      context "and it contains a '_' character" do
+        let(:string) { 'abb_bb' }
+        it "must parse it" do
+          expect(subject.parse(string)).to eq(string)
+        end
+      end
+      context "but it contains repeating '_' characters" do
+        let(:string) { 'abb__bb' }
+        it "must not parse it" do
+          expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+        end
+      end
+      context "and it contains a '-' character" do
+        let(:string) { 'abb-bb' }
+        it "must parse it" do
+          expect(subject.parse(string)).to eq(string)
+        end
+      end
+      context "but it contains repeating '-' characters" do
+        let(:string) { 'abb--bb' }
+        it "must not parse it" do
+          expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+        end
+      end
+    end
+    context "when given a single uppercase characters" do
+      let(:string) { 'A' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when it contains a uppercase character" do
+      let(:string) { 'aaaaBaaaa' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+  end
+  describe "#uppercase_name" do
+    subject { super().uppercase_name }
+    context "when given a '_' character" do
+      let(:string) { '_' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given one uppercase character" do
+      let(:string) { 'A' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given multiple uppercase characters" do
+      let(:string) { 'AB' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+      context "and it contains a '_' character" do
+        let(:string) { 'ABB_BB' }
+        it "must parse it" do
+          expect(subject.parse(string)).to eq(string)
+        end
+      end
+      context "but it contains repeating '_' characters" do
+        let(:string) { 'ABB__BB' }
+        it "must not parse it" do
+          expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+        end
+      end
+      context "and it contains a '-' character" do
+        let(:string) { 'ABB-BB' }
+        it "must parse it" do
+          expect(subject.parse(string)).to eq(string)
+        end
+      end
+      context "but it contains repeating '-' characters" do
+        let(:string) { 'ABB--BB' }
+        it "must not parse it" do
+          expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+        end
+      end
+    end
+    context "when given a single lowercase characters" do
+      let(:string) { 'a' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when it contains a uppercase character" do
+      let(:string) { 'AAAAbAAAA' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+  end
+  describe "#short_flag" do
+    subject { super().short_flag }
+    context "when given a single '-'" do
+      let(:string) { '-' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given a '-' and a lowercase alphabetic character" do
+      let(:string) { '-a' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given a '-' and a uppercase alphabetic character" do
+      let(:string) { '-A' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given a '-' and a numeric character" do
+      let(:string) { '-0' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given a '-' and a '#' character" do
+      let(:string) { '-#' }
+      it "must parse it" do
+        expect(subject.parse(string)).to eq(string)
+      end
+    end
+    context "when given '--'" do
+      let(:string) { '--' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given '-_'" do
+      let(:string) { '-_' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+  end
+  describe "#long_flag" do
+    subject { super().long_flag }
+    context "when given a '--'" do
+      let(:string) { '-' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given a '--' and a lowercase alphabetic character" do
+      let(:string) { '--a' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given a '--' and a uppercase alphabetic character" do
+      let(:string) { '--A' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given a '--' and a numeric character" do
+      let(:string) { '--0' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given a '---'" do
+      let(:string) { '---' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when given a '--' and an underscore" do
+      let(:string) { '--_' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when the string contains repeating '-' characters" do
+      let(:string) { '--foo--bar' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+    context "when the string contains repeating '_' characters" do
+      let(:string) { '--foo__bar' }
+      it "must not parse it" do
+        expect { subject.parse(string) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+  end
+end