Create contest with default template (#53)

Author: yuchiki

internal/cmd/ach/ach.go

@@ -2,6 +2,7 @@ package ach
 
 import (
 	"github.com/spf13/cobra"
+	"github.com/yuchiki/atcoderHelper/internal/cmd/ach/contest"
 	"github.com/yuchiki/atcoderHelper/internal/cmd/ach/version"
 )
 
@@ -19,6 +20,7 @@ func NewAchCmd() *cobra.Command {
 
 func registerSubcommands(cmd *cobra.Command) {
 	cmd.AddCommand(version.NewVersionCmd())
+	cmd.AddCommand(contest.NewContestCmd())
 }
 
 /*

internal/cmd/ach/ach_test.go

@@ -8,8 +8,8 @@ import (
 
 func TestAch_Execute(t *testing.T) {
 	testutil.TestCaseTemplates{
-		testutil.RootSucceeds(),
-		testutil.HasSubcommand("version"),
+		testutil.HasName("ach"),
+		testutil.HasSubcommands("version", "contest"),
 	}.
 		Build(NewAchCmd).
 		Run(t)

internal/cmd/ach/contest/contest.go

@@ -0,0 +1,22 @@
+package contest
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/yuchiki/atcoderHelper/internal/cmd/ach/contest/create"
+)
+
+func NewContestCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "contest",
+		Short: "manipulates an AtCoder contest",
+		Long:  `manipulates an AtCoder contest.`,
+	}
+
+	registerSubcommands(cmd)
+
+	return cmd
+}
+
+func registerSubcommands(cmd *cobra.Command) {
+	cmd.AddCommand(create.NewContestCreateCmd())
+}

internal/cmd/ach/contest/contest_test.go

@@ -0,0 +1,16 @@
+package contest
+
+import (
+	"testing"
+
+	"github.com/yuchiki/atcoderHelper/internal/testutil"
+)
+
+func TestAch_Execute(t *testing.T) {
+	testutil.TestCaseTemplates{
+		testutil.HasName("contest"),
+		testutil.HasSubcommands("create"),
+	}.
+		Build(NewContestCmd).
+		Run(t)
+}

internal/cmd/ach/contest/create/create.go

@@ -0,0 +1,52 @@
+package create
+
+import (
+	"log"
+	"os/exec"
+	"os/user"
+	"path"
+
+	"github.com/spf13/cobra"
+)
+
+// NewContestCreateCmd returns a new contest create command.
+func NewContestCreateCmd() *cobra.Command {
+	user, _ := user.Current()
+	templateDirName := path.Join(user.HomeDir, "projects", "private", "atcoder", "D")
+	taskNames := []string{"A", "B", "C", "D", "E", "F"}
+
+	useDefaultTemplate := new(bool)
+
+	cmd := &cobra.Command{
+		Use:   "create [contestName]",
+		Short: "creates contest directory",
+		Long:  "creates contest directory.",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			contestName := args[0]
+			err := exec.Command("mkdir", contestName).Run()
+			if err != nil {
+				return err
+			}
+
+			for _, taskName := range taskNames {
+				taskDirName := path.Join(contestName, taskName)
+
+				err := exec.Command("cp", "-r", templateDirName, taskDirName).Run()
+				if err != nil {
+					return err
+				}
+			}
+
+			return nil
+		},
+	}
+
+	cmd.Flags().BoolVarP(useDefaultTemplate, "default-template", "d", false, "use default contest template")
+
+	if cmd.MarkFlagRequired("default-template") != nil {
+		log.Fatal("default-template require")
+	}
+
+	return cmd
+}

internal/cmd/ach/contest/create/create_test.go

@@ -0,0 +1,16 @@
+package create
+
+import (
+	"testing"
+
+	"github.com/yuchiki/atcoderHelper/internal/testutil"
+)
+
+func TestCreate_Execute(t *testing.T) {
+	testutil.TestCaseTemplates{
+		testutil.HasName("create"),
+		// This is a temporal implementation with temporal args, so the test are given later.
+	}.
+		Build(NewContestCreateCmd).
+		Run(t)
+}

internal/testutil/testutil.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"strings"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
@@ -39,6 +40,12 @@ type (
 
 	// TestCaseTemplates is a suit of testCaseTemplates.
 	TestCaseTemplates []TestCaseTemplate
+
+	// HelpInfo contains information obtained from help message.
+	HelpInfo struct {
+		CommandName string
+		Subcommands []string
+	}
 )
 
 // OutputShouldBe returns a check for output.
@@ -52,6 +59,34 @@ func OutputShouldBe(expected string) OutputCheck {
 	}
 }
 
+// HelpShouldShowCommandName returns a check for command name.
+func HelpShouldShowCommandName(name string) OutputCheck {
+	return func(t *testing.T, output string) {
+		t.Helper()
+
+		help := ParseHelp(t, output)
+
+		if help.CommandName != name {
+			t.Errorf("expected %v, but actual %v", name, help.CommandName)
+		}
+	}
+}
+
+// HelpShouldShowSubcommands returns a check for subcommands.
+func HelpShouldShowSubcommands(subcommands []string) OutputCheck {
+	return func(t *testing.T, output string) {
+		t.Helper()
+
+		help := ParseHelp(t, output)
+
+		for _, subcommand := range subcommands {
+			if !Contains(subcommand, help.Subcommands) {
+				t.Errorf("subcommand %v is not included in %v", subcommand, help.Subcommands)
+			}
+		}
+	}
+}
+
 // ErrorShouldBe returns a check for error.
 func ErrorShouldBe(expected error) ErrorCheck {
 	return func(t *testing.T, err error) {
@@ -158,17 +193,81 @@ func (cts TestCaseTemplates) Build(cmdBuilder func() *cobra.Command) TestCases {
 	return TestCases(testCases)
 }
 
-// RootSucceeds returns a template which tests if the root succeeds.
-func RootSucceeds() TestCaseTemplate {
+// HasName returns a template which tests if the root -h succeeds and shows the name.
+func HasName(name string) TestCaseTemplate {
 	return TestCaseTemplate{
-		Name: "root succeeds",
+		Name:        fmt.Sprintf("root has Name %s", name),
+		Args:        []string{"-h"},
+		OutputCheck: HelpShouldShowCommandName(name),
 	}
 }
 
-// HasSubcommand returns a template which tests if it has the subcommand and it succeeds.
-func HasSubcommand(name string) TestCaseTemplate {
+// HasSubcommands returns a template which tests if it has the subcommand and it succeeds.
+func HasSubcommands(subcommands ...string) TestCaseTemplate {
 	return TestCaseTemplate{
-		Name: fmt.Sprintf("has Subcommand %s and it succeeds", name),
-		Args: []string{name},
+		Name:        fmt.Sprintf("has Subcommands %s and it succeeds", subcommands),
+		Args:        []string{"-h"},
+		OutputCheck: HelpShouldShowSubcommands(subcommands),
+	}
+}
+
+// ParseHelp parses a help message.
+func ParseHelp(t *testing.T, helpMessage string) HelpInfo {
+	t.Helper()
+
+	lines := strings.Split(helpMessage, "\n")
+
+	literal := map[string][]string{}
+
+	i := 0
+	for i < len(lines) {
+		if lines[i] == "" {
+			i++
+
+			continue
+		}
+
+		if !strings.HasSuffix(lines[i], ":") {
+			i++
+
+			continue
+		}
+
+		key := strings.TrimSuffix(lines[i], ":")
+		i++
+
+		for j := i; j < len(lines); j++ {
+			if !strings.HasPrefix(lines[j], "  ") {
+				break
+			}
+
+			literal[key] = append(literal[key], strings.TrimSpace(lines[j]))
+		}
 	}
+
+	if len(literal["Usage"]) == 0 {
+		t.Fatal("help message has no Usage section")
+	}
+
+	cmdName := strings.Fields(literal["Usage"][0])[0]
+
+	subcommands := []string{}
+	for _, cmdDescriptions := range literal["Available Commands"] {
+		subcommands = append(subcommands, strings.Fields(cmdDescriptions)[0])
+	}
+
+	return HelpInfo{
+		CommandName: cmdName,
+		Subcommands: subcommands,
+	}
+}
+
+func Contains(str string, arr []string) bool {
+	for _, elem := range arr {
+		if str == elem {
+			return true
+		}
+	}
+
+	return false
 }