refactor: move java domain to jdomain

cmd/api.go

@@ -6,7 +6,7 @@ import (
 	"github.com/phodal/coca/cmd/config"
 	"github.com/phodal/coca/pkg/application/api"
 	"github.com/phodal/coca/pkg/application/call"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/domain/support_domain"
 	"github.com/spf13/cobra"
 	"log"
@@ -31,8 +31,8 @@ var (
 	restApis     []api_domain.RestAPI
 
 	identifiers    = cmd_util.LoadIdentify(apiCmdConfig.DependencePath)
-	identifiersMap = domain.BuildIdentifierMap(identifiers)
-	diMap          = domain.BuildDIMap(identifiers, identifiersMap)
+	identifiersMap = jdomain.BuildIdentifierMap(identifiers)
+	diMap          = jdomain.BuildDIMap(identifiers, identifiersMap)
 )
 
 var apiCmd = &cobra.Command{

cmd/arch.go

@@ -6,7 +6,7 @@ import (
 	"github.com/phodal/coca/cmd/config"
 	"github.com/phodal/coca/pkg/application/arch"
 	"github.com/phodal/coca/pkg/application/arch/tequila"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/spf13/cobra"
 	"os"
 	"strings"
@@ -27,7 +27,7 @@ var archCmd = &cobra.Command{
 	Long:  ``,
 	Run: func(cmd *cobra.Command, args []string) {
 		identifiers = cmd_util.LoadIdentify(apiCmdConfig.DependencePath)
-		identifiersMap = domain.BuildIdentifierMap(identifiers)
+		identifiersMap = jdomain.BuildIdentifierMap(identifiers)
 
 		parsedDeps := cmd_util.GetDepsFromJson(archCmdConfig.DependencePath)
 		archApp := arch.NewArchApp()

cmd/call.go

@@ -5,7 +5,7 @@ import (
 	"github.com/phodal/coca/cmd/cmd_util"
 	"github.com/phodal/coca/cmd/config"
 	. "github.com/phodal/coca/pkg/application/call"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/spf13/cobra"
 	"log"
 	"strings"
@@ -24,7 +24,7 @@ var callGraphCmd = &cobra.Command{
 	Short: "show call graph with specific method",
 	Long:  ``,
 	Run: func(cmd *cobra.Command, args []string) {
-		var parsedDeps []domain.JClassNode
+		var parsedDeps []jdomain.JClassNode
 		dependence := callCmdConfig.Path
 
 		className := cmd.Flag("className").Value.String()

cmd/cmd_util/deps_loader.go

@@ -2,11 +2,11 @@ package cmd_util
 
 import (
 	"encoding/json"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 )
 
-func GetDepsFromJson(depPath string) []domain.JClassNode {
-	var parsedDeps []domain.JClassNode
+func GetDepsFromJson(depPath string) []jdomain.JClassNode {
+	var parsedDeps []jdomain.JClassNode
 	file := ReadFile(depPath)
 	_ = json.Unmarshal(file, &parsedDeps)
 

cmd/cmd_util/ident_helper.go

@@ -3,19 +3,19 @@ package cmd_util
 import (
 	"encoding/json"
 	"github.com/phodal/coca/pkg/application/analysis"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 )
 
-func LoadIdentify(importPath string) []domain.JIdentifier {
+func LoadIdentify(importPath string) []jdomain.JIdentifier {
 	return readIdentify(importPath, "identify.json", analysisByPath)
 }
 
-func LoadTestIdentify(files []string) []domain.JIdentifier {
+func LoadTestIdentify(files []string) []jdomain.JIdentifier {
 	return readIdentify(files, "tidentify.json", analysisByFiles)
 }
 
-func readIdentify(importPath interface{}, fileName string, analysisApp func(importPath interface{}) []domain.JIdentifier) []domain.JIdentifier {
-	var identifiers []domain.JIdentifier
+func readIdentify(importPath interface{}, fileName string, analysisApp func(importPath interface{}) []jdomain.JIdentifier) []jdomain.JIdentifier {
+	var identifiers []jdomain.JIdentifier
 
 	apiContent := ReadCocaFile(fileName)
 	if apiContent == nil || string(apiContent) == "null" {
@@ -30,13 +30,13 @@ func readIdentify(importPath interface{}, fileName string, analysisApp func(impo
 	return identifiers
 }
 
-func analysisByPath(importPath interface{}) []domain.JIdentifier {
+func analysisByPath(importPath interface{}) []jdomain.JIdentifier {
 	identifierApp := new(analysis.JavaIdentifierApp)
 	ident := identifierApp.AnalysisPath(importPath.(string))
 	return ident
 }
 
-func analysisByFiles(files interface{}) []domain.JIdentifier {
+func analysisByFiles(files interface{}) []jdomain.JIdentifier {
 	identifierApp := analysis.NewJavaIdentifierApp()
 	ident := identifierApp.AnalysisFiles(files.([]string))
 	return ident

cmd/concept.go

@@ -5,12 +5,12 @@ import (
 	"github.com/phodal/coca/cmd/cmd_util"
 	"github.com/phodal/coca/cmd/config"
 	"github.com/phodal/coca/pkg/application/concept"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/spf13/cobra"
 	"strconv"
 )
 
-var parsedDeps []domain.JClassNode
+var parsedDeps []jdomain.JClassNode
 
 var conceptCmd = &cobra.Command{
 	Use:   "concept",

cmd/count.go

@@ -5,7 +5,7 @@ import (
 	"github.com/phodal/coca/cmd/cmd_util"
 	"github.com/phodal/coca/cmd/config"
 	"github.com/phodal/coca/pkg/application/count"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/infrastructure/string_helper"
 	"github.com/spf13/cobra"
 	"strconv"
@@ -20,7 +20,7 @@ var (
 	countCmdConfig CountCmdConfig
 )
 
-var cparsedDeps []domain.JClassNode
+var cparsedDeps []jdomain.JClassNode
 
 var countCmd = &cobra.Command{
 	Use:   "count",

cmd/deps.go

@@ -6,7 +6,7 @@ import (
 	"github.com/phodal/coca/pkg/adapter/cocafile"
 	"github.com/phodal/coca/pkg/application/analysis"
 	"github.com/phodal/coca/pkg/application/deps"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/domain/support_domain"
 	"github.com/spf13/cobra"
 	"path/filepath"
@@ -21,7 +21,7 @@ var (
 )
 
 type DepApp interface {
-	AnalysisPath(path string, nodes []domain.JClassNode) []api_domain.JDependency
+	AnalysisPath(path string, nodes []jdomain.JClassNode) []api_domain.JDependency
 }
 
 var depsCmd = &cobra.Command{

cmd/evaluate.go

@@ -7,7 +7,7 @@ import (
 	"github.com/phodal/coca/cmd/config"
 	"github.com/phodal/coca/pkg/application/evaluate"
 	"github.com/phodal/coca/pkg/application/evaluate/evaluator"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/spf13/cobra"
 	"log"
 	"strconv"
@@ -34,7 +34,7 @@ var evaluateCmd = &cobra.Command{
 			log.Fatal("lost file:" + dependence)
 		}
 
-		var identifiers []domain.JIdentifier
+		var identifiers []jdomain.JIdentifier
 		identContent := cmd_util.ReadCocaFile("identify.json")
 
 		_ = json.Unmarshal(identContent, &identifiers)

cmd/tbs.go

@@ -7,7 +7,7 @@ import (
 	"github.com/phodal/coca/pkg/adapter/cocafile"
 	"github.com/phodal/coca/pkg/application/analysis"
 	"github.com/phodal/coca/pkg/application/tbs"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/spf13/cobra"
 	"strconv"
 )
@@ -29,7 +29,7 @@ var tbsCmd = &cobra.Command{
 		files := cocafile.GetJavaTestFiles(tbsCmdConfig.Path)
 
 		identifiers := cmd_util.LoadTestIdentify(files)
-		identifiersMap := domain.BuildIdentifierMap(identifiers)
+		identifiersMap := jdomain.BuildIdentifierMap(identifiers)
 
 		var classes []string = nil
 		for _, node := range identifiers {

cocatest/testhelper/generate.go

@@ -2,11 +2,11 @@ package testhelper
 
 import (
 	"github.com/phodal/coca/pkg/application/analysis"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"path/filepath"
 )
 
-func BuildAnalysisDeps(codePath string) ([]domain.JClassNode, map[string]domain.JIdentifier, []domain.JIdentifier) {
+func BuildAnalysisDeps(codePath string) ([]jdomain.JClassNode, map[string]jdomain.JIdentifier, []jdomain.JIdentifier) {
 	codePath = filepath.FromSlash(codePath)
 
 	identifierApp := analysis.NewJavaIdentifierApp()
@@ -19,7 +19,7 @@ func BuildAnalysisDeps(codePath string) ([]domain.JClassNode, map[string]domain.
 	callApp := analysis.NewJavaFullApp()
 	callNodes := callApp.AnalysisPath(codePath, classes, identifiers)
 
-	identifiersMap := domain.BuildIdentifierMap(identifiers)
+	identifiersMap := jdomain.BuildIdentifierMap(identifiers)
 	return callNodes, identifiersMap, identifiers
 }
 

pkg/application/analysis/java_full_app.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"github.com/antlr/antlr4/runtime/Go/antlr"
 	"github.com/phodal/coca/pkg/adapter/cocafile"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/infrastructure/ast"
 	"github.com/phodal/coca/pkg/infrastructure/ast/full"
 	"path/filepath"
@@ -17,15 +17,15 @@ func NewJavaFullApp() JavaFullApp {
 	return JavaFullApp{}
 }
 
-func (j *JavaFullApp) AnalysisPath(codeDir string, classes []string, identNodes []domain.JIdentifier) []domain.JClassNode {
+func (j *JavaFullApp) AnalysisPath(codeDir string, classes []string, identNodes []jdomain.JIdentifier) []jdomain.JClassNode {
 	files := cocafile.GetJavaFiles(codeDir)
 	return j.AnalysisFiles(identNodes, files, classes)
 }
 
-func (j *JavaFullApp) AnalysisFiles(identNodes []domain.JIdentifier, files []string, classes []string) []domain.JClassNode {
-	var nodeInfos []domain.JClassNode
+func (j *JavaFullApp) AnalysisFiles(identNodes []jdomain.JIdentifier, files []string, classes []string) []jdomain.JClassNode {
+	var nodeInfos []jdomain.JClassNode
 
-	var identMap = make(map[string]domain.JIdentifier)
+	var identMap = make(map[string]jdomain.JIdentifier)
 	for _, ident := range identNodes {
 		identMap[ident.GetClassFullName()] = ident
 	}

pkg/application/analysis/java_full_app_test.go

@@ -2,7 +2,7 @@ package analysis
 
 import (
 	. "github.com/onsi/gomega"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"path/filepath"
 	"testing"
 )
@@ -36,7 +36,7 @@ func TestJavaCallListener_EnterConstructorDeclaration(t *testing.T) {
 	g.Expect(len(callNodes[0].Methods)).To(Equal(3))
 }
 
-func getCallNodes(codePath string) []domain.JClassNode {
+func getCallNodes(codePath string) []jdomain.JClassNode {
 	identifierApp := NewJavaIdentifierApp()
 	iNodes := identifierApp.AnalysisPath(codePath)
 	var classes []string = nil
@@ -58,7 +58,7 @@ func TestLambda_Express(t *testing.T) {
 
 	callNodes := getCallNodes(codePath)
 
-	methodMap := make(map[string]domain.JMethod)
+	methodMap := make(map[string]jdomain.JMethod)
 	for _, c := range callNodes[1].Methods {
 		methodMap[c.Name] = c
 	}
@@ -75,7 +75,7 @@ func TestInterface(t *testing.T) {
 
 	callNodes := getCallNodes(codePath)
 
-	methodMap := make(map[string]domain.JMethod)
+	methodMap := make(map[string]jdomain.JMethod)
 
 	for _, c := range callNodes[0].Methods {
 		methodMap[c.Name] = c
@@ -93,7 +93,7 @@ func TestAnnotation(t *testing.T) {
 
 	callNodes := getCallNodes(codePath)
 
-	methodMap := make(map[string]domain.JMethod)
+	methodMap := make(map[string]jdomain.JMethod)
 	for _, c := range callNodes[0].Methods {
 		methodMap[c.Name] = c
 	}
@@ -110,7 +110,7 @@ func Test_ShouldHaveOnlyOneAnnotation(t *testing.T) {
 
 	callNodes := getCallNodes(codePath)
 
-	methodMap := make(map[string]domain.JMethod)
+	methodMap := make(map[string]jdomain.JMethod)
 	for _, c := range callNodes[0].Methods {
 		methodMap[c.Name] = c
 	}
@@ -127,7 +127,7 @@ func Test_ShouldHaveOnlyOneAnnotationWithMultipleSame(t *testing.T) {
 
 	callNodes := getCallNodes(codePath)
 
-	methodMap := make(map[string]domain.JMethod)
+	methodMap := make(map[string]jdomain.JMethod)
 	for _, c := range callNodes[0].Methods {
 		methodMap[c.Name] = c
 	}
@@ -147,7 +147,7 @@ func Test_CreatorAnnotation(t *testing.T) {
 
 	callNodes := getCallNodes(codePath)
 
-	methodMap := make(map[string]domain.JMethod)
+	methodMap := make(map[string]jdomain.JMethod)
 	for _, c := range callNodes[0].Methods {
 		methodMap[c.Name] = c
 	}
@@ -163,7 +163,7 @@ func Test_ShouldGetMethodCreators(t *testing.T) {
 
 	callNodes := getCallNodes(codePath)
 
-	methodMap := make(map[string]domain.JMethod)
+	methodMap := make(map[string]jdomain.JMethod)
 	for _, c := range callNodes[0].Methods {
 		methodMap[c.Name] = c
 	}
@@ -179,7 +179,7 @@ func Test_ShouldNotGetCreators(t *testing.T) {
 
 	callNodes := getCallNodes(codePath)
 
-	methodMap := make(map[string]domain.JMethod)
+	methodMap := make(map[string]jdomain.JMethod)
 	for _, c := range callNodes[0].Methods {
 		methodMap[c.Name] = c
 	}
@@ -195,7 +195,7 @@ func Test_ShouldGetMethodCallParameters(t *testing.T) {
 
 	callNodes := getCallNodes(codePath)
 
-	methodCallMap := make(map[string]domain.JMethodCall)
+	methodCallMap := make(map[string]jdomain.JMethodCall)
 	for _, method := range callNodes[0].Methods {
 		for _, call := range method.MethodCalls {
 			methodCallMap[call.MethodName] = call
@@ -213,7 +213,7 @@ func Test_BuilderCallSplitIssue(t *testing.T) {
 
 	callNodes := getCallNodes(codePath)
 
-	methodCallMap := make(map[string]domain.JMethodCall)
+	methodCallMap := make(map[string]jdomain.JMethodCall)
 	for _, method := range callNodes[0].Methods {
 		for _, call := range method.MethodCalls {
 			methodCallMap[call.MethodName] = call

pkg/application/analysis/java_identifier_app.go

@@ -3,7 +3,7 @@ package analysis
 import (
 	"github.com/antlr/antlr4/runtime/Go/antlr"
 	"github.com/phodal/coca/pkg/adapter/cocafile"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/infrastructure/ast"
 	"github.com/phodal/coca/pkg/infrastructure/ast/identifier"
 )
@@ -16,13 +16,13 @@ func NewJavaIdentifierApp() JavaIdentifierApp {
 	return JavaIdentifierApp{}
 }
 
-func (j *JavaIdentifierApp) AnalysisPath(codeDir string) []domain.JIdentifier {
+func (j *JavaIdentifierApp) AnalysisPath(codeDir string) []jdomain.JIdentifier {
 	files := cocafile.GetJavaFiles(codeDir)
 	return j.AnalysisFiles(files)
 }
 
-func (j *JavaIdentifierApp) AnalysisFiles(files []string) []domain.JIdentifier {
-	var nodeInfos []domain.JIdentifier = nil
+func (j *JavaIdentifierApp) AnalysisFiles(files []string) []jdomain.JIdentifier {
+	var nodeInfos []jdomain.JIdentifier = nil
 
 	for _, file := range files {
 		parser := ast.ProcessJavaFile(file)

pkg/application/api/java_api_app.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"github.com/antlr/antlr4/runtime/Go/antlr"
 	"github.com/phodal/coca/pkg/adapter/cocafile"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/domain/support_domain"
 	"github.com/phodal/coca/pkg/infrastructure/ast"
 	"github.com/phodal/coca/pkg/infrastructure/ast/api"
@@ -16,7 +16,7 @@ var allApis []api_domain.RestAPI
 type JavaApiApp struct {
 }
 
-func (j *JavaApiApp) AnalysisPath(codeDir string, parsedDeps []domain.JClassNode, identifiersMap map[string]domain.JIdentifier, diMap map[string]string) []api_domain.RestAPI {
+func (j *JavaApiApp) AnalysisPath(codeDir string, parsedDeps []jdomain.JClassNode, identifiersMap map[string]jdomain.JIdentifier, diMap map[string]string) []api_domain.RestAPI {
 	files := cocafile.GetJavaFiles(codeDir)
 	allApis = nil
 	for index := range files {

pkg/application/api/java_api_app_test.go

@@ -3,7 +3,7 @@ package api
 import (
 	. "github.com/onsi/gomega"
 	"github.com/phodal/coca/cocatest/testhelper"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"testing"
 )
 
@@ -12,7 +12,7 @@ func TestJavaCallApp_AnalysisPath(t *testing.T) {
 
 	codePath := "../../../_fixtures/call"
 	callNodes, identifiersMap, identifiers := testhelper.BuildAnalysisDeps(codePath)
-	diMap := domain.BuildDIMap(identifiers, identifiersMap)
+	diMap := jdomain.BuildDIMap(identifiers, identifiersMap)
 
 	app := new(JavaApiApp)
 	restApis := app.AnalysisPath(codePath, callNodes, identifiersMap, diMap)

pkg/application/arch/arch_app.go

@@ -2,7 +2,7 @@ package arch
 
 import (
 	"github.com/phodal/coca/pkg/application/arch/tequila"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 )
 
 type ArchApp struct {
@@ -12,7 +12,7 @@ func NewArchApp() ArchApp {
 	return ArchApp{}
 }
 
-func (a ArchApp) Analysis(deps []domain.JClassNode, identifiersMap map[string]domain.JIdentifier) *tequila.FullGraph {
+func (a ArchApp) Analysis(deps []jdomain.JClassNode, identifiersMap map[string]jdomain.JIdentifier) *tequila.FullGraph {
 	fullGraph := &tequila.FullGraph{
 		NodeList:     make(map[string]string),
 		RelationList: make(map[string]*tequila.Relation),
@@ -44,7 +44,7 @@ func (a ArchApp) Analysis(deps []domain.JClassNode, identifiersMap map[string]do
 	return fullGraph
 }
 
-func addCallInField(clz domain.JClassNode, src string, fullGraph tequila.FullGraph) {
+func addCallInField(clz jdomain.JClassNode, src string, fullGraph tequila.FullGraph) {
 	for _, field := range clz.MethodCalls {
 		dst := field.Package + "." + field.Class
 		relation := &tequila.Relation{
@@ -57,7 +57,7 @@ func addCallInField(clz domain.JClassNode, src string, fullGraph tequila.FullGra
 	}
 }
 
-func addCallInMethod(clz domain.JClassNode, identifiersMap map[string]domain.JIdentifier, src string, fullGraph tequila.FullGraph) {
+func addCallInMethod(clz jdomain.JClassNode, identifiersMap map[string]jdomain.JIdentifier, src string, fullGraph tequila.FullGraph) {
 	for _, method := range clz.Methods {
 		if method.Name == "main" {
 			continue
@@ -83,7 +83,7 @@ func addCallInMethod(clz domain.JClassNode, identifiersMap map[string]domain.JId
 	}
 }
 
-func addExtend(clz domain.JClassNode, src string, fullGraph tequila.FullGraph) {
+func addExtend(clz jdomain.JClassNode, src string, fullGraph tequila.FullGraph) {
 	if clz.Extend != "" {
 		relation := &tequila.Relation{
 			From:  src,

pkg/application/call/call_graph.go

 package call
 
 import (
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/domain/support_domain"
 	"github.com/phodal/coca/pkg/infrastructure/jpackage"
 	"strings"
@@ -14,7 +14,7 @@ func NewCallGraph() CallGraph {
 	return CallGraph{}
 }
 
-func (c CallGraph) Analysis(funcName string, clzs []domain.JClassNode) string {
+func (c CallGraph) Analysis(funcName string, clzs []jdomain.JClassNode) string {
 	methodMap := BuildMethodMap(clzs)
 	chain := BuildCallChain(funcName, methodMap, nil)
 	dotContent := ToGraphviz(chain)
@@ -56,7 +56,7 @@ func BuildCallChain(funcName string, methodMap map[string][]string, diMap map[st
 	return "\n"
 }
 
-func (c CallGraph) AnalysisByFiles(restApis []api_domain.RestAPI, deps []domain.JClassNode, diMap map[string]string) (string, []api_domain.CallAPI) {
+func (c CallGraph) AnalysisByFiles(restApis []api_domain.RestAPI, deps []jdomain.JClassNode, diMap map[string]string) (string, []api_domain.CallAPI) {
 	methodMap := BuildMethodMap(deps)
 	var apiCallSCounts []api_domain.CallAPI
 
@@ -88,7 +88,7 @@ func escapeStr(caller string) string {
 	return strings.ReplaceAll(caller, "\"", "\\\"")
 }
 
-func BuildMethodMap(clzs []domain.JClassNode) map[string][]string {
+func BuildMethodMap(clzs []jdomain.JClassNode) map[string][]string {
 	var methodMap = make(map[string][]string)
 	for _, clz := range clzs {
 		for _, method := range clz.Methods {

pkg/application/call/call_graph_test.go

@@ -7,7 +7,7 @@ import (
 	"github.com/phodal/coca/cocatest/testhelper"
 	"github.com/phodal/coca/pkg/application/api"
 	"github.com/phodal/coca/pkg/application/call"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/domain/support_domain"
 	"path/filepath"
 	"testing"
@@ -16,7 +16,7 @@ import (
 func Test_ShouldBuildSuccessDataFromJson(t *testing.T) {
 	g := NewGomegaWithT(t)
 
-	var parsedDeps []domain.JClassNode
+	var parsedDeps []jdomain.JClassNode
 	analyser := call.NewCallGraph()
 	codePath := "../../../_fixtures/call/call_api_test.json"
 	codePath = filepath.FromSlash(codePath)
@@ -44,7 +44,7 @@ func Test_ShouldBuildSuccessDataFromSourceData(t *testing.T) {
 	codePath := "../../../_fixtures/examples/api"
 	callNodes, identifiersMap, identifiers := testhelper.BuildAnalysisDeps(codePath)
 
-	diMap := domain.BuildDIMap(identifiers, identifiersMap)
+	diMap := jdomain.BuildDIMap(identifiers, identifiersMap)
 	app := new(api.JavaApiApp)
 	restApis := app.AnalysisPath(codePath, callNodes, identifiersMap, diMap)
 

pkg/application/concept/concept_analyser.go

@@ -2,7 +2,7 @@ package concept
 
 import (
 	languages2 "github.com/phodal/coca/pkg/application/call/stop_words/languages"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/infrastructure/constants"
 	"github.com/phodal/coca/pkg/infrastructure/string_helper"
 )
@@ -14,11 +14,11 @@ func NewConceptAnalyser() ConceptAnalyser {
 	return ConceptAnalyser{}
 }
 
-func (c ConceptAnalyser) Analysis(clzs *[]domain.JClassNode) string_helper.PairList {
+func (c ConceptAnalyser) Analysis(clzs *[]jdomain.JClassNode) string_helper.PairList {
 	return buildMethodsFromDeps(*clzs)
 }
 
-func buildMethodsFromDeps(clzs []domain.JClassNode) string_helper.PairList {
+func buildMethodsFromDeps(clzs []jdomain.JClassNode) string_helper.PairList {
 	var methodsName []string
 	var methodStr string
 	for _, clz := range clzs {

pkg/application/concept/concept_analyser_test.go

@@ -3,7 +3,7 @@ package concept
 import (
 	"encoding/json"
 	"github.com/phodal/coca/cmd/cmd_util"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"log"
 	"path/filepath"
 	"testing"
@@ -14,7 +14,7 @@ import (
 func TestConceptAnalyser_Analysis(t *testing.T) {
 	g := NewGomegaWithT(t)
 
-	var parsedDeps []domain.JClassNode
+	var parsedDeps []jdomain.JClassNode
 	analyser := NewConceptAnalyser()
 	codePath := "../../../_fixtures/call/call_api_test.json"
 	codePath = filepath.FromSlash(codePath)

pkg/application/count/count_app.go

 package count
 
-import "github.com/phodal/coca/pkg/domain"
+import (
+	"github.com/phodal/coca/pkg/domain/jdomain"
+)
 
-func BuildCallMap(parserDeps []domain.JClassNode) map[string]int {
+func BuildCallMap(parserDeps []jdomain.JClassNode) map[string]int {
 	var projectMethods = make(map[string]string)
 	for _, clz := range parserDeps {
 		clz.BuildStringMethodMap(projectMethods)

pkg/application/count/count_app_test.go

@@ -4,14 +4,14 @@ import (
 	"encoding/json"
 	. "github.com/onsi/gomega"
 	"github.com/phodal/coca/cmd/cmd_util"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"path/filepath"
 	"testing"
 )
 
 func TestBuildCallMap(t *testing.T) {
 	g := NewGomegaWithT(t)
-	var parsedDeps []domain.JClassNode
+	var parsedDeps []jdomain.JClassNode
 	codePath := "../../../_fixtures/count/call.json"
 	codePath = filepath.FromSlash(codePath)
 	file := cmd_util.ReadFile(codePath)

pkg/application/deps/dep_app.go

@@ -2,7 +2,7 @@ package deps
 
 import (
 	"github.com/phodal/coca/pkg/adapter/cocafile"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/domain/support_domain"
 	"path/filepath"
 	"strings"
@@ -15,8 +15,8 @@ func NewDepApp() *DepAnalysisApp {
 	return &DepAnalysisApp{}
 }
 
-func (d *DepAnalysisApp) BuildImportMap(deps []domain.JClassNode) map[string]domain.JImport {
-	var impMap = make(map[string]domain.JImport)
+func (d *DepAnalysisApp) BuildImportMap(deps []jdomain.JClassNode) map[string]jdomain.JImport {
+	var impMap = make(map[string]jdomain.JImport)
 	for _, clz := range deps {
 		for _, imp := range clz.Imports {
 			impMap[imp.Source] = imp
@@ -26,7 +26,7 @@ func (d *DepAnalysisApp) BuildImportMap(deps []domain.JClassNode) map[string]dom
 	return impMap
 }
 
-func (d *DepAnalysisApp) AnalysisPath(path string, nodes []domain.JClassNode) []api_domain.JDependency {
+func (d *DepAnalysisApp) AnalysisPath(path string, nodes []jdomain.JClassNode) []api_domain.JDependency {
 	path, _ = filepath.Abs(path)
 	pomXmls := cocafile.GetFilesWithFilter(path, cocafile.PomXmlFilter)
 	gradleFiles := cocafile.GetFilesWithFilter(path, cocafile.BuildGradleFilter)

pkg/application/evaluate/analyser.go

@@ -2,7 +2,7 @@ package evaluate
 
 import (
 	"github.com/phodal/coca/pkg/application/evaluate/evaluator"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"gonum.org/v1/gonum/stat"
 )
 
@@ -13,12 +13,12 @@ func NewEvaluateAnalyser() Analyser {
 	return Analyser{}
 }
 
-func (a Analyser) Analysis(classNodes []domain.JClassNode, identifiers []domain.JIdentifier) evaluator.EvaluateModel {
-	var servicesNode []domain.JClassNode = nil
+func (a Analyser) Analysis(classNodes []jdomain.JClassNode, identifiers []jdomain.JIdentifier) evaluator.EvaluateModel {
+	var servicesNode []jdomain.JClassNode = nil
 	var evaluation Evaluation
 	var result = evaluator.NewEvaluateModel()
 
-	var nodeMap = make(map[string]domain.JClassNode)
+	var nodeMap = make(map[string]jdomain.JClassNode)
 
 	for _, node := range classNodes {
 		nodeMap[node.Class] = node
@@ -48,7 +48,7 @@ func (a Analyser) Analysis(classNodes []domain.JClassNode, identifiers []domain.
 	return result
 }
 
-func SummaryMethodIdentifier(identifiers []domain.JIdentifier, result *evaluator.EvaluateModel) {
+func SummaryMethodIdentifier(identifiers []jdomain.JIdentifier, result *evaluator.EvaluateModel) {
 	var methodLengthArray []float64
 	var methodCountArray []float64
 	for _, ident := range identifiers {

pkg/application/evaluate/analyser_test.go

@@ -6,7 +6,7 @@ import (
 	"github.com/phodal/coca/cmd/cmd_util"
 	"github.com/phodal/coca/cocatest/testhelper"
 	"github.com/phodal/coca/pkg/application/evaluate/evaluator"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"path/filepath"
 	"testing"
 )
@@ -14,7 +14,7 @@ import (
 func TestAnalyser_Analysis(t *testing.T) {
 	g := NewGomegaWithT(t)
 
-	var parsedDeps []domain.JClassNode
+	var parsedDeps []jdomain.JClassNode
 	analyser := NewEvaluateAnalyser()
 	codePath := "../../../_fixtures/evaluate/service.json"
 	codePath = filepath.FromSlash(codePath)
@@ -29,7 +29,7 @@ func TestAnalyser_Analysis(t *testing.T) {
 func Test_Service_LifeCycle(t *testing.T) {
 	g := NewGomegaWithT(t)
 
-	var parsedDeps []domain.JClassNode
+	var parsedDeps []jdomain.JClassNode
 	analyser := NewEvaluateAnalyser()
 	codePath := "../../../_fixtures/evaluate/service_lifecycle.json"
 	codePath = filepath.FromSlash(codePath)
@@ -46,7 +46,7 @@ func Test_Service_LifeCycle(t *testing.T) {
 func Test_Service_Same_Return_Type(t *testing.T) {
 	g := NewGomegaWithT(t)
 
-	var parsedDeps []domain.JClassNode
+	var parsedDeps []jdomain.JClassNode
 	analyser := NewEvaluateAnalyser()
 	codePath := "../../../_fixtures/evaluate/service_same_return_type.json"
 	codePath = filepath.FromSlash(codePath)
@@ -61,7 +61,7 @@ func Test_Service_Same_Return_Type(t *testing.T) {
 func Test_Long_Parameters(t *testing.T) {
 	g := NewGomegaWithT(t)
 
-	var parsedDeps []domain.JClassNode
+	var parsedDeps []jdomain.JClassNode
 	analyser := NewEvaluateAnalyser()
 	codePath := "../../../_fixtures/evaluate/service_long_parameters.json"
 	codePath = filepath.FromSlash(codePath)

pkg/application/evaluate/evaluate.go

@@ -2,22 +2,22 @@ package evaluate
 
 import (
 	"github.com/phodal/coca/pkg/application/evaluate/evaluator"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 )
 
 type Evaluator interface {
-	Evaluate(result *evaluator.EvaluateModel, node domain.JClassNode)
-	EvaluateList(evaluateModel *evaluator.EvaluateModel, nodes []domain.JClassNode, nodeMap map[string]domain.JClassNode, identifiers []domain.JIdentifier)
+	Evaluate(result *evaluator.EvaluateModel, node jdomain.JClassNode)
+	EvaluateList(evaluateModel *evaluator.EvaluateModel, nodes []jdomain.JClassNode, nodeMap map[string]jdomain.JClassNode, identifiers []jdomain.JIdentifier)
 }
 
 type Evaluation struct {
 	Evaluator Evaluator
 }
 
-func (o *Evaluation) Evaluate(result *evaluator.EvaluateModel, node domain.JClassNode) {
+func (o *Evaluation) Evaluate(result *evaluator.EvaluateModel, node jdomain.JClassNode) {
 	o.Evaluator.Evaluate(result, node)
 }
 
-func (o *Evaluation) EvaluateList(evaluateModel *evaluator.EvaluateModel, nodes []domain.JClassNode, nodeMap map[string]domain.JClassNode, identifiers []domain.JIdentifier) {
+func (o *Evaluation) EvaluateList(evaluateModel *evaluator.EvaluateModel, nodes []jdomain.JClassNode, nodeMap map[string]jdomain.JClassNode, identifiers []jdomain.JIdentifier) {
 	o.Evaluator.EvaluateList(evaluateModel, nodes, nodeMap, identifiers)
 }

pkg/application/evaluate/evaluator/controller.go

@@ -2,13 +2,13 @@ package evaluator
 
 import (
 	"fmt"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 )
 
 type Controller struct {
 
 }
 
-func (Controller) Evaluate(node domain.JClassNode) {
+func (Controller) Evaluate(node jdomain.JClassNode) {
 	fmt.Println("controller")
 }

pkg/application/evaluate/evaluator/empty.go

 package evaluator
 
 import (
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 )
 
 type Empty struct {
 
 }
 
-func (Empty) Evaluate(*EvaluateModel, domain.JClassNode) {
+func (Empty) Evaluate(*EvaluateModel, jdomain.JClassNode) {
 
 }
 
-func (Empty) EvaluateList(*EvaluateModel, []domain.JClassNode, map[string]domain.JClassNode, []domain.JIdentifier) {
+func (Empty) EvaluateList(*EvaluateModel, []jdomain.JClassNode, map[string]jdomain.JClassNode, []jdomain.JIdentifier) {
 
 }
\ No newline at end of file

pkg/application/evaluate/evaluator/null_exception.go

 	package evaluator
 
 import (
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 )
 
 type NullPointException struct {
 }
 
-func (NullPointException) Evaluate(*EvaluateModel, domain.JClassNode) {
+func (NullPointException) Evaluate(*EvaluateModel, jdomain.JClassNode) {
 
 }
 
-func (n NullPointException) EvaluateList(evaluateModel *EvaluateModel, nodes []domain.JClassNode, nodeMap map[string]domain.JClassNode, identifiers []domain.JIdentifier) {
+func (n NullPointException) EvaluateList(evaluateModel *EvaluateModel, nodes []jdomain.JClassNode, nodeMap map[string]jdomain.JClassNode, identifiers []jdomain.JIdentifier) {
 	var nullableList []string = nil
 	var nullableMap = make(map[string]string)
 	for _, ident := range identifiers {
@@ -36,6 +36,6 @@ func (n NullPointException) EvaluateList(evaluateModel *EvaluateModel, nodes []d
 	evaluateModel.Nullable.Items = nullableList
 }
 
-func buildMethodPath(ident domain.JIdentifier, method domain.JMethod) string {
+func buildMethodPath(ident jdomain.JIdentifier, method jdomain.JMethod) string {
 	return ident.Package + "." + ident.ClassName + "." + method.Name
 }

pkg/application/evaluate/evaluator/service.go

 package evaluator
 
 import (
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/infrastructure/apriori"
 	"github.com/phodal/coca/pkg/infrastructure/constants"
 	"strings"
@@ -10,11 +10,11 @@ import (
 type Service struct {
 }
 
-var serviceNodeMap map[string]domain.JClassNode
+var serviceNodeMap map[string]jdomain.JClassNode
 var returnTypeMap map[string][]string
-var longParameterList []domain.JMethod
+var longParameterList []jdomain.JMethod
 
-func (s Service) EvaluateList(evaluateModel *EvaluateModel, nodes []domain.JClassNode, nodeMap map[string]domain.JClassNode, identifiers []domain.JIdentifier) {
+func (s Service) EvaluateList(evaluateModel *EvaluateModel, nodes []jdomain.JClassNode, nodeMap map[string]jdomain.JClassNode, identifiers []jdomain.JIdentifier) {
 	serviceNodeMap = nodeMap
 	longParameterList = nil
 	returnTypeMap = make(map[string][]string)
@@ -27,7 +27,7 @@ func (s Service) EvaluateList(evaluateModel *EvaluateModel, nodes []domain.JClas
 	findRelatedMethodParameter(evaluateModel, longParameterList)
 }
 
-func findRelatedMethodParameter(model *EvaluateModel, list []domain.JMethod) {
+func findRelatedMethodParameter(model *EvaluateModel, list []jdomain.JMethod) {
 	var dataset [][]string
 	for _, method := range list {
 		var methodlist []string
@@ -49,7 +49,7 @@ func findRelatedMethodParameter(model *EvaluateModel, list []domain.JMethod) {
 	}
 }
 
-func (s Service) Evaluate(result *EvaluateModel, node domain.JClassNode) {
+func (s Service) Evaluate(result *EvaluateModel, node jdomain.JClassNode) {
 	var methodNameArray [][]string
 	for _, method := range node.Methods {
 		methodNameArray = append(methodNameArray, SplitCamelcase(method.Name))

pkg/application/evaluate/evaluator/util.go

 package evaluator
 
 import (
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 )
 
 type Util struct {
 }
 
-func (Util) Evaluate(result *EvaluateModel, node domain.JClassNode) {
+func (Util) Evaluate(result *EvaluateModel, node jdomain.JClassNode) {
 
 }
 
-func (s Util) EvaluateList(evaluateModel *EvaluateModel, nodes []domain.JClassNode, nodeMap map[string]domain.JClassNode, identifiers []domain.JIdentifier) {
+func (s Util) EvaluateList(evaluateModel *EvaluateModel, nodes []jdomain.JClassNode, nodeMap map[string]jdomain.JClassNode, identifiers []jdomain.JIdentifier) {
 
 }

pkg/application/rcall/rcall_graph.go

@@ -2,7 +2,7 @@ package rcall
 
 import (
 	"github.com/phodal/coca/pkg/application/call"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 )
 
 type RCallGraph struct {
@@ -12,7 +12,7 @@ func NewRCallGraph() RCallGraph {
 	return RCallGraph{}
 }
 
-func (c RCallGraph) Analysis(funcName string, clzs []domain.JClassNode, writeCallback func(rcallMap map[string][]string)) string {
+func (c RCallGraph) Analysis(funcName string, clzs []jdomain.JClassNode, writeCallback func(rcallMap map[string][]string)) string {
 	var projectMethodMap = BuildProjectMethodMap(clzs)
 	rcallMap := BuildRCallMethodMap(clzs, projectMethodMap)
 
@@ -26,7 +26,7 @@ func (c RCallGraph) Analysis(funcName string, clzs []domain.JClassNode, writeCal
 	return dotContent
 }
 
-func BuildProjectMethodMap(clzs []domain.JClassNode) map[string]int {
+func BuildProjectMethodMap(clzs []jdomain.JClassNode) map[string]int {
 	var maps = make(map[string]int)
 	for _, clz := range clzs {
 		for _, method := range clz.Methods {
@@ -37,7 +37,7 @@ func BuildProjectMethodMap(clzs []domain.JClassNode) map[string]int {
 	return maps
 }
 
-func BuildRCallMethodMap(parserDeps []domain.JClassNode, projectMaps map[string]int) map[string][]string {
+func BuildRCallMethodMap(parserDeps []jdomain.JClassNode, projectMaps map[string]int) map[string][]string {
 	var methodMap = make(map[string][]string)
 	for _, clz := range parserDeps {
 		for _, method := range clz.Methods {

pkg/application/rcall/rcall_graph_test.go

@@ -3,7 +3,7 @@ package rcall
 import (
 	"encoding/json"
 	"github.com/phodal/coca/cmd/cmd_util"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"log"
 	"testing"
 
@@ -17,7 +17,7 @@ func MockWriteCallMap(rcallMap map[string][]string) {
 func TestRCallGraph_Analysis(t *testing.T) {
 	g := NewGomegaWithT(t)
 
-	var parsedDeps []domain.JClassNode
+	var parsedDeps []jdomain.JClassNode
 	analyser := NewRCallGraph()
 	file := cmd_util.ReadFile("../../../_fixtures/call/call_api_test.json")
 	if file == nil {
@@ -39,7 +39,7 @@ edge [dir="back"];
 func TestRCallGraph_Constructor(t *testing.T) {
 	g := NewGomegaWithT(t)
 
-	var parsedDeps []domain.JClassNode
+	var parsedDeps []jdomain.JClassNode
 	analyser := NewRCallGraph()
 	file := cmd_util.ReadFile("../../../_fixtures/rcall/constructor_call.json")
 	if file == nil {

pkg/application/refactor/rename/rename_method.go

@@ -2,7 +2,7 @@ package unused
 
 import (
 	"github.com/phodal/coca/pkg/application/refactor/rename/support"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"io/ioutil"
 	"log"
 	"strings"
@@ -13,9 +13,9 @@ var parsedChange []support.RefactorChangeRelate
 type RemoveMethodApp struct {
 }
 
-var parsedDeps []domain.JClassNode
+var parsedDeps []jdomain.JClassNode
 
-func RenameMethodApp(deps []domain.JClassNode) *RemoveMethodApp {
+func RenameMethodApp(deps []jdomain.JClassNode) *RemoveMethodApp {
 	parsedDeps = deps
 	return &RemoveMethodApp{}
 }
@@ -25,7 +25,7 @@ func (j *RemoveMethodApp) Refactoring(conf string) {
 	startParse(parsedDeps, parsedChange)
 }
 
-func startParse(nodes []domain.JClassNode, relates []support.RefactorChangeRelate) {
+func startParse(nodes []jdomain.JClassNode, relates []support.RefactorChangeRelate) {
 	for _, pkgNode := range nodes {
 		for _, related := range relates {
 			oldInfo := support.BuildMethodPackageInfo(related.OldObj)
@@ -52,11 +52,11 @@ func startParse(nodes []domain.JClassNode, relates []support.RefactorChangeRelat
 	}
 }
 
-func methodCallToMethodModel(call domain.JMethodCall) domain.JMethod {
-	return domain.JMethod{Name: call.MethodName, Type: call.Type, StartLine: call.StartLine, StartLinePosition: call.StartLinePosition, StopLine: call.StopLine, StopLinePosition: call.StopLinePosition}
+func methodCallToMethodModel(call jdomain.JMethodCall) jdomain.JMethod {
+	return jdomain.JMethod{Name: call.MethodName, Type: call.Type, StartLine: call.StartLine, StartLinePosition: call.StartLinePosition, StopLine: call.StopLine, StopLinePosition: call.StopLinePosition}
 }
 
-func updateSelfRefs(node domain.JClassNode, method domain.JMethod, info *support.PackageClassInfo) {
+func updateSelfRefs(node jdomain.JClassNode, method jdomain.JMethod, info *support.PackageClassInfo) {
 	path := node.FilePath
 	input, err := ioutil.ReadFile(path)
 	if err != nil {

pkg/application/refactor/unusedclasses/unused_classes_app.go

 package unusedclasses
 
 import (
-	. "github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"sort"
 	"strings"
 )
 
 var analysisPackage = ""
 
-func Refactoring(parsedDeps []JClassNode) []string {
+func Refactoring(parsedDeps []jdomain.JClassNode) []string {
 	sourceClasses := make(map[string]string)
 	targetClasses := make(map[string]string)
 

pkg/application/refactor/unusedclasses/unused_classes_app_test.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	. "github.com/onsi/gomega"
 	"github.com/phodal/coca/cmd/cmd_util"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"path/filepath"
 	"testing"
 )
@@ -13,7 +13,7 @@ func TestRefactoring(t *testing.T) {
 	g := NewGomegaWithT(t)
 
 
-	var parsedDeps []domain.JClassNode
+	var parsedDeps []jdomain.JClassNode
 	codePath := "../../../../_fixtures/count/call.json"
 	codePath = filepath.FromSlash(codePath)
 	file := cmd_util.ReadFile(codePath)

pkg/application/suggest/suggest_app.go

 package suggest
 
 import (
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/domain/support_domain"
 )
 
@@ -12,7 +12,7 @@ func NewSuggestApp() SuggestApp {
 	return SuggestApp{}
 }
 
-func (a SuggestApp) AnalysisPath(deps []domain.JClassNode) []api_domain.Suggest {
+func (a SuggestApp) AnalysisPath(deps []jdomain.JClassNode) []api_domain.Suggest {
 	var suggests []api_domain.Suggest
 	for _, clz := range deps {
 		if clz.Type == "Class" {
@@ -27,7 +27,7 @@ func (a SuggestApp) AnalysisPath(deps []domain.JClassNode) []api_domain.Suggest
 	return suggests
 }
 
-func factorySuggest(clz domain.JClassNode, suggests []api_domain.Suggest) []api_domain.Suggest {
+func factorySuggest(clz jdomain.JClassNode, suggests []api_domain.Suggest) []api_domain.Suggest {
 	var constructorCount = 0
 	var longestParaConstructorMethod = clz.Methods[0]
 

pkg/application/suggest/suggest_app_test.go

@@ -3,7 +3,7 @@ package suggest
 import (
 	"encoding/json"
 	"github.com/phodal/coca/cmd/cmd_util"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"log"
 	"path/filepath"
 	"testing"
@@ -14,7 +14,7 @@ import (
 func TestConceptAnalyser_Analysis(t *testing.T) {
 	g := NewGomegaWithT(t)
 
-	var parsedDeps []domain.JClassNode
+	var parsedDeps []jdomain.JClassNode
 	analyser := NewSuggestApp()
 	codePath := "../../../_fixtures/suggest/factory/factory_suggest.json"
 	codePath = filepath.FromSlash(codePath)

pkg/application/tbs/tbs_app.go

 package tbs
 
 import (
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/infrastructure/constants"
 )
 
@@ -19,9 +19,9 @@ type TestBadSmell struct {
 	Line        int
 }
 
-func (a TbsApp) AnalysisPath(deps []domain.JClassNode, identifiersMap map[string]domain.JIdentifier) []TestBadSmell {
+func (a TbsApp) AnalysisPath(deps []jdomain.JClassNode, identifiersMap map[string]jdomain.JIdentifier) []TestBadSmell {
 	var results []TestBadSmell = nil
-	callMethodMap := domain.BuildCallMethodMap(deps)
+	callMethodMap := jdomain.BuildCallMethodMap(deps)
 	for _, clz := range deps {
 		for _, method := range clz.Methods {
 			if !method.IsJunitTest() {
@@ -37,7 +37,7 @@ func (a TbsApp) AnalysisPath(deps []domain.JClassNode, identifiersMap map[string
 				checkEmptyTest(clz.FilePath, annotation, &results, method, &testType)
 			}
 
-			var methodCallMap = make(map[string][]domain.JMethodCall)
+			var methodCallMap = make(map[string][]jdomain.JMethodCall)
 			var hasAssert = false
 			for index, methodCall := range currentMethodCalls {
 				if methodCall.MethodName == "" {
@@ -69,7 +69,7 @@ func (a TbsApp) AnalysisPath(deps []domain.JClassNode, identifiersMap map[string
 	return results
 }
 
-func checkAssert(hasAssert bool, clz domain.JClassNode, method domain.JMethod, results *[]TestBadSmell, testType *string) {
+func checkAssert(hasAssert bool, clz jdomain.JClassNode, method jdomain.JMethod, results *[]TestBadSmell, testType *string) {
 	if !hasAssert {
 		*testType = "UnknownTest"
 		tbs := TestBadSmell{
@@ -84,7 +84,7 @@ func checkAssert(hasAssert bool, clz domain.JClassNode, method domain.JMethod, r
 	}
 }
 
-func updateMethodCallsForSelfCall(method domain.JMethod, clz domain.JClassNode, callMethodMap map[string]domain.JMethod) []domain.JMethodCall {
+func updateMethodCallsForSelfCall(method jdomain.JMethod, clz jdomain.JClassNode, callMethodMap map[string]jdomain.JMethod) []jdomain.JMethodCall {
 	currentMethodCalls := method.MethodCalls
 	for _, methodCall := range currentMethodCalls {
 		if methodCall.Class == clz.Class {
@@ -97,7 +97,7 @@ func updateMethodCallsForSelfCall(method domain.JMethod, clz domain.JClassNode,
 	return currentMethodCalls
 }
 
-func checkRedundantAssertionTest(path string, call domain.JMethodCall, method domain.JMethod, results *[]TestBadSmell, testType *string) {
+func checkRedundantAssertionTest(path string, call jdomain.JMethodCall, method jdomain.JMethod, results *[]TestBadSmell, testType *string) {
 	TWO_PARAMETERS := 2
 	if len(call.Parameters) == TWO_PARAMETERS {
 		if call.Parameters[0] == call.Parameters[1] {
@@ -114,7 +114,7 @@ func checkRedundantAssertionTest(path string, call domain.JMethodCall, method do
 	}
 }
 
-func checkDuplicateAssertTest(clz domain.JClassNode, results *[]TestBadSmell, methodCallMap map[string][]domain.JMethodCall, method domain.JMethod, testType *string) {
+func checkDuplicateAssertTest(clz jdomain.JClassNode, results *[]TestBadSmell, methodCallMap map[string][]jdomain.JMethodCall, method jdomain.JMethod, testType *string) {
 	var isDuplicateAssert = false
 	for _, methodCall := range methodCallMap {
 		if len(methodCall) >= constants.DuplicatedAssertionLimitLength {
@@ -137,7 +137,7 @@ func checkDuplicateAssertTest(clz domain.JClassNode, results *[]TestBadSmell, me
 	}
 }
 
-func checkSleepyTest(path string, method domain.JMethodCall, jMethod domain.JMethod, results *[]TestBadSmell, testType *string) {
+func checkSleepyTest(path string, method jdomain.JMethodCall, jMethod jdomain.JMethod, results *[]TestBadSmell, testType *string) {
 	if method.IsThreadSleep() {
 		*testType = "SleepyTest"
 		tbs := TestBadSmell{
@@ -151,7 +151,7 @@ func checkSleepyTest(path string, method domain.JMethodCall, jMethod domain.JMet
 	}
 }
 
-func checkRedundantPrintTest(path string, mCall domain.JMethodCall, results *[]TestBadSmell, testType *string) {
+func checkRedundantPrintTest(path string, mCall jdomain.JMethodCall, results *[]TestBadSmell, testType *string) {
 	if mCall.IsSystemOutput() {
 		*testType = "RedundantPrintTest"
 		tbs := TestBadSmell{
@@ -165,7 +165,7 @@ func checkRedundantPrintTest(path string, mCall domain.JMethodCall, results *[]T
 	}
 }
 
-func checkEmptyTest(path string, annotation domain.Annotation, results *[]TestBadSmell, method domain.JMethod, testType *string) {
+func checkEmptyTest(path string, annotation jdomain.Annotation, results *[]TestBadSmell, method jdomain.JMethod, testType *string) {
 	if annotation.IsTest() {
 		if len(method.MethodCalls) <= 1 {
 			*testType = "EmptyTest"
@@ -181,7 +181,7 @@ func checkEmptyTest(path string, annotation domain.Annotation, results *[]TestBa
 	}
 }
 
-func checkIgnoreTest(clzPath string, annotation domain.Annotation, results *[]TestBadSmell, testType *string) {
+func checkIgnoreTest(clzPath string, annotation jdomain.Annotation, results *[]TestBadSmell, testType *string) {
 	if annotation.IsIgnoreTest() {
 		*testType = "IgnoreTest"
 		tbs := TestBadSmell{

pkg/application/tbs/tbs_app_test.go

@@ -5,7 +5,7 @@ import (
 	"github.com/phodal/coca/cmd/cmd_util"
 	"github.com/phodal/coca/pkg/adapter/cocafile"
 	"github.com/phodal/coca/pkg/application/analysis"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"path/filepath"
 	"testing"
 )
@@ -139,11 +139,11 @@ func buildTbsResult(codePath string) []TestBadSmell {
 	return result
 }
 
-func BuildTestAnalysisResultsByPath(codePath string) (map[string]domain.JIdentifier, []domain.JClassNode) {
+func BuildTestAnalysisResultsByPath(codePath string) (map[string]jdomain.JIdentifier, []jdomain.JClassNode) {
 	files := cocafile.GetJavaTestFiles(codePath)
 
 	identifiers := cmd_util.LoadTestIdentify(files)
-	identifiersMap := domain.BuildIdentifierMap(identifiers)
+	identifiersMap := jdomain.BuildIdentifierMap(identifiers)
 
 	var classes []string = nil
 	for _, node := range identifiers {

pkg/domain/core_domain/code_member.go

 package core_domain
 
-import "github.com/phodal/coca/pkg/domain"
+import (
+	"github.com/phodal/coca/pkg/domain/jdomain"
+)
 
 type CodeMember struct {
 	ID            string
 	Name          string
 	Type          string
-	ClassNodes    []domain.JClassNode
+	ClassNodes    []jdomain.JClassNode
 	FunctionNodes []CodeFunction
 	Namespace     []string
 	FileID        string

pkg/domain/jannotation.go → pkg/domain/jdomain/jannotation.go

-package domain
+package jdomain
 
 type Annotation struct {
 	QualifiedName string

pkg/domain/jclass_node.go → pkg/domain/jdomain/jclass_node.go

-package domain
+package jdomain
 
 import "strings"
 

pkg/domain/jidentifier.go → pkg/domain/jdomain/jidentifier.go

-package domain
+package jdomain
 
 var methods []JMethod
 

pkg/domain/jimport.go → pkg/domain/jdomain/jimport.go

-package domain
+package jdomain
 
 type JImport struct {
 	Source string

pkg/domain/jmethod.go → pkg/domain/jdomain/jmethod.go

-package domain
+package jdomain
 
 import (
 	"github.com/phodal/coca/pkg/infrastructure/string_helper"

pkg/domain/jmethod_call.go → pkg/domain/jdomain/jmethod_call.go

-package domain
+package jdomain
 
 import (
 	"github.com/phodal/coca/pkg/infrastructure/constants"

pkg/domain/jparameter.go → pkg/domain/jdomain/jparameter.go

-package domain
+package jdomain
 
 type JParameter struct {
 	Name string

pkg/domain/support_domain/suggest.go

 package api_domain
 
 import (
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"strings"
 )
 
@@ -15,7 +15,7 @@ type Suggest struct {
 	Line    int
 }
 
-func NewSuggest(clz domain.JClassNode, pattern, reason string) Suggest {
+func NewSuggest(clz jdomain.JClassNode, pattern, reason string) Suggest {
 	return Suggest{
 		File:    clz.FilePath,
 		Package: clz.Package,
@@ -25,7 +25,7 @@ func NewSuggest(clz domain.JClassNode, pattern, reason string) Suggest {
 	}
 }
 
-func MergeSuggest(clz domain.JClassNode, currentSuggestList []Suggest) Suggest {
+func MergeSuggest(clz jdomain.JClassNode, currentSuggestList []Suggest) Suggest {
 	var suggest = NewSuggest(clz, "", "")
 	for _, s := range currentSuggestList {
 		if !strings.Contains(suggest.Pattern, s.Pattern) {

pkg/infrastructure/ast/api/java_api_listener.go

@@ -3,13 +3,13 @@ package api
 import (
 	"github.com/antlr/antlr4/runtime/Go/antlr"
 	"github.com/phodal/coca/languages/java"
-	models "github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/pkg/domain/support_domain"
 	"reflect"
 	"strings"
 )
 
-var jClassNodes []models.JClassNode
+var jClassNodes []jdomain.JClassNode
 
 var hasEnterClass = false
 var isSpringRestController = false
@@ -22,11 +22,11 @@ var restAPIs []api_domain.RestAPI
 var currentClz string
 var currentPkg string
 
-var identMap map[string]models.JIdentifier
+var identMap map[string]jdomain.JIdentifier
 var imports []string
 var currentImplements = ""
 
-func NewJavaAPIListener(jIdentMap map[string]models.JIdentifier, diMap map[string]string) *JavaAPIListener {
+func NewJavaAPIListener(jIdentMap map[string]jdomain.JIdentifier, diMap map[string]string) *JavaAPIListener {
 	isSpringRestController = false
 	currentClz = ""
 	currentPkg = ""
@@ -300,7 +300,7 @@ func buildMethodParameters(requestBodyClass string) {
 	currentRestAPI.MethodParams = params
 }
 
-func (s *JavaAPIListener) AppendClasses(classes []models.JClassNode) {
+func (s *JavaAPIListener) AppendClasses(classes []jdomain.JClassNode) {
 	jClassNodes = classes
 }
 

pkg/infrastructure/ast/common_listener/common_listener.go

 package common_listener
 
 import (
-	"github.com/phodal/coca/pkg/domain"
 	"github.com/phodal/coca/languages/java"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"reflect"
 )
 
-func BuildAnnotation(ctx *parser.AnnotationContext) domain.Annotation {
+func BuildAnnotation(ctx *parser.AnnotationContext) jdomain.Annotation {
 	annotationName := ctx.QualifiedName().GetText()
-	annotation := domain.NewAnnotation()
+	annotation := jdomain.NewAnnotation()
 	annotation.QualifiedName = annotationName
 	if ctx.ElementValuePairs() != nil {
 		pairs := ctx.ElementValuePairs().(*parser.ElementValuePairsContext).AllElementValuePair()
 		for _, pair := range pairs {
 			pairCtx := pair.(*parser.ElementValuePairContext)
 			pairCtx.ElementValue()
-			annotation.ValuePairs = append(annotation.ValuePairs, domain.AnnotationKeyValue{
+			annotation.ValuePairs = append(annotation.ValuePairs, jdomain.AnnotationKeyValue{
 				Key:   pairCtx.IDENTIFIER().GetText(),
 				Value: pairCtx.ElementValue().GetText(),
 			})
 		}
 	} else if ctx.ElementValue() != nil {
 		value := ctx.ElementValue().GetText()
-		annotation.ValuePairs = append(annotation.ValuePairs, domain.AnnotationKeyValue{
+		annotation.ValuePairs = append(annotation.ValuePairs, jdomain.AnnotationKeyValue{
 			Key:   value,
 			Value: value,
 		})
@@ -31,7 +31,7 @@ func BuildAnnotation(ctx *parser.AnnotationContext) domain.Annotation {
 	return annotation
 }
 
-func BuildAnnotationForMethod(context *parser.ModifierContext, method *domain.JMethod) {
+func BuildAnnotationForMethod(context *parser.ModifierContext, method *jdomain.JMethod) {
 	if context.ClassOrInterfaceModifier() != nil {
 		if reflect.TypeOf(context.ClassOrInterfaceModifier().GetChild(0)).String() == "*parser.AnnotationContext" {
 			annotationCtx := context.ClassOrInterfaceModifier().GetChild(0).(*parser.AnnotationContext)

pkg/infrastructure/ast/full/java_full_converter.go

@@ -2,12 +2,12 @@ package full
 
 import (
 	"github.com/phodal/coca/languages/java"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"strings"
 )
 
-func BuildMethodParameters(parameters parser.IFormalParametersContext) []domain.JParameter {
-	var methodParams []domain.JParameter = nil
+func BuildMethodParameters(parameters parser.IFormalParametersContext) []jdomain.JParameter {
+	var methodParams []jdomain.JParameter = nil
 	parameterList := parameters.GetChild(1).(*parser.FormalParameterListContext)
 	formalParameter := parameterList.AllFormalParameter()
 	for _, param := range formalParameter {
@@ -16,12 +16,12 @@ func BuildMethodParameters(parameters parser.IFormalParametersContext) []domain.
 		paramValue := paramContext.VariableDeclaratorId().(*parser.VariableDeclaratorIdContext).IDENTIFIER().GetText()
 
 		localVars[paramValue] = paramType
-		methodParams = append(methodParams, domain.JParameter{Name: paramValue, Type: paramType})
+		methodParams = append(methodParams, jdomain.JParameter{Name: paramValue, Type: paramType})
 	}
 	return methodParams
 }
 
-func BuildMethodCallMethods(jMethodCall *domain.JMethodCall, callee string, targetType string, ctx *parser.MethodCallContext) {
+func BuildMethodCallMethods(jMethodCall *jdomain.JMethodCall, callee string, targetType string, ctx *parser.MethodCallContext) {
 	methodName := callee
 	packageName := currentPkg
 
@@ -51,14 +51,14 @@ func BuildMethodCallMethods(jMethodCall *domain.JMethodCall, callee string, targ
 	jMethodCall.Class = targetType
 }
 
-func BuildMethodCallLocation(jMethodCall *domain.JMethodCall, ctx *parser.MethodCallContext, callee string) {
+func BuildMethodCallLocation(jMethodCall *jdomain.JMethodCall, ctx *parser.MethodCallContext, callee string) {
 	jMethodCall.StartLine = ctx.GetStart().GetLine()
 	jMethodCall.StartLinePosition = ctx.GetStart().GetColumn()
 	jMethodCall.StopLine = ctx.GetStop().GetLine()
 	jMethodCall.StopLinePosition = jMethodCall.StartLinePosition + len(callee)
 }
 
-func BuildMethodCallParameters(jMethodCall *domain.JMethodCall, ctx *parser.MethodCallContext) {
+func BuildMethodCallParameters(jMethodCall *jdomain.JMethodCall, ctx *parser.MethodCallContext) {
 	if ctx.ExpressionList() != nil {
 		var parameters []string
 		for _, expression := range ctx.ExpressionList().(*parser.ExpressionListContext).AllExpression() {

pkg/infrastructure/ast/full/java_full_listener.go

@@ -3,7 +3,7 @@ package full
 import (
 	"github.com/antlr/antlr4/runtime/Go/antlr"
 	"github.com/phodal/coca/languages/java"
-	"github.com/phodal/coca/pkg/domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	common_listener2 "github.com/phodal/coca/pkg/infrastructure/ast/common_listener"
 	"reflect"
 	"strconv"
@@ -14,40 +14,40 @@ var imports []string
 var clzs []string
 var currentPkg string
 var currentClz string
-var fields []domain.JField
-var methodCalls []domain.JMethodCall
+var fields []jdomain.JField
+var methodCalls []jdomain.JMethodCall
 var currentType string
 
 var mapFields = make(map[string]string)
 var localVars = make(map[string]string)
 var formalParameters = make(map[string]string)
 var currentClzExtend = ""
-var currentMethod domain.JMethod
-var methodMap = make(map[string]domain.JMethod)
-var creatorMethodMap = make(map[string]domain.JMethod)
+var currentMethod jdomain.JMethod
+var methodMap = make(map[string]jdomain.JMethod)
+var creatorMethodMap = make(map[string]jdomain.JMethod)
 
-var methodQueue []domain.JMethod
+var methodQueue []jdomain.JMethod
 var classStringQueue []string
 
-var identMap map[string]domain.JIdentifier
+var identMap map[string]jdomain.JIdentifier
 var isOverrideMethod = false
 
-var classNodeQueue []domain.JClassNode
+var classNodeQueue []jdomain.JClassNode
 
-var currentNode *domain.JClassNode
-var classNodes []domain.JClassNode
-var creatorNodes []domain.JClassNode
-var currentCreatorNode domain.JClassNode
+var currentNode *jdomain.JClassNode
+var classNodes []jdomain.JClassNode
+var creatorNodes []jdomain.JClassNode
+var currentCreatorNode jdomain.JClassNode
 var fileName = ""
 var hasEnterClass = false
 
-func NewJavaFullListener(nodes map[string]domain.JIdentifier, file string) *JavaFullListener {
+func NewJavaFullListener(nodes map[string]jdomain.JIdentifier, file string) *JavaFullListener {
 	identMap = nodes
 	imports = nil
 	fileName = file
 	currentPkg = ""
 	classNodes = nil
-	currentNode = domain.NewClassNode()
+	currentNode = jdomain.NewClassNode()
 	classStringQueue = nil
 	classNodeQueue = nil
 	methodQueue = nil
@@ -59,10 +59,10 @@ func NewJavaFullListener(nodes map[string]domain.JIdentifier, file string) *Java
 func initClass() {
 	currentClz = ""
 	currentClzExtend = ""
-	currentMethod = domain.NewJMethod()
+	currentMethod = jdomain.NewJMethod()
 	currentNode.MethodCalls = nil
 
-	methodMap = make(map[string]domain.JMethod)
+	methodMap = make(map[string]jdomain.JMethod)
 	methodCalls = nil
 	fields = nil
 	isOverrideMethod = false
@@ -72,7 +72,7 @@ type JavaFullListener struct {
 	parser.BaseJavaParserListener
 }
 
-func (s *JavaFullListener) GetNodeInfo() []domain.JClassNode {
+func (s *JavaFullListener) GetNodeInfo() []jdomain.JClassNode {
 	return classNodes
 }
 
@@ -99,7 +99,7 @@ func (s *JavaFullListener) exitBody() {
 	}
 
 	if currentNode.Class == "" {
-		currentNode = domain.NewClassNode()
+		currentNode = jdomain.NewClassNode()
 		initClass()
 		return
 	}
@@ -118,7 +118,7 @@ func (s *JavaFullListener) exitBody() {
 			currentNode = &classNodeQueue[len(classNodeQueue)-1]
 		}
 	} else {
-		currentNode = domain.NewClassNode()
+		currentNode = jdomain.NewClassNode()
 	}
 
 	initClass()
@@ -132,7 +132,7 @@ func (s *JavaFullListener) EnterPackageDeclaration(ctx *parser.PackageDeclaratio
 func (s *JavaFullListener) EnterImportDeclaration(ctx *parser.ImportDeclarationContext) {
 	importText := ctx.QualifiedName().GetText()
 	imports = append(imports, importText)
-	currentNode.Imports = append(currentNode.Imports, domain.NewJImport(importText))
+	currentNode.Imports = append(currentNode.Imports, jdomain.NewJImport(importText))
 }
 
 func (s *JavaFullListener) EnterClassDeclaration(ctx *parser.ClassDeclarationContext) {
@@ -207,7 +207,7 @@ func (s *JavaFullListener) EnterInterfaceMethodDeclaration(ctx *parser.Interface
 		common_listener2.BuildAnnotationForMethod(ctx.GetParent().GetParent().GetChild(0).(*parser.ModifierContext), &currentMethod)
 	}
 
-	method := &domain.JMethod{Name: name, Type: typeType, StartLine: startLine, StartLinePosition: startLinePosition, StopLine: stopLine, StopLinePosition: stopLinePosition}
+	method := &jdomain.JMethod{Name: name, Type: typeType, StartLine: startLine, StartLinePosition: startLinePosition, StopLine: stopLine, StopLinePosition: stopLinePosition}
 	updateMethod(method)
 }
 
@@ -237,7 +237,7 @@ func (s *JavaFullListener) EnterFieldDeclaration(ctx *parser.FieldDeclarationCon
 		typeTypeText := typeCtx.IDENTIFIER(0).GetText()
 		value := declarator.(*parser.VariableDeclaratorContext).VariableDeclaratorId().(*parser.VariableDeclaratorIdContext).IDENTIFIER().GetText()
 		mapFields[value] = typeTypeText
-		fields = append(fields, domain.JField{Type: typeTypeText, Value: value})
+		fields = append(fields, jdomain.JField{Type: typeTypeText, Value: value})
 
 		buildFieldCall(typeTypeText, ctx)
 	}
@@ -281,7 +281,7 @@ func (s *JavaFullListener) EnterAnnotation(ctx *parser.AnnotationContext) {
 }
 
 func (s *JavaFullListener) EnterConstructorDeclaration(ctx *parser.ConstructorDeclarationContext) {
-	method := &domain.JMethod{
+	method := &jdomain.JMethod{
 		Name:              ctx.IDENTIFIER().GetText(),
 		Type:              "",
 		StartLine:         ctx.GetStart().GetLine(),
@@ -303,7 +303,7 @@ func (s *JavaFullListener) EnterConstructorDeclaration(ctx *parser.ConstructorDe
 }
 
 func (s *JavaFullListener) ExitConstructorDeclaration(ctx *parser.ConstructorDeclarationContext) {
-	currentMethod = domain.NewJMethod()
+	currentMethod = jdomain.NewJMethod()
 	isOverrideMethod = false
 }
 
@@ -320,7 +320,7 @@ func (s *JavaFullListener) EnterMethodDeclaration(ctx *parser.MethodDeclarationC
 		common_listener2.BuildAnnotationForMethod(ctx.GetParent().GetParent().GetChild(0).(*parser.ModifierContext), &currentMethod)
 	}
 
-	method := &domain.JMethod{
+	method := &jdomain.JMethod{
 		Name:              name,
 		Type:              typeType,
 		StartLine:         startLine,
@@ -341,7 +341,7 @@ func (s *JavaFullListener) EnterMethodDeclaration(ctx *parser.MethodDeclarationC
 	updateMethod(method)
 }
 
-func buildMethodParameters(parameters parser.IFormalParametersContext, method *domain.JMethod) bool {
+func buildMethodParameters(parameters parser.IFormalParametersContext, method *jdomain.JMethod) bool {
 	if parameters != nil {
 		if parameters.GetChild(0) == nil || parameters.GetText() == "()" || parameters.GetChild(1) == nil {
 			updateMethod(method)
@@ -354,7 +354,7 @@ func buildMethodParameters(parameters parser.IFormalParametersContext, method *d
 	return false
 }
 
-func updateMethod(method *domain.JMethod) {
+func updateMethod(method *jdomain.JMethod) {
 	if currentType == "CreatorClass" {
 		creatorMethodMap[getMethodMapName(*method)] = *method
 	} else {
@@ -373,7 +373,7 @@ func exitMethod() {
 		return
 	}
 
-	currentMethod = domain.NewJMethod()
+	currentMethod = jdomain.NewJMethod()
 }
 
 // TODO: add inner creator examples
@@ -394,7 +394,7 @@ func (s *JavaFullListener) ExitInnerCreator(ctx *parser.InnerCreatorContext) {
 	currentClz = classStringQueue[len(classStringQueue)-1]
 }
 
-func getMethodMapName(method domain.JMethod) string {
+func getMethodMapName(method jdomain.JMethod) string {
 	name := method.Name
 	if name == "" && len(methodQueue) > 1 {
 		name = methodQueue[len(methodQueue)-1].Name
@@ -428,7 +428,7 @@ func (s *JavaFullListener) EnterCreator(ctx *parser.CreatorContext) {
 
 		currentType = "CreatorClass"
 		text := ctx.CreatedName().GetText()
-		creatorNode := &domain.JClassNode{
+		creatorNode := &jdomain.JClassNode{
 			Package:     currentPkg,
 			Class:       text,
 			Type:        "CreatorClass",
@@ -456,7 +456,7 @@ func (s *JavaFullListener) ExitCreator(ctx *parser.CreatorContext) {
 	if currentType == "CreatorClass" {
 		currentType = ""
 	}
-	currentCreatorNode = *domain.NewClassNode()
+	currentCreatorNode = *jdomain.NewClassNode()
 
 	if classNodeQueue == nil || len(classNodeQueue) < 1 {
 		return
@@ -467,7 +467,7 @@ func buildCreatedCall(createdName string, ctx *parser.CreatorContext) {
 	method := methodMap[getMethodMapName(currentMethod)]
 	fullType, _ := WarpTargetFullType(createdName)
 
-	jMethodCall := &domain.JMethodCall{
+	jMethodCall := &jdomain.JMethodCall{
 		Package:           RemoveTarget(fullType),
 		Type:              "CreatorClass",
 		Class:             createdName,
@@ -483,7 +483,7 @@ func buildCreatedCall(createdName string, ctx *parser.CreatorContext) {
 }
 
 func (s *JavaFullListener) EnterMethodCall(ctx *parser.MethodCallContext) {
-	var jMethodCall = domain.NewJMethodCall()
+	var jMethodCall = jdomain.NewJMethodCall()
 
 	targetCtx := ctx.GetParent().GetChild(0).(antlr.ParseTree)
 	var targetType = ParseTargetType(targetCtx.GetText())
@@ -504,7 +504,7 @@ func (s *JavaFullListener) EnterMethodCall(ctx *parser.MethodCallContext) {
 	sendResultToMethodCallMap(jMethodCall)
 }
 
-func sendResultToMethodCallMap(jMethodCall domain.JMethodCall) {
+func sendResultToMethodCallMap(jMethodCall jdomain.JMethodCall) {
 	methodCalls = append(methodCalls, jMethodCall)
 
 	method := methodMap[getMethodMapName(currentMethod)]
@@ -547,7 +547,7 @@ func (s *JavaFullListener) EnterExpression(ctx *parser.ExpressionContext) {
 		stopLine := ctx.GetStop().GetLine()
 		stopLinePosition := startLinePosition + len(text)
 
-		jMethodCall := &domain.JMethodCall{
+		jMethodCall := &jdomain.JMethodCall{
 			Package:           RemoveTarget(fullType),
 			Type:              "lambda",
 			Class:             targetType,
@@ -576,7 +576,7 @@ func buildExtend(extendName string) {
 func buildFieldCall(typeType string, ctx *parser.FieldDeclarationContext) {
 	target, _ := WarpTargetFullType(typeType)
 	if target != "" {
-		jMethodCall := &domain.JMethodCall{
+		jMethodCall := &jdomain.JMethodCall{
 			Package:           RemoveTarget(target),
 			Type:              "field",
 			Class:             typeType,

pkg/infrastructure/ast/identifier/java_identifier_listener.go

@@ -2,24 +2,24 @@ package identifier
 
 import (
 	"github.com/antlr/antlr4/runtime/Go/antlr"
-	"github.com/phodal/coca/pkg/domain"
-	common_listener2 "github.com/phodal/coca/pkg/infrastructure/ast/common_listener"
 	"github.com/phodal/coca/languages/java"
+	"github.com/phodal/coca/pkg/domain/jdomain"
+	common_listener2 "github.com/phodal/coca/pkg/infrastructure/ast/common_listener"
 	"reflect"
 	"strings"
 )
 
-var currentNode *domain.JIdentifier
-var nodes []domain.JIdentifier
+var currentNode *jdomain.JIdentifier
+var nodes []jdomain.JIdentifier
 
-var currentMethod domain.JMethod
+var currentMethod jdomain.JMethod
 var hasEnterClass = false
 var imports []string
 
 func NewJavaIdentifierListener() *JavaIdentifierListener {
 	nodes = nil
-	currentNode = domain.NewJIdentifier()
-	currentMethod = domain.NewJMethod()
+	currentNode = jdomain.NewJIdentifier()
+	currentMethod = jdomain.NewJMethod()
 	return &JavaIdentifierListener{}
 }
 
@@ -60,7 +60,7 @@ func (s *JavaIdentifierListener) EnterClassDeclaration(ctx *parser.ClassDeclarat
 		}
 	}
 
-	currentMethod = domain.NewJMethod()
+	currentMethod = jdomain.NewJMethod()
 }
 
 func (s *JavaIdentifierListener) ExitClassBody(ctx *parser.ClassBodyContext) {
@@ -69,7 +69,7 @@ func (s *JavaIdentifierListener) ExitClassBody(ctx *parser.ClassBodyContext) {
 		currentNode.Methods = currentNode.GetMethods()
 		nodes = append(nodes, *currentNode)
 	}
-	currentNode = domain.NewJIdentifier()
+	currentNode = jdomain.NewJIdentifier()
 }
 
 func (s *JavaIdentifierListener) ExitInterfaceDeclaration(ctx *parser.InterfaceDeclarationContext) {
@@ -78,11 +78,11 @@ func (s *JavaIdentifierListener) ExitInterfaceDeclaration(ctx *parser.InterfaceD
 		currentNode.Methods = currentNode.GetMethods()
 		nodes = append(nodes, *currentNode)
 	}
-	currentNode = domain.NewJIdentifier()
+	currentNode = jdomain.NewJIdentifier()
 }
 
 func (s *JavaIdentifierListener) EnterConstructorDeclaration(ctx *parser.ConstructorDeclarationContext) {
-	currentMethod = domain.JMethod{
+	currentMethod = jdomain.JMethod{
 		Name:              ctx.IDENTIFIER().GetText(),
 		Type:              "",
 		StartLine:         ctx.GetStart().GetLine(),
@@ -116,7 +116,7 @@ func (s *JavaIdentifierListener) EnterInterfaceMethodDeclaration(ctx *parser.Int
 		common_listener2.BuildAnnotationForMethod(ctx.GetParent().GetParent().GetChild(0).(*parser.ModifierContext), &currentMethod)
 	}
 
-	currentMethod = domain.JMethod{
+	currentMethod = jdomain.JMethod{
 		Name:              name,
 		Type:              typeType,
 		StartLine:         startLine,
@@ -130,7 +130,7 @@ func (s *JavaIdentifierListener) EnterInterfaceMethodDeclaration(ctx *parser.Int
 
 func (s *JavaIdentifierListener) ExitInterfaceMethodDeclaration(ctx *parser.InterfaceMethodDeclarationContext) {
 	currentNode.AddMethod(currentMethod)
-	currentMethod = domain.NewJMethod()
+	currentMethod = jdomain.NewJMethod()
 }
 
 var isOverrideMethod = false
@@ -150,7 +150,7 @@ func (s *JavaIdentifierListener) EnterMethodDeclaration(ctx *parser.MethodDeclar
 		common_listener2.BuildAnnotationForMethod(ctx.GetParent().GetParent().GetChild(0).(*parser.ModifierContext), &currentMethod)
 	}
 
-	currentMethod = domain.JMethod{
+	currentMethod = jdomain.JMethod{
 		Name:              name,
 		Type:              typeType,
 		StartLine:         startLine,
@@ -175,7 +175,7 @@ func (s *JavaIdentifierListener) EnterMethodDeclaration(ctx *parser.MethodDeclar
 
 func (s *JavaIdentifierListener) ExitMethodDeclaration(ctx *parser.MethodDeclarationContext) {
 	currentNode.AddMethod(currentMethod)
-	currentMethod = domain.NewJMethod()
+	currentMethod = jdomain.NewJMethod()
 }
 
 func (s *JavaIdentifierListener) EnterAnnotation(ctx *parser.AnnotationContext) {
@@ -206,6 +206,6 @@ func (s *JavaIdentifierListener) EnterExpression(ctx *parser.ExpressionContext)
 	}
 }
 
-func (s *JavaIdentifierListener) GetNodes() []domain.JIdentifier {
+func (s *JavaIdentifierListener) GetNodes() []jdomain.JIdentifier {
 	return nodes
 }

trial/pkg/ast/ast_util/position.go

@@ -2,11 +2,11 @@ package ast_util
 
 import (
 	"github.com/antlr/antlr4/runtime/Go/antlr"
-	"github.com/phodal/coca/pkg/domain"
 	"github.com/phodal/coca/pkg/domain/core_domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 )
 
-func AddPosition(m *domain.JMethod, ctx *antlr.BaseParserRuleContext) {
+func AddPosition(m *jdomain.JMethod, ctx *antlr.BaseParserRuleContext) {
 	m.StartLine = ctx.GetStart().GetLine()
 	m.StartLinePosition = ctx.GetStart().GetColumn()
 	m.StopLine = ctx.GetStop().GetLine()

trial/pkg/ast/ts/typescript_ident_listener.go

@@ -3,8 +3,8 @@ package ts
 import (
 	"github.com/antlr/antlr4/runtime/Go/antlr"
 	parser "github.com/phodal/coca/languages/ts"
-	"github.com/phodal/coca/pkg/domain"
 	"github.com/phodal/coca/pkg/domain/core_domain"
+	"github.com/phodal/coca/pkg/domain/jdomain"
 	"github.com/phodal/coca/trial/pkg/ast/ast_util"
 	"strings"
 )
@@ -101,7 +101,7 @@ func BuildInterfaceTypeBody(ctx *parser.TypeMemberListContext, dataStruct *core_
 		case *parser.PropertySignatureContext:
 			BuildInterfacePropertySignature(x, dataStruct)
 		case *parser.MethodSignatureContext:
-			method := domain.NewJMethod()
+			method := jdomain.NewJMethod()
 			method.Name = x.PropertyName().GetText()
 
 			function := core_domain.CodeFunction{