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

command_mapper-gen 0.1.0.pre1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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