#525521553

Committed 27 May 2025 10:24AM UTC coverage: 82.286% (-0.03%) from 82.32%

Build # #525521553

Build Type

push

github

Committed by

hurricup

Commit Message

Removed redundant implementations, moved up to the abstract class

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

128 existing lines in 30 files now uncovered.

30886 of 37535 relevant lines covered (82.29%)

0.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.8

/plugin/core/src/main/java/com/perl5/lang/perl/psi/references/PerlBuiltInVariablesService.java

/*
 * Copyright 2015-2025 Alexandr Evstigneev
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.perl5.lang.perl.psi.references;

import com.intellij.openapi.progress.ProgressManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.PsiManager;
import com.intellij.util.Processor;
import com.perl5.lang.perl.psi.PerlVariableDeclarationElement;
import com.perl5.lang.perl.psi.impl.PerlBuiltInVariable;
import com.perl5.lang.perl.psi.utils.PerlVariableType;
import com.perl5.lang.perl.util.PerlArrayUtil;
import com.perl5.lang.perl.util.PerlBuiltInScalars;
import com.perl5.lang.perl.util.PerlGlobUtil;
import com.perl5.lang.perl.util.PerlHashUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

import static com.perl5.lang.perl.psi.utils.PerlVariableType.*;

public class PerlBuiltInVariablesService {
  private final PsiManager myPsiManager;
  private final Map<String, PerlBuiltInVariable> myScalars = new HashMap<>();
  private final Map<String, PerlBuiltInVariable> myArrays = new HashMap<>();
  private final Map<String, PerlBuiltInVariable> myHashes = new HashMap<>();
  private final Map<String, PerlBuiltInVariable> myGlobs = new HashMap<>();

  public PerlBuiltInVariablesService(Project project) {
    myPsiManager = PsiManager.getInstance(project);

    for (int i = 1; i <= 20; i++) {
      String variableName = Integer.toString(i);
      myScalars.put(variableName, new PerlBuiltInVariable(myPsiManager, "$" + variableName));
    }
    PerlBuiltInScalars.BUILT_IN.forEach(name -> myScalars.put(name, new PerlBuiltInVariable(myPsiManager, SCALAR.withSigil(name))));
    PerlArrayUtil.BUILT_IN.forEach(name -> myArrays.put(name, new PerlBuiltInVariable(myPsiManager, ARRAY.withSigil(name))));
    PerlHashUtil.BUILT_IN.forEach(name -> myHashes.put(name, new PerlBuiltInVariable(myPsiManager, HASH.withSigil(name))));
    PerlGlobUtil.BUILT_IN.forEach(name -> myGlobs.put(name, new PerlBuiltInVariable(myPsiManager, GLOB.withSigil(name))));
  }

  public @Nullable PerlBuiltInVariable getScalar(@Nullable String name) {
    return myScalars.get(name);
  }

  public @Nullable PerlBuiltInVariable getArray(@Nullable String name) {
    return myArrays.get(name);
  }

  public @Nullable PerlBuiltInVariable getHash(@Nullable String name) {
    return myHashes.get(name);
  }

  public @Nullable PerlBuiltInVariable getGlob(@Nullable String name) {
    return myHashes.get(name);
  }

  public boolean processScalars(@NotNull Processor<PerlVariableDeclarationElement> processor) {
    return processVariables(myScalars, processor);
  }

  public boolean processArrays(@NotNull Processor<PerlVariableDeclarationElement> processor) {
    return processVariables(myArrays, processor);
  }

  public boolean processHashes(@NotNull Processor<PerlVariableDeclarationElement> processor) {
    return processVariables(myHashes, processor);
  }

  @SuppressWarnings("UnusedReturnValue")
  public boolean processVariables(@NotNull Processor<PerlVariableDeclarationElement> processor) {
    return processScalars(processor) && processArrays(processor) && processHashes(processor) && processGlobs(processor);
  }

  public boolean processGlobs(@NotNull Processor<PerlVariableDeclarationElement> processor) {
    return processVariables(myGlobs, processor);
  }

  public @Nullable PerlVariableDeclarationElement getVariableDeclaration(@Nullable PerlVariableType type, @Nullable String variableName) {
    if (StringUtil.isEmpty(variableName)) {
      return null;
    }

    if (type == SCALAR) {
      return getScalar(variableName);
    }
    else if (type == PerlVariableType.ARRAY) {
      return getArray(variableName);
    }
    else if (type == PerlVariableType.HASH) {
      return getHash(variableName);
    }

    return null;
  }

  private static boolean processVariables(@NotNull Map<String, PerlBuiltInVariable> variableMap,
                                          @NotNull Processor<PerlVariableDeclarationElement> processor) {
    for (PerlBuiltInVariable variable : variableMap.values()) {
      ProgressManager.checkCanceled();
      if (!processor.process(variable)) {
        return false;
      }
    }
    return true;
  }

  public static @NotNull PerlBuiltInVariablesService getInstance(@NotNull Project project) {
    return project.getService(PerlBuiltInVariablesService.class);
  }

  /**
   * @return {@code @_}
   */
  public static @NotNull PerlBuiltInVariable getImplicitArray(@NotNull Project project) {
    return Objects.requireNonNull(getInstance(project).getArray("_"));
  }

  /**
   * @return {@code $_}
   */
  public static @NotNull PerlBuiltInVariable getImplicitScalar(@NotNull Project project) {
    return Objects.requireNonNull(getInstance(project).getScalar("_"));
  }
}

