@Override public List<Task> getIssues( @Nullable String query, int max, long since, boolean forceRequest, final boolean withClosed, @NotNull final ProgressIndicator cancelled) { List<Task> tasks = getIssuesFromRepositories(query, max, since, forceRequest, cancelled); if (tasks == null) return getCachedIssues(withClosed); myIssueCache.putAll(ContainerUtil.newMapFromValues(tasks.iterator(), KEY_CONVERTOR)); return ContainerUtil.filter( tasks, new Condition<Task>() { @Override public boolean value(final Task task) { return withClosed || !task.isClosed(); } }); }
/** @author Mikhail Golubev */ public enum JqlStandardField { AFFECTED_VERSION("affectedVersion", JqlFieldType.VERSION), ASSIGNEE("assignee", JqlFieldType.USER), CATEGORY("category", JqlFieldType.CATEGORY), COMMENT("comment", JqlFieldType.TEXT), COMPONENT("component", JqlFieldType.COMPONENT), CREATED("created", JqlFieldType.DATE), CREATED_DATE("createdDate", JqlFieldType.DATE), DESCRIPTION("description", JqlFieldType.TEXT), DUE("due", JqlFieldType.DATE), DUE_DATE("dueDate", JqlFieldType.DATE), ENVIRONMENT("environment", JqlFieldType.TEXT), FILTER("filter", JqlFieldType.FILTER), REQUEST("request", JqlFieldType.FILTER), SAVED_FILTER("savedFilter", JqlFieldType.FILTER), SEARCH_REQUEST("searchRequest", JqlFieldType.FILTER), FIX_VERSION("fixVersion", JqlFieldType.VERSION), ISSUE_KEY("issueKey", JqlFieldType.ISSUE), ID("id", JqlFieldType.ISSUE), ISSUE("issue", JqlFieldType.ISSUE), KEY("key", JqlFieldType.ISSUE), LAST_VIEWED("lastViewed", JqlFieldType.DATE), LEVEL("level", JqlFieldType.SECURITY_LEVEL), ORIGINAL_ESTIMATE("originalEstimate", JqlFieldType.DURATION), TIME_ORIGINAL_ESTIMATE("timeOriginalEstimate", JqlFieldType.DURATION), PARENT("parent", JqlFieldType.ISSUE), PRIORITY("priority", JqlFieldType.PRIORITY), PROJECT("project", JqlFieldType.PROJECT), REMAINING_ESTIMATE("remainingEstimate", JqlFieldType.DURATION), TIME_ESTIMATE("timeEstimate", JqlFieldType.DURATION), REPORTER("reporter", JqlFieldType.USER), RESOLUTION("resolution", JqlFieldType.RESOLUTION), RESOLVED("resolved", JqlFieldType.DATE), RESOLUTION_DATE("resolutionDate", JqlFieldType.DATE), STATUS("status", JqlFieldType.STATUS), SUMMARY("summary", JqlFieldType.TEXT), // So called "master-field". Search in summary, description, environment, // comments and custom fields TEXT("text", JqlFieldType.TEXT), TYPE("type", JqlFieldType.ISSUE_TYPE), ISSUE_TYPE("issueType", JqlFieldType.ISSUE_TYPE), TIME_SPENT("timeSpent", JqlFieldType.DURATION), UPDATED("updated", JqlFieldType.DATE), UPDATED_DATE("updatedDate", JqlFieldType.DATE), VOTER("voter", JqlFieldType.USER), VOTES("votes", JqlFieldType.NUMBER), WATCHER("watcher", JqlFieldType.USER), WATCHERS("watchers", JqlFieldType.NUMBER), WORK_RATION("workRatio", JqlFieldType.NUMBER); private final String myName; private final JqlFieldType myType; JqlStandardField(String name, JqlFieldType type) { myName = name; myType = type; } public String getName() { return myName; } public JqlFieldType getType() { return myType; } private static final JqlStandardField[] VALUES = values(); private static final Map<String, JqlStandardField> NAME_LOOKUP = ContainerUtil.newMapFromValues( ContainerUtil.iterate(VALUES), new Convertor<JqlStandardField, String>() { @Override public String convert(JqlStandardField field) { return field.getName(); } }); public static JqlStandardField byName(String name) { return NAME_LOOKUP.get(name); } private static final MultiMap<JqlFieldType, String> TYPE_LOOKUP = new MultiMap<JqlFieldType, String>(); static { for (JqlStandardField field : VALUES) { TYPE_LOOKUP.putValue(field.getType(), field.getName()); } } public static Collection<String> allOfType(JqlFieldType type) { return type == JqlFieldType.UNKNOWN ? ALL_FIELD_NAMES : new ArrayList<String>(TYPE_LOOKUP.get(type)); } public static final List<String> ALL_FIELD_NAMES = ContainerUtil.map2List(VALUES, field -> field.myName); public static JqlFieldType typeOf(String name) { for (Map.Entry<JqlFieldType, Collection<String>> entry : TYPE_LOOKUP.entrySet()) { if (entry.getValue().contains(name)) { return entry.getKey(); } } return JqlFieldType.UNKNOWN; } }
// new TemplatesGroup selected public void projectTypeChanged() { TemplatesGroup group = getSelectedGroup(); if (group == null || group == myLastSelectedGroup) return; myLastSelectedGroup = group; PropertiesComponent.getInstance().setValue(PROJECT_WIZARD_GROUP, group.getId()); ModuleBuilder groupModuleBuilder = group.getModuleBuilder(); mySettingsStep = null; myHeaderPanel.removeAll(); if (groupModuleBuilder != null && groupModuleBuilder.getModuleType() != null) { mySettingsStep = groupModuleBuilder.modifyProjectTypeStep(this); } if (groupModuleBuilder == null || groupModuleBuilder.isTemplateBased()) { showTemplates(group); } else if (!showCustomOptions(groupModuleBuilder)) { List<FrameworkSupportInModuleProvider> providers = FrameworkSupportUtil.getProviders(groupModuleBuilder); final ProjectCategory category = group.getProjectCategory(); if (category != null) { List<FrameworkSupportInModuleProvider> filtered = ContainerUtil.filter( providers, new Condition<FrameworkSupportInModuleProvider>() { @Override public boolean value(FrameworkSupportInModuleProvider provider) { return matchFramework(category, provider); } }); // add associated Map<String, FrameworkSupportInModuleProvider> map = ContainerUtil.newMapFromValues(providers.iterator(), PROVIDER_STRING_CONVERTOR); Set<FrameworkSupportInModuleProvider> set = new HashSet<FrameworkSupportInModuleProvider>(filtered); for (FrameworkSupportInModuleProvider provider : filtered) { for (FrameworkSupportInModuleProvider.FrameworkDependency depId : provider.getDependenciesFrameworkIds()) { FrameworkSupportInModuleProvider dependency = map.get(depId.getFrameworkId()); set.add(dependency); } } myFrameworksPanel.setProviders( new ArrayList<FrameworkSupportInModuleProvider>(set), new HashSet<String>(Arrays.asList(category.getAssociatedFrameworkIds())), new HashSet<String>(Arrays.asList(category.getPreselectedFrameworkIds()))); } else { myFrameworksPanel.setProviders(providers); } getSelectedBuilder().addModuleConfigurationUpdater(myConfigurationUpdater); showCard(FRAMEWORKS_CARD); } myHeaderPanel.setVisible(myHeaderPanel.getComponentCount() > 0); // align header labels List<JLabel> labels = UIUtil.findComponentsOfType(myHeaderPanel, JLabel.class); int width = 0; for (JLabel label : labels) { int width1 = label.getPreferredSize().width; width = Math.max(width, width1); } for (JLabel label : labels) { label.setPreferredSize(new Dimension(width, label.getPreferredSize().height)); } myHeaderPanel.revalidate(); myHeaderPanel.repaint(); updateSelection(); }
public abstract class ErlangExpressionType { public String getName() { return myName; } private final String myName; protected ErlangExpressionType(String name) { myName = name; } @Override public String toString() { return "ErlangExpressionType{'" + myName + "'}"; } public boolean accept(ErlangExpressionType type) { return equals(type); } public static class ErlangPrimitiveType extends ErlangExpressionType { public ErlangPrimitiveType(@NotNull String name) { super(name); } } private static final ErlangExpressionType FLOAT = new ErlangPrimitiveType("FLOAT"); private static final ErlangExpressionType FUN = new ErlangPrimitiveType("FUN"); private static final ErlangExpressionType INTEGER = new ErlangPrimitiveType("INTEGER"); private static final ErlangExpressionType CHAR = new ErlangPrimitiveType("CHAR"); private static final ErlangExpressionType IOLIST = new ErlangPrimitiveType("IOLIST"); private static final ErlangExpressionType TUPLE = new ErlangPrimitiveType("TUPLE"); private static final ErlangExpressionType ATOM = new ErlangPrimitiveType("ATOM"); private static final ErlangExpressionType BINARY = new ErlangPrimitiveType("BINARY"); private static final ErlangExpressionType BITSTRING = new ErlangPrimitiveType("BITSTRING"); private static final ErlangExpressionType STRING = new ErlangPrimitiveType("STRING"); private static final ErlangExpressionType PID = new ErlangPrimitiveType("PID"); private static final ErlangExpressionType PORT = new ErlangPrimitiveType("PORT"); private static final ErlangExpressionType REF = new ErlangPrimitiveType("REF"); private static final ErlangExpressionType TERM = new ErlangPrimitiveType("TERM"); private static final ErlangExpressionType BOOLEAN = new ErlangPrimitiveType("BOOLEAN"); public static final ErlangExpressionType UNKNOWN = new ErlangPrimitiveType("UNKNOWN"); private static final ErlangExpressionType LIST = new ErlangPrimitiveType("LIST") { @Override public boolean accept(ErlangExpressionType type) { return super.accept(type) || type.equals(STRING); } }; public static final Map<String, ErlangExpressionType> TYPE_MAP = ContainerUtil.newMapFromValues( ContainerUtil.list( FLOAT, FUN, INTEGER, LIST, IOLIST, TUPLE, ATOM, BINARY, BITSTRING, STRING, PID, PORT, REF, TERM, BOOLEAN) .iterator(), erlangExpressionType -> erlangExpressionType.myName.toLowerCase()); @NotNull public static ErlangExpressionType create(@Nullable ErlangExpression e) { if (e == null) return UNKNOWN; final Ref<ErlangExpressionType> ref = Ref.create(UNKNOWN); e.accept( new ErlangVisitor() { @Override public void visitParenthesizedExpression(@NotNull ErlangParenthesizedExpression o) { ref.set(create(o.getExpression())); } @Override public void visitMultiplicativeExpression(@NotNull ErlangMultiplicativeExpression o) { PsiElement firstChild = o.getFirstChild(); PsiElement operator = firstChild.getNextSibling(); if (operator == null) return; IElementType operatorElementType = operator.getNode().getElementType(); if (operatorElementType == ErlangTypes.ERL_OP_AR_DIV) ref.set(FLOAT); else if (operatorElementType == ErlangTypes.ERL_OP_AR_MUL) { ErlangExpressionType leftType = create(o.getLeft()); ErlangExpressionType rightType = create(o.getRight()); if (leftType.equals(rightType)) ref.set(leftType); else ref.set(FLOAT); } } @Override public void visitFunctionCallExpression(@NotNull ErlangFunctionCallExpression o) { PsiReference reference = o.getReference(); PsiElement element = reference != null ? reference.resolve() : null; if (element instanceof ErlangFunction) { ref.set(calculateFunctionType((ErlangFunction) element)); } } @Override public void visitBinaryExpression(@NotNull ErlangBinaryExpression o) { ref.set(BINARY); } @Override public void visitTupleExpression(@NotNull ErlangTupleExpression o) { ref.set(TUPLE); } @Override public void visitListExpression(@NotNull ErlangListExpression o) { ref.set(LIST); } @Override public void visitAdditiveExpression(@NotNull ErlangAdditiveExpression o) { ErlangExpressionType leftType = create(o.getLeft()); ErlangExpressionType rightType = create(o.getRight()); if (leftType.equals(rightType)) ref.set(leftType); } @Override public void visitMaxExpression(@NotNull ErlangMaxExpression o) { if (o.getInteger() != null) ref.set(INTEGER); else if (o.getFloat() != null) ref.set(FLOAT); else if (o.getQAtom() != null) ref.set(ATOM); else if (o.getChar() != null) ref.set(CHAR); } @Override public void visitStringLiteral(@NotNull ErlangStringLiteral o) { ref.set(STRING); } @Override public void visitFunExpression(@NotNull ErlangFunExpression o) { ref.set(FUN); } }); return ref.get(); } @NotNull public static ErlangExpressionType calculateFunctionType(@NotNull ErlangFunction function) { ErlangSpecification spec = function.findSpecification(); if (spec == null) return UNKNOWN; ErlangFunTypeSigs signature = ErlangPsiImplUtil.getSignature(spec); if (signature == null) return UNKNOWN; for (ErlangTypeSig typeSig : signature.getTypeSigList()) { ErlangFunType funType = typeSig.getFunType(); ErlangTopTypeClause typeClause = funType.getTopTypeClause(); ErlangType type = PsiTreeUtil.getChildOfType(typeClause, ErlangType.class); ErlangTypeRef typeRef = type != null ? type.getTypeRef() : null; String text = typeRef != null ? typeRef.getText() : null; ErlangExpressionType expressionType = TYPE_MAP.get(text); if (expressionType != null) return expressionType; } return UNKNOWN; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ErlangExpressionType that = (ErlangExpressionType) o; if (myName != null ? !myName.equals(that.myName) : that.myName != null) return false; return true; } @Override public int hashCode() { return myName != null ? myName.hashCode() : 0; } }