refactor: merge jclass nodes

cmd/cmd_util/ident_helper.go

@@ -6,16 +6,16 @@ import (
 	"github.com/phodal/coca/pkg/domain/core_domain"
 )
 
-func LoadIdentify(importPath string) []core_domain.JIdentifier {
+func LoadIdentify(importPath string) []core_domain.CodeDataStruct {
 	return readIdentify(importPath, "identify.json", analysisByPath)
 }
 
-func LoadTestIdentify(files []string) []core_domain.JIdentifier {
+func LoadTestIdentify(files []string) []core_domain.CodeDataStruct {
 	return readIdentify(files, "tidentify.json", analysisByFiles)
 }
 
-func readIdentify(importPath interface{}, fileName string, analysisApp func(importPath interface{}) []core_domain.JIdentifier) []core_domain.JIdentifier {
-	var identifiers []core_domain.JIdentifier
+func readIdentify(importPath interface{}, fileName string, analysisApp func(importPath interface{}) []core_domain.CodeDataStruct) []core_domain.CodeDataStruct {
+	var identifiers []core_domain.CodeDataStruct
 
 	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{}) []core_domain.JIdentifier {
+func analysisByPath(importPath interface{}) []core_domain.CodeDataStruct {
 	identifierApp := new(analysis.JavaIdentifierApp)
 	ident := identifierApp.AnalysisPath(importPath.(string))
 	return ident
 }
 
-func analysisByFiles(files interface{}) []core_domain.JIdentifier {
+func analysisByFiles(files interface{}) []core_domain.CodeDataStruct {
 	identifierApp := analysis.NewJavaIdentifierApp()
 	ident := identifierApp.AnalysisFiles(files.([]string))
 	return ident

cmd/evaluate.go

@@ -34,7 +34,7 @@ var evaluateCmd = &cobra.Command{
 			log.Fatal("lost file:" + dependence)
 		}
 
-		var identifiers []core_domain.JIdentifier
+		var identifiers []core_domain.CodeDataStruct
 		identContent := cmd_util.ReadCocaFile("identify.json")
 
 		_ = json.Unmarshal(identContent, &identifiers)

cocatest/testhelper/generate.go

@@ -6,7 +6,7 @@ import (
 	"path/filepath"
 )
 
-func BuildAnalysisDeps(codePath string) ([]core_domain.CodeDataStruct, map[string]core_domain.JIdentifier, []core_domain.JIdentifier) {
+func BuildAnalysisDeps(codePath string) ([]core_domain.CodeDataStruct, map[string]core_domain.CodeDataStruct, []core_domain.CodeDataStruct) {
 	codePath = filepath.FromSlash(codePath)
 
 	identifierApp := analysis.NewJavaIdentifierApp()

pkg/application/analysis/java_full_app.go

@@ -17,15 +17,15 @@ func NewJavaFullApp() JavaFullApp {
 	return JavaFullApp{}
 }
 
-func (j *JavaFullApp) AnalysisPath(codeDir string, classes []string, identNodes []core_domain.JIdentifier) []core_domain.CodeDataStruct {
+func (j *JavaFullApp) AnalysisPath(codeDir string, classes []string, identNodes []core_domain.CodeDataStruct) []core_domain.CodeDataStruct {
 	files := cocafile.GetJavaFiles(codeDir)
 	return j.AnalysisFiles(identNodes, files, classes)
 }
 
-func (j *JavaFullApp) AnalysisFiles(identNodes []core_domain.JIdentifier, files []string, classes []string) []core_domain.CodeDataStruct {
+func (j *JavaFullApp) AnalysisFiles(identNodes []core_domain.CodeDataStruct, files []string, classes []string) []core_domain.CodeDataStruct {
 	var nodeInfos []core_domain.CodeDataStruct
 
-	var identMap = make(map[string]core_domain.JIdentifier)
+	var identMap = make(map[string]core_domain.CodeDataStruct)
 	for _, ident := range identNodes {
 		identMap[ident.GetClassFullName()] = ident
 	}

pkg/application/analysis/java_identifier_app.go

@@ -16,13 +16,13 @@ func NewJavaIdentifierApp() JavaIdentifierApp {
 	return JavaIdentifierApp{}
 }
 
-func (j *JavaIdentifierApp) AnalysisPath(codeDir string) []core_domain.JIdentifier {
+func (j *JavaIdentifierApp) AnalysisPath(codeDir string) []core_domain.CodeDataStruct {
 	files := cocafile.GetJavaFiles(codeDir)
 	return j.AnalysisFiles(files)
 }
 
-func (j *JavaIdentifierApp) AnalysisFiles(files []string) []core_domain.JIdentifier {
-	var nodeInfos []core_domain.JIdentifier = nil
+func (j *JavaIdentifierApp) AnalysisFiles(files []string) []core_domain.CodeDataStruct {
+	var nodeInfos []core_domain.CodeDataStruct = nil
 
 	for _, file := range files {
 		parser := ast.ProcessJavaFile(file)

pkg/application/api/java_api_app.go

@@ -16,7 +16,7 @@ var allApis []api_domain.RestAPI
 type JavaApiApp struct {
 }
 
-func (j *JavaApiApp) AnalysisPath(codeDir string, parsedDeps []core_domain.CodeDataStruct, identifiersMap map[string]core_domain.JIdentifier, diMap map[string]string) []api_domain.RestAPI {
+func (j *JavaApiApp) AnalysisPath(codeDir string, parsedDeps []core_domain.CodeDataStruct, identifiersMap map[string]core_domain.CodeDataStruct, diMap map[string]string) []api_domain.RestAPI {
 	files := cocafile.GetJavaFiles(codeDir)
 	allApis = nil
 	for index := range files {

pkg/application/arch/arch_app.go

@@ -12,7 +12,7 @@ func NewArchApp() ArchApp {
 	return ArchApp{}
 }
 
-func (a ArchApp) Analysis(deps []core_domain.CodeDataStruct, identifiersMap map[string]core_domain.JIdentifier) *tequila.FullGraph {
+func (a ArchApp) Analysis(deps []core_domain.CodeDataStruct, identifiersMap map[string]core_domain.CodeDataStruct) *tequila.FullGraph {
 	fullGraph := &tequila.FullGraph{
 		NodeList:     make(map[string]string),
 		RelationList: make(map[string]*tequila.Relation),
@@ -57,7 +57,7 @@ func addCallInField(clz core_domain.CodeDataStruct, src string, fullGraph tequil
 	}
 }
 
-func addCallInMethod(clz core_domain.CodeDataStruct, identifiersMap map[string]core_domain.JIdentifier, src string, fullGraph tequila.FullGraph) {
+func addCallInMethod(clz core_domain.CodeDataStruct, identifiersMap map[string]core_domain.CodeDataStruct, src string, fullGraph tequila.FullGraph) {
 	for _, method := range clz.Functions {
 		if method.Name == "main" {
 			continue

pkg/application/evaluate/analyser.go

@@ -13,7 +13,7 @@ func NewEvaluateAnalyser() Analyser {
 	return Analyser{}
 }
 
-func (a Analyser) Analysis(classNodes []core_domain.CodeDataStruct, identifiers []core_domain.JIdentifier) evaluator.EvaluateModel {
+func (a Analyser) Analysis(classNodes []core_domain.CodeDataStruct, identifiers []core_domain.CodeDataStruct) evaluator.EvaluateModel {
 	var servicesNode []core_domain.CodeDataStruct = nil
 	var evaluation Evaluation
 	var result = evaluator.NewEvaluateModel()
@@ -48,7 +48,7 @@ func (a Analyser) Analysis(classNodes []core_domain.CodeDataStruct, identifiers
 	return result
 }
 
-func SummaryMethodIdentifier(identifiers []core_domain.JIdentifier, result *evaluator.EvaluateModel) {
+func SummaryMethodIdentifier(identifiers []core_domain.CodeDataStruct, result *evaluator.EvaluateModel) {
 	var methodLengthArray []float64
 	var methodCountArray []float64
 	for _, ident := range identifiers {

pkg/application/evaluate/evaluate.go

@@ -7,7 +7,7 @@ import (
 
 type Evaluator interface {
 	Evaluate(result *evaluator.EvaluateModel, node core_domain.CodeDataStruct)
-	EvaluateList(evaluateModel *evaluator.EvaluateModel, nodes []core_domain.CodeDataStruct, nodeMap map[string]core_domain.CodeDataStruct, identifiers []core_domain.JIdentifier)
+	EvaluateList(evaluateModel *evaluator.EvaluateModel, nodes []core_domain.CodeDataStruct, nodeMap map[string]core_domain.CodeDataStruct, identifiers []core_domain.CodeDataStruct)
 }
 
 type Evaluation struct {
@@ -18,6 +18,6 @@ func (o *Evaluation) Evaluate(result *evaluator.EvaluateModel, node core_domain.
 	o.Evaluator.Evaluate(result, node)
 }
 
-func (o *Evaluation) EvaluateList(evaluateModel *evaluator.EvaluateModel, nodes []core_domain.CodeDataStruct, nodeMap map[string]core_domain.CodeDataStruct, identifiers []core_domain.JIdentifier) {
+func (o *Evaluation) EvaluateList(evaluateModel *evaluator.EvaluateModel, nodes []core_domain.CodeDataStruct, nodeMap map[string]core_domain.CodeDataStruct, identifiers []core_domain.CodeDataStruct) {
 	o.Evaluator.EvaluateList(evaluateModel, nodes, nodeMap, identifiers)
 }

pkg/application/evaluate/evaluator/empty.go

@@ -12,6 +12,6 @@ func (Empty) Evaluate(*EvaluateModel, core_domain.CodeDataStruct) {
 
 }
 
-func (Empty) EvaluateList(*EvaluateModel, []core_domain.CodeDataStruct, map[string]core_domain.CodeDataStruct, []core_domain.JIdentifier) {
+func (Empty) EvaluateList(*EvaluateModel, []core_domain.CodeDataStruct, map[string]core_domain.CodeDataStruct, []core_domain.CodeDataStruct) {
 
 }
\ No newline at end of file

pkg/application/evaluate/evaluator/null_exception.go

@@ -11,7 +11,7 @@ func (NullPointException) Evaluate(*EvaluateModel, core_domain.CodeDataStruct) {
 
 }
 
-func (n NullPointException) EvaluateList(evaluateModel *EvaluateModel, nodes []core_domain.CodeDataStruct, nodeMap map[string]core_domain.CodeDataStruct, identifiers []core_domain.JIdentifier) {
+func (n NullPointException) EvaluateList(evaluateModel *EvaluateModel, nodes []core_domain.CodeDataStruct, nodeMap map[string]core_domain.CodeDataStruct, identifiers []core_domain.CodeDataStruct) {
 	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 []c
 	evaluateModel.Nullable.Items = nullableList
 }
 
-func buildMethodPath(ident core_domain.JIdentifier, method core_domain.CodeFunction) string {
+func buildMethodPath(ident core_domain.CodeDataStruct, method core_domain.CodeFunction) string {
 	return ident.Package + "." + ident.NodeName + "." + method.Name
 }

pkg/application/evaluate/evaluator/service.go

@@ -14,7 +14,7 @@ var serviceNodeMap map[string]core_domain.CodeDataStruct
 var returnTypeMap map[string][]string
 var longParameterList []core_domain.CodeFunction
 
-func (s Service) EvaluateList(evaluateModel *EvaluateModel, nodes []core_domain.CodeDataStruct, nodeMap map[string]core_domain.CodeDataStruct, identifiers []core_domain.JIdentifier) {
+func (s Service) EvaluateList(evaluateModel *EvaluateModel, nodes []core_domain.CodeDataStruct, nodeMap map[string]core_domain.CodeDataStruct, identifiers []core_domain.CodeDataStruct) {
 	serviceNodeMap = nodeMap
 	longParameterList = nil
 	returnTypeMap = make(map[string][]string)

pkg/application/evaluate/evaluator/util.go

@@ -11,6 +11,6 @@ func (Util) Evaluate(result *EvaluateModel, node core_domain.CodeDataStruct) {
 
 }
 
-func (s Util) EvaluateList(evaluateModel *EvaluateModel, nodes []core_domain.CodeDataStruct, nodeMap map[string]core_domain.CodeDataStruct, identifiers []core_domain.JIdentifier) {
+func (s Util) EvaluateList(evaluateModel *EvaluateModel, nodes []core_domain.CodeDataStruct, nodeMap map[string]core_domain.CodeDataStruct, identifiers []core_domain.CodeDataStruct) {
 
 }

pkg/application/tbs/tbs_app.go

@@ -19,7 +19,7 @@ type TestBadSmell struct {
 	Line        int
 }
 
-func (a TbsApp) AnalysisPath(deps []core_domain.CodeDataStruct, identifiersMap map[string]core_domain.JIdentifier) []TestBadSmell {
+func (a TbsApp) AnalysisPath(deps []core_domain.CodeDataStruct, identifiersMap map[string]core_domain.CodeDataStruct) []TestBadSmell {
 	var results []TestBadSmell = nil
 	callMethodMap := core_domain.BuildCallMethodMap(deps)
 	for _, clz := range deps {

pkg/application/tbs/tbs_app_test.go

@@ -139,7 +139,7 @@ func buildTbsResult(codePath string) []TestBadSmell {
 	return result
 }
 
-func BuildTestAnalysisResultsByPath(codePath string) (map[string]core_domain.JIdentifier, []core_domain.CodeDataStruct) {
+func BuildTestAnalysisResultsByPath(codePath string) (map[string]core_domain.CodeDataStruct, []core_domain.CodeDataStruct) {
 	files := cocafile.GetJavaTestFiles(codePath)
 
 	identifiers := cmd_util.LoadTestIdentify(files)

pkg/domain/core_domain/code_data_struct.go

@@ -21,45 +21,35 @@ type CodeDataStruct struct {
 	Extension interface{}
 }
 
-type JIdentifier struct {
-	NodeName    string
-	Package     string
-	Type        string
-	Extend      string
-	Implements  []string
-	Functions   []CodeFunction
-	Annotations []CodeAnnotation
-}
-
 func NewDataStruct() *CodeDataStruct {
 	return &CodeDataStruct{}
 }
 
-func (j *CodeDataStruct) IsUtilClass() bool {
-	return strings.Contains(strings.ToLower(j.NodeName), "util") || strings.Contains(strings.ToLower(j.NodeName), "utils")
+func (d *CodeDataStruct) IsUtilClass() bool {
+	return strings.Contains(strings.ToLower(d.NodeName), "util") || strings.Contains(strings.ToLower(d.NodeName), "utils")
 }
 
-func (j *CodeDataStruct) IsServiceClass() bool {
-	return strings.Contains(strings.ToLower(j.NodeName), "service")
+func (d *CodeDataStruct) IsServiceClass() bool {
+	return strings.Contains(strings.ToLower(d.NodeName), "service")
 }
 
-func (j *CodeDataStruct) SetMethodFromMap(methodMap map[string]CodeFunction) {
+func (d *CodeDataStruct) SetMethodFromMap(methodMap map[string]CodeFunction) {
 	var methodsArray []CodeFunction
 	for _, value := range methodMap {
 		methodsArray = append(methodsArray, value)
 	}
 
-	j.Functions = methodsArray
+	d.Functions = methodsArray
 }
 
-func (j *CodeDataStruct) BuildStringMethodMap(projectMethods map[string]string) {
-	for _, method := range j.Functions {
-		projectMethods[method.BuildFullMethodName(*j)] = method.BuildFullMethodName(*j)
+func (d *CodeDataStruct) BuildStringMethodMap(projectMethods map[string]string) {
+	for _, method := range d.Functions {
+		projectMethods[method.BuildFullMethodName(*d)] = method.BuildFullMethodName(*d)
 	}
 }
 
-func (j *CodeDataStruct) IsNotEmpty() bool {
-	return len(j.Functions) > 0 || len(j.FunctionCalls) > 0
+func (d *CodeDataStruct) IsNotEmpty() bool {
+	return len(d.Functions) > 0 || len(d.FunctionCalls) > 0
 }
 
 func BuildCallMethodMap(deps []CodeDataStruct) map[string]CodeFunction {
@@ -72,16 +62,12 @@ func BuildCallMethodMap(deps []CodeDataStruct) map[string]CodeFunction {
 	return callMethodMap
 }
 
-func NewJIdentifier() *JIdentifier {
-	return &JIdentifier{}
-}
-
-func (identifier *JIdentifier) GetClassFullName() string {
-	return identifier.Package + "." + identifier.NodeName
+func (d *CodeDataStruct) GetClassFullName() string {
+	return d.Package + "." + d.NodeName
 }
 
-func BuildIdentifierMap(identifiers []JIdentifier) map[string]JIdentifier {
-	var identifiersMap = make(map[string]JIdentifier)
+func BuildIdentifierMap(identifiers []CodeDataStruct) map[string]CodeDataStruct {
+	var identifiersMap = make(map[string]CodeDataStruct)
 
 	for _, ident := range identifiers {
 		identifiersMap[ident.Package+"."+ident.NodeName] = ident
@@ -89,7 +75,7 @@ func BuildIdentifierMap(identifiers []JIdentifier) map[string]JIdentifier {
 	return identifiersMap
 }
 
-func BuildDIMap(identifiers []JIdentifier, identifierMap map[string]JIdentifier) map[string]string {
+func BuildDIMap(identifiers []CodeDataStruct, identifierMap map[string]CodeDataStruct) map[string]string {
 	var diMap = make(map[string]string)
 	for _, clz := range identifiers {
 		if len(clz.Annotations) > 0 {

pkg/domain/core_domain/jidentifier.go

-package core_domain
-

pkg/infrastructure/ast/api/java_api_listener.go

@@ -22,11 +22,11 @@ var restAPIs []api_domain.RestAPI
 var currentClz string
 var currentPkg string
 
-var identMap map[string]core_domain.JIdentifier
+var identMap map[string]core_domain.CodeDataStruct
 var imports []string
 var currentImplements = ""
 
-func NewJavaAPIListener(jIdentMap map[string]core_domain.JIdentifier, diMap map[string]string) *JavaAPIListener {
+func NewJavaAPIListener(jIdentMap map[string]core_domain.CodeDataStruct, diMap map[string]string) *JavaAPIListener {
 	isSpringRestController = false
 	currentClz = ""
 	currentPkg = ""

pkg/infrastructure/ast/full/java_full_listener.go

@@ -29,7 +29,7 @@ var creatorMethodMap = make(map[string]core_domain.CodeFunction)
 var methodQueue []core_domain.CodeFunction
 var classStringQueue []string
 
-var identMap map[string]core_domain.JIdentifier
+var identMap map[string]core_domain.CodeDataStruct
 var isOverrideMethod = false
 
 var classNodeQueue []core_domain.CodeDataStruct
@@ -41,7 +41,7 @@ var currentCreatorNode core_domain.CodeDataStruct
 var fileName = ""
 var hasEnterClass = false
 
-func NewJavaFullListener(nodes map[string]core_domain.JIdentifier, file string) *JavaFullListener {
+func NewJavaFullListener(nodes map[string]core_domain.CodeDataStruct, file string) *JavaFullListener {
 	identMap = nodes
 	imports = nil
 	fileName = file

pkg/infrastructure/ast/identifier/java_identifier_listener.go

@@ -9,8 +9,8 @@ import (
 	"strings"
 )
 
-var currentNode *core_domain.JIdentifier
-var nodes []core_domain.JIdentifier
+var currentNode *core_domain.CodeDataStruct
+var nodes []core_domain.CodeDataStruct
 
 var currentMethod core_domain.CodeFunction
 var hasEnterClass = false
@@ -18,7 +18,7 @@ var imports []string
 
 func NewJavaIdentifierListener() *JavaIdentifierListener {
 	nodes = nil
-	currentNode = core_domain.NewJIdentifier()
+	currentNode = core_domain.NewDataStruct()
 	currentMethod = core_domain.NewJMethod()
 	return &JavaIdentifierListener{}
 }
@@ -68,7 +68,7 @@ func (s *JavaIdentifierListener) ExitClassBody(ctx *parser.ClassBodyContext) {
 	if currentNode.NodeName != "" {
 		nodes = append(nodes, *currentNode)
 	}
-	currentNode = core_domain.NewJIdentifier()
+	currentNode = core_domain.NewDataStruct()
 }
 
 func (s *JavaIdentifierListener) ExitInterfaceDeclaration(ctx *parser.InterfaceDeclarationContext) {
@@ -76,7 +76,7 @@ func (s *JavaIdentifierListener) ExitInterfaceDeclaration(ctx *parser.InterfaceD
 	if currentNode.NodeName != "" {
 		nodes = append(nodes, *currentNode)
 	}
-	currentNode = core_domain.NewJIdentifier()
+	currentNode = core_domain.NewDataStruct()
 }
 
 func (s *JavaIdentifierListener) EnterConstructorDeclaration(ctx *parser.ConstructorDeclarationContext) {
@@ -216,6 +216,6 @@ func (s *JavaIdentifierListener) EnterExpression(ctx *parser.ExpressionContext)
 	}
 }
 
-func (s *JavaIdentifierListener) GetNodes() []core_domain.JIdentifier {
+func (s *JavaIdentifierListener) GetNodes() []core_domain.CodeDataStruct {
 	return nodes
 }

trial/pkg/application/processor/process_test.go

@@ -10,5 +10,5 @@ func Test_ProcessPackage(t *testing.T) {
 	g := NewGomegaWithT(t)
 
 	results := ProcessPackage("../../../../pkg/domain", true)
-	g.Expect(len(results)).To(Equal(22))
+	g.Expect(len(results)).To(Equal(21))
 }
\ No newline at end of file