1	/*
2	* Copyright 2015-2025 Alexandr Evstigneev
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	package com.perl5.lang.perl.psi.references;
18
19	import com.intellij.openapi.progress.ProgressManager;
20	import com.intellij.openapi.project.Project;
21	import com.intellij.openapi.util.text.StringUtil;
22	import com.intellij.psi.PsiManager;
23	import com.intellij.util.Processor;
24	import com.perl5.lang.perl.psi.PerlVariableDeclarationElement;
25	import com.perl5.lang.perl.psi.impl.PerlBuiltInVariable;
26	import com.perl5.lang.perl.psi.utils.PerlVariableType;
27	import com.perl5.lang.perl.util.PerlArrayUtil;
28	import com.perl5.lang.perl.util.PerlBuiltInScalars;
29	import com.perl5.lang.perl.util.PerlGlobUtil;
30	import com.perl5.lang.perl.util.PerlHashUtil;
31	import org.jetbrains.annotations.NotNull;
32	import org.jetbrains.annotations.Nullable;
33
34	import java.util.HashMap;
35	import java.util.Map;
36	import java.util.Objects;
37
38	import static com.perl5.lang.perl.psi.utils.PerlVariableType.*;
39
40	public class PerlBuiltInVariablesService {
41	private final PsiManager myPsiManager;
42	private final Map<String, PerlBuiltInVariable> myScalars = new HashMap<>();	1✔
43	private final Map<String, PerlBuiltInVariable> myArrays = new HashMap<>();	1✔
44	private final Map<String, PerlBuiltInVariable> myHashes = new HashMap<>();	1✔
45	private final Map<String, PerlBuiltInVariable> myGlobs = new HashMap<>();	1✔
46
47	public PerlBuiltInVariablesService(Project project) {	1✔
48	myPsiManager = PsiManager.getInstance(project);	1✔
49
50	for (int i = 1; i <= 20; i++) {	1✔
51	String variableName = Integer.toString(i);	1✔
52	myScalars.put(variableName, new PerlBuiltInVariable(myPsiManager, "$" + variableName));	1✔
53	}
54	PerlBuiltInScalars.BUILT_IN.forEach(name -> myScalars.put(name, new PerlBuiltInVariable(myPsiManager, SCALAR.withSigil(name))));	1✔
55	PerlArrayUtil.BUILT_IN.forEach(name -> myArrays.put(name, new PerlBuiltInVariable(myPsiManager, ARRAY.withSigil(name))));	1✔
56	PerlHashUtil.BUILT_IN.forEach(name -> myHashes.put(name, new PerlBuiltInVariable(myPsiManager, HASH.withSigil(name))));	1✔
57	PerlGlobUtil.BUILT_IN.forEach(name -> myGlobs.put(name, new PerlBuiltInVariable(myPsiManager, GLOB.withSigil(name))));	1✔
58	}	1✔
59
60	public @Nullable PerlBuiltInVariable getScalar(@Nullable String name) {
61	return myScalars.get(name);	1✔
62	}
63
64	public @Nullable PerlBuiltInVariable getArray(@Nullable String name) {
65	return myArrays.get(name);	1✔
66	}
67
68	public @Nullable PerlBuiltInVariable getHash(@Nullable String name) {
69	return myHashes.get(name);	1✔
70	}
71
72	public @Nullable PerlBuiltInVariable getGlob(@Nullable String name) {
73	return myHashes.get(name);	×
74	}
75
76	public boolean processScalars(@NotNull Processor<PerlVariableDeclarationElement> processor) {
77	return processVariables(myScalars, processor);	1✔
78	}
79
80	public boolean processArrays(@NotNull Processor<PerlVariableDeclarationElement> processor) {
81	return processVariables(myArrays, processor);	1✔
82	}
83
84	public boolean processHashes(@NotNull Processor<PerlVariableDeclarationElement> processor) {
85	return processVariables(myHashes, processor);	1✔
86	}
87
88	@SuppressWarnings("UnusedReturnValue")
89	public boolean processVariables(@NotNull Processor<PerlVariableDeclarationElement> processor) {
90	return processScalars(processor) && processArrays(processor) && processHashes(processor) && processGlobs(processor);	1✔
91	}
92
93	public boolean processGlobs(@NotNull Processor<PerlVariableDeclarationElement> processor) {
94	return processVariables(myGlobs, processor);	1✔
95	}
96
97	public @Nullable PerlVariableDeclarationElement getVariableDeclaration(@Nullable PerlVariableType type, @Nullable String variableName) {
98	if (StringUtil.isEmpty(variableName)) {	1✔
UNCOV 99	return null;	×
100	}
101
102	if (type == SCALAR) {	1✔
103	return getScalar(variableName);	1✔
104	}
105	else if (type == PerlVariableType.ARRAY) {	1✔
106	return getArray(variableName);	1✔
107	}
108	else if (type == PerlVariableType.HASH) {	1✔
109	return getHash(variableName);	1✔
110	}
111
UNCOV 112	return null;	×
113	}
114
115	private static boolean processVariables(@NotNull Map<String, PerlBuiltInVariable> variableMap,
116	@NotNull Processor<PerlVariableDeclarationElement> processor) {
117	for (PerlBuiltInVariable variable : variableMap.values()) {	1✔
118	ProgressManager.checkCanceled();	1✔
119	if (!processor.process(variable)) {	1✔
UNCOV 120	return false;	×
121	}
122	}	1✔
123	return true;	1✔
124	}
125
126	public static @NotNull PerlBuiltInVariablesService getInstance(@NotNull Project project) {
127	return project.getService(PerlBuiltInVariablesService.class);	1✔
128	}
129
130	/**
131	* @return {@code @_}
132	*/
133	public static @NotNull PerlBuiltInVariable getImplicitArray(@NotNull Project project) {
134	return Objects.requireNonNull(getInstance(project).getArray("_"));	1✔
135	}
136
137	/**
138	* @return {@code $_}
139	*/
140	public static @NotNull PerlBuiltInVariable getImplicitScalar(@NotNull Project project) {
UNCOV 141	return Objects.requireNonNull(getInstance(project).getScalar("_"));	×
142	}
143	}

Camelcade / Perl5-IDEA / #525521553

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous