Mitigate single dash long flags (#5)

* go linter complaint

* added heuristic to catch long short flags

* tests

* added error catching if everything else fails

* naming things is hard

* changed a comment

app.go

@@ -209,7 +209,7 @@ func (a *Application) parseContext(ignoreDefault bool, args []string) (*ParseCon
 // on.
 func (a *Application) Parse(args []string) (command string, err error) {
 	context, parseErr := a.ParseContext(args)
-	selected := []string{}
+	var selected []string
 	var setValuesErr error
 
 	if context == nil {

flags.go

@@ -147,7 +147,12 @@ func (f *flagGroup) parse(context *ParseContext) (*FlagClause, error) {
 					context.Elements = context.Elements[:len(context.Elements)-pos]
 					for x := len(current) - pos - 1; x > 0; x-- {
 						// We skip all remaining elements of the group
-						context.Next()
+						purgedToken := context.Next()
+						// This error isn't supposed to be possible, but let's handle it anyway.
+						if purgedToken.Type == TokenLong {
+							err = fmt.Errorf("while skipping unmanaged shorts flags, skipped long flag '%s' from '%s'", purgedToken.Value, current)
+							return nil, err
+						}
 					}
 				}
 				context.appUnmanagedArgs.Unmanaged = append(context.appUnmanagedArgs.Unmanaged, current)

parser.go

@@ -192,7 +192,7 @@ func (p *ParseContext) Next() *Token {
 		return p.Next()
 	}
 
-	if strings.HasPrefix(arg, "--") {
+	if strings.HasPrefix(arg, "--") || (strings.HasPrefix(arg, "-") && strings.Count(arg, "-") > 1) {
 		parts := strings.SplitN(arg[2:], "=", 2)
 		token := &Token{p.argi, TokenLong, parts[0]}
 		if len(parts) == 2 {

parser_test.go

@@ -120,3 +120,56 @@ func TestParseContextPush(t *testing.T) {
 	b = c.Next()
 	assert.Equal(t, "bar", b.Value)
 }
+
+func TestAppParseSingleThenDoubleDashFlags(t *testing.T) {
+	app := New("test", "")
+	app.allowUnmanaged = true
+	app.Command("foo", "")
+
+	_, err := app.ParseContext([]string{"foo", "-single-dash", "--double-dash"})
+	assert.Nil(t, err)
+	assert.Equal(t, []string{"-single-dash", "--double-dash"}, app.Unmanaged)
+}
+
+func TestAppParseTwoSingleDashFlags(t *testing.T) {
+	app := New("test", "")
+	app.allowUnmanaged = true
+	app.Command("foo", "")
+
+	_, err := app.ParseContext([]string{"foo", "-short-flag", "-verylongshort-flag"})
+	assert.Nil(t, err)
+	assert.Equal(t, []string{"-short-flag", "-verylongshort-flag"}, app.Unmanaged)
+}
+
+func TestAppParseDoubleThenSingleDashFlags(t *testing.T) {
+	app := New("test", "")
+	app.allowUnmanaged = true
+	app.Command("foo", "")
+
+	_, err := app.ParseContext([]string{"foo", "--double-dash", "-single-dash"})
+	assert.Nil(t, err)
+	assert.Equal(t, []string{"--double-dash", "-single-dash"}, app.Unmanaged)
+}
+
+func TestAppParseVerboseVarFlags(t *testing.T) {
+	app := New("test", "")
+	app.allowUnmanaged = true
+	app.Command("foo", "")
+	app.Flag("verbose", "").Short('v').Bool()
+
+	_, err := app.ParseContext([]string{"foo", "-v", "-var"})
+	assert.Nil(t, err)
+	assert.Equal(t, []string{"-var"}, app.Unmanaged)
+}
+
+func TestAppParseUnmanagedVarWithTwoManagedFlags(t *testing.T) {
+	app := New("test", "")
+	app.allowUnmanaged = true
+	app.Command("foo", "")
+	app.Flag("verbose", "").Short('v').Bool()
+	app.Flag("aflag", "").Short('a').Bool()
+
+	_, err := app.ParseContext([]string{"foo", "-var"})
+	assert.Nil(t, err)
+	assert.Equal(t, []string{"-var"}, app.Unmanaged)
+}