public static String getGoalText( final ChallengeGoalData goal, final ChallengeData data, final ChallengeDataModel model) { String rawText = goal.getFormattedString(); if (rawText == null || rawText.length() == 0) { return null; } rawText = (String) ChallengeFormatter.extractValue( rawText, ChallengeFormatter.Type.STRING, model.getParams()); for (Matcher match = ChallengeGoalView.GOAL_BREED_PATTERN.matcher(rawText); match.find(); match = ChallengeGoalView.GOAL_BREED_PATTERN.matcher(rawText)) { final String name = WakfuTranslator.getInstance() .getString(7, PrimitiveConverter.getInteger(match.group(1)), new Object[0]); rawText = match.replaceFirst(name); } for (Matcher match = ChallengeGoalView.GOAL_RESOURCE_PATTERN.matcher(rawText); match.find(); match = ChallengeGoalView.GOAL_RESOURCE_PATTERN.matcher(rawText)) { final String name = WakfuTranslator.getInstance() .getString(12, PrimitiveConverter.getInteger(match.group(1)), new Object[0]); rawText = match.replaceFirst(name); } for (Matcher match = ChallengeGoalView.GOAL_VAR_PATTERN.matcher(rawText); match.find(); match = ChallengeGoalView.GOAL_VAR_PATTERN.matcher(rawText)) { final Long value = data.getVarValue(match.group().substring(1, match.group().length() - 1)); rawText = match.replaceFirst(value.toString()); } return rawText; }
/** * Return info about this regex. Does it match the text, how many groups, etc. * * @param text body of text * @param regex regex expression to run against the text * @param flags Pattern.DOTALL, MULTILINE, CASE_INSENSITIVE, etc. * @return text about matches */ public static String getRegexInfo(String text, String regex, int flags) { try { if (text.isEmpty() || regex.isEmpty()) { return ""; } Pattern pat = Pattern.compile(regex, flags); Matcher mat = pat.matcher(text); int matchCount = 0; StringBuilder builder = new StringBuilder(); while (mat.find()) { matchCount++; builder.append(String.format(" Match: \"%s\"\n", mat.group(0))); // Weirdness alert: groupCount() doesn't include group(0), which is the full match. // Thus if groupCount() == 1, we want to display group(1), not group(0). for (int gCount = 1; gCount <= mat.groupCount(); gCount++) { builder.append(String.format(" Group %d: \"%s\"\n", gCount, mat.group(gCount))); } builder.append("\n"); } return String.format("Matches: %d\n%s", matchCount, builder.toString()); } catch (Exception e) { return ""; } }
private String decodeEntities(String s) { StringBuffer buf = new StringBuffer(); Matcher m = P_ENTITY.matcher(s); while (m.find()) { final String match = m.group(1); final int decimal = Integer.decode(match).intValue(); m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal))); } m.appendTail(buf); s = buf.toString(); buf = new StringBuffer(); m = P_ENTITY_UNICODE.matcher(s); while (m.find()) { final String match = m.group(1); final int decimal = Integer.valueOf(match, 16).intValue(); m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal))); } m.appendTail(buf); s = buf.toString(); buf = new StringBuffer(); m = P_ENCODE.matcher(s); while (m.find()) { final String match = m.group(1); final int decimal = Integer.valueOf(match, 16).intValue(); m.appendReplacement(buf, Matcher.quoteReplacement(chr(decimal))); } m.appendTail(buf); s = buf.toString(); s = validateEntities(s); return s; }
/** * {@inheritDoc} <br> * Overridden to always compute the class name and the object number. * * @see org.xwiki.model.reference.EntityReference#setName(java.lang.String) */ @Override protected void setName(String name) { super.setName(name); String classReferenceStr; String objectNumberStr; Matcher matcher = NUMBERPATTERN.matcher(name); if (matcher.find()) { if (matcher.group(1).length() % 2 == 0) { classReferenceStr = name.substring(0, matcher.end(1)); objectNumberStr = matcher.group(2); } else { classReferenceStr = name; objectNumberStr = null; } } else { classReferenceStr = name; objectNumberStr = null; } this.xclassReference = RESOLVER.resolve(classReferenceStr); if (objectNumberStr != null) { this.objectNumber = Integer.valueOf(objectNumberStr); } }
private List<String> findRelativeURLs(StringBuffer buf) { List<String> uris = new ArrayList<String>(); if (buf.indexOf("<wsdl:") < 0) { // $NON-NLS-1$ Pattern pattern = Pattern.compile("(<import)(.*)( schemaLocation=\")([^\"]+)"); // $NON-NLS-1$ Matcher matcher = pattern.matcher(buf); while (matcher.find()) { String relativeURLString = matcher.group(4); uris.add(relativeURLString); } pattern = Pattern.compile("(<import schemaLocation=\")([^\"]+)"); // $NON-NLS-1$ matcher = pattern.matcher(buf); while (matcher.find()) { String relativeURLString = matcher.group(2); uris.add(relativeURLString); } } else { Pattern pattern = Pattern.compile("(<xsd:import)(.*)( schemaLocation=\")([^\"]+)"); // $NON-NLS-1$ Matcher matcher = pattern.matcher(buf); while (matcher.find()) { String relativeURLString = matcher.group(4); uris.add(relativeURLString); } pattern = Pattern.compile("(<xsd:import schemaLocation=\")([^\"]+)"); // $NON-NLS-1$ matcher = pattern.matcher(buf); while (matcher.find()) { String relativeURLString = matcher.group(2); uris.add(relativeURLString); } } return uris; }
/** * Tries to parse the given input text. * * @param input the text to parse * @return the parsed {@link LedVisualize} or null */ static Target tryParseTarget(String input) { CmdAndAddressRet header = CmdAndAddressRet.parse(input, false); if (header != null) { Matcher matcher; switch (header.getCmd().toUpperCase()) { case "LED_STATE": if ((matcher = PATTERN_LED.matcher(header.getRestInput())).matches()) { int ledId = Integer.parseInt(matcher.group("ledId")) - 1; if (ledId < 12) { String[] stateTexts = new String[] { "off", "on", "blink", "flicker" // Defaults }; for (int i = 0; i < 4; ++i) { String s = matcher.group(String.format("text%d", i)); if (s != null) { stateTexts[i] = s; } } return new LedVisualize((LcnAddrMod) header.getAddr(), ledId, stateTexts); } } break; } } return null; }
private List parseCompileFailuresFromFormattedMessage(String target, String message) { final List errors = new ArrayList(); final Pattern pattern = Pattern.compile("^(.+):\\[(\\d+),\\d+\\] ", Pattern.MULTILINE); final Matcher matcher = pattern.matcher(message); boolean found = matcher.find(); while (found) { final String file = toRelative(matcher.group(1)); final Integer line = Integer.valueOf(matcher.group(2)); // final String msg = matcher.group(3); int start = matcher.end(); found = matcher.find(); int end = message.length() - 1; if (found) { end = matcher.start(); } final String msg = message.substring(start, end).replaceAll("\r", "").trim(); errors.add( new AntEventSummary( Constants.MESSAGE_LOGGED, "project", target, "task", msg, 0, file, line, null)); } return errors; }
// helper method for repeatHelper. private static int findInterval(String inputText) { HashMap<String, Integer> wordsToNum = new HashMap<String, Integer>(); String[] words = new String[] { "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve" }; for (int i = 0; i < words.length; i++) { wordsToNum.put(words[i], i + 1); wordsToNum.put(Integer.toString(i + 1), i + 1); } wordsToNum.put("other", 2); Pattern pattern = Pattern.compile("(?i)\\bevery (\\w*)\\b"); int interval = 1; Matcher m = pattern.matcher(inputText); if (m.find() && m.group(1) != null) { String intervalStr = m.group(1); if (wordsToNum.containsKey(intervalStr)) { interval = wordsToNum.get(intervalStr); } else { try { interval = Integer.parseInt(intervalStr); } catch (NumberFormatException e) { // Ah well } } } return interval; }
public static void main(String[] args) throws IOException { // Get input html StringBuffer sb = new StringBuffer(); BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); for (String str = in.readLine(); str != null; str = in.readLine()) { sb.append("\n" + str); } String html = sb.toString(); // Match all the questions Matcher matcher = Pattern.compile( "<\\s*div\\s+class\\s*=\\s*\"question-summary\"\\s*id\\s*=\\s*\"question-summary-(?<id>\\d+)\"\\s*>" + ".*?<\\s*div\\s+class\\s*=\\s*\"summary\"\\s*>" + ".*?<\\s*a\\s+.*?class\\s*=\\s*\"question-hyperlink\"\\s*>" + "(?<title>.*?)" + "</\\s*a\\s*>.*?<\\s*div\\s+class\\s*=\\s*\"user-action-time\"\\s*>" + ".*?<\\s*span\\s+.*?>(?<time>.*?)</\\s*span\\s*>", Pattern.CASE_INSENSITIVE | Pattern.DOTALL) .matcher(html); // Output the information while (matcher.find()) { String id = matcher.group("id"); String title = matcher.group("title"); String time = matcher.group("time"); System.out.println(id + ";" + title + ";" + time); } }
private void directPage(String text) { text = text.trim(); // LOG.debug("directPage(" + text + ')'); Matcher mat = PAGE_DIRECTIVE_PATTERN.matcher(text); for (int ix = 0; ; ) { if (!mat.find(ix)) { return; } String name = mat.group(1); String value = mat.group(2); if (name.equals(IMPORT_DIRECTIVE)) { pageImport(value); } if (name.equalsIgnoreCase(CONTENT_TYPE_DIRECTIVE)) { contentType(value); } if (name.equalsIgnoreCase(EXPRESSION_CODEC_DIRECTIVE)) { expressionCodecDirectiveValue = value.trim(); } if (name.equalsIgnoreCase(EXPRESSION_CODEC_DIRECTIVE_ALIAS)) { expressionCodecDirectiveValue = value.trim(); } if (name.equalsIgnoreCase(STATIC_CODEC_DIRECTIVE)) { staticCodecDirectiveValue = value.trim(); } if (name.equalsIgnoreCase(OUT_CODEC_DIRECTIVE)) { outCodecDirectiveValue = value.trim(); } if (name.equalsIgnoreCase(TAGLIB_CODEC_DIRECTIVE)) { taglibCodecDirectiveValue = value.trim(); } ix = mat.end(); } }
/** * The coder shall be able to decode all stock mechs. * * @throws Exception */ @Test public void testDecodeAllStock() throws Exception { InputStream is = LoadoutCoderV2.class.getResourceAsStream("/resources/lsmlv2stock.txt"); Scanner sc = new Scanner(is); Base64 base64 = new Base64(); // [JENNER JR7-D(F)]=lsml://rQAD5AgQCAwOFAYQCAwIuipmzMO3aIExIyk9jt2DMA== while (sc.hasNextLine()) { String line = sc.nextLine(); Pattern pat = Pattern.compile("\\[([^\\]]*)\\]\\s*=\\s*lsml://(\\S*).*"); Matcher m = pat.matcher(line); m.matches(); ChassisBase chassi = ChassisDB.lookup(m.group(1)); String lsml = m.group(2); LoadoutStandard reference = new LoadoutStandard(chassi.getName()); LoadoutStandard decoded = cut.decode(base64.decode(lsml.toCharArray())); // Name is not encoded OperationStack stack = new OperationStack(0); stack.pushAndApply(new OpRename(decoded, null, reference.getName())); // Verify assertEquals(reference, decoded); } sc.close(); }
/** * Match a URI against the pattern. * * <p>If the URI matches against the pattern then the capturing group values (if any) will be * added to a list passed in as parameter. * * @param uri the uri to match against the template. * @param groupValues the list to add the values of a pattern's capturing groups if matching is * successful. The values are added in the same order as the pattern's capturing groups. The * list is cleared before values are added. * @return true if the URI matches the pattern, otherwise false. * @throws IllegalArgumentException if the uri or capturingGroupValues is null. */ public final boolean match(CharSequence uri, List<String> groupValues) { if (groupValues == null) throw new IllegalArgumentException(); // Check for match against the empty pattern if (uri == null || uri.length() == 0) return (regexPattern == null) ? true : false; else if (regexPattern == null) return false; // Match the URI to the URI template regular expression Matcher m = regexPattern.matcher(uri); if (!m.matches()) return false; groupValues.clear(); if (groupIndexes.length > 0) { for (int i = 0; i < groupIndexes.length - 1; i++) { groupValues.add(m.group(groupIndexes[i])); } } else { for (int i = 1; i <= m.groupCount(); i++) { groupValues.add(m.group(i)); } } // TODO check for consistency of different capturing groups // that must have the same value return true; }
protected Map<String, String> getAttributes() { if (attributes != null) { return attributes; } attributes = new HashMap<String, String>(); matcher = ADDITIONAL_ATTRIBUTES_PATTERN.matcher(firstLine); if (matcher.find()) { String s; Matcher attributeMatcher; s = matcher.group(2); attributeMatcher = ADDITIONAL_ATTRIBUTE_PATTERN.matcher(s); while (attributeMatcher.find()) { String key; String value; key = attributeMatcher.group(1); value = attributeMatcher.group(2); attributes.put(key.toLowerCase(Locale.ENGLISH), value); } } return attributes; }
public void run() { Scanner in = new Scanner(System.in); while (true) { String msg; try { msg = in.nextLine().trim(); Pattern p = Pattern.compile("^@(\\w+)\\s+(.+)"); Matcher m = p.matcher(msg); if (msg.equals("quit")) { this.server.disconnect(this); in.close(); System.exit(0); } else if (msg.equals("list")) { this.server.list(this); } else if (m.find()) { String receiverName = m.group(1); BaseClient receiver = server.lookup(receiverName); if (receiver != null) { receiver.receive(this.name, "<private> %s".format(m.group(2))); } else { this.server.broadcast(this.name, m.group(2)); } } else { this.server.broadcast(this.name, msg); } } catch (Exception e) { e.printStackTrace(); } } }
private SlimTestResult doRange(Matcher matcher) { boolean closedLeft = matcher.group(2).equals("="); boolean closedRight = matcher.group(3).equals("="); boolean pass = (arg1 < v && v < arg2) || (closedLeft && arg1 == v) || (closedRight && arg2 == v); return rangeMessage(pass); }
private String urlEncodeQueryParams(String url) { final StringBuilder sb = new StringBuilder((int) (url.length() * 1.2)); final int pos = url.indexOf('?'); if (pos > 0) { // split url into base and query expression final String queryExpr = url.substring(pos + 1); LOG.trace("queryExpr {}", queryExpr); final Pattern p = Pattern.compile( "\\G([A-Za-z0-9-_]+)=([A-Za-z0-9-+:#|^\\.,<>;%*\\(\\)_/\\[\\]\\{\\}\\\\ ]+)[&]?"); final Matcher m = p.matcher(queryExpr); while (m.find()) { LOG.trace("group 1: {} group 2: {}", m.group(1), m.group(2)); if (sb.length() > 0) { sb.append("&"); } sb.append(m.group(1)); sb.append("="); try { // URL Encode the value of each query parameter sb.append(URLEncoder.encode(m.group(2), "UTF-8")); } catch (UnsupportedEncodingException e) { // Ignore - We know UTF-8 is supported } } LOG.trace("new query Expr: {}", sb.toString()); sb.insert(0, url.substring(0, pos + 1)); } return sb.toString(); }
public void parseStatusXml(String statusXml) { try { Document statusDoc = SubmissionUtils.emptyDocument(); SubmissionUtils.transform(new StringReader(statusXml), statusDoc); if (statusDoc.getDocumentElement().getTagName().equals("error")) { String runName = statusDoc.getElementsByTagName("RunName").item(0).getTextContent(); String runDirRegex = "(\\d{6})_([A-z0-9]+)_(\\d+)_[A-z0-9_]*"; Matcher m = Pattern.compile(runDirRegex).matcher(runName); if (m.matches()) { setStartDate(new SimpleDateFormat("yyMMdd").parse(m.group(1))); setInstrumentName(m.group(2)); } setRunName(runName); setHealth(HealthType.Unknown); } else { String runStarted = statusDoc.getElementsByTagName("RunStarted").item(0).getTextContent(); setStartDate(new SimpleDateFormat("EEEE, MMMMM dd, yyyy h:mm aaa").parse(runStarted)); setInstrumentName( statusDoc.getElementsByTagName("InstrumentName").item(0).getTextContent()); setRunName(statusDoc.getElementsByTagName("RunName").item(0).getTextContent()); setHealth(HealthType.Unknown); } setXml(statusXml); } catch (ParserConfigurationException e) { e.printStackTrace(); } catch (TransformerException e) { e.printStackTrace(); } catch (ParseException e) { e.printStackTrace(); } }
@Override public void output(int id, String line) { // general check if line contains file if (line.contains(fileName)) { // try to match line exactly try { Matcher permissionMatcher = permissionPattern.matcher(line); if (permissionMatcher.find()) { permissions = convertPermissions(permissionMatcher.group(1)); Log.d(RootCommands.TAG, "Found permissions: " + permissions); } else { Log.d(RootCommands.TAG, "Permissions were not found in ls command!"); } // try to parse for symlink Matcher symlinkMatcher = symlinkPattern.matcher(line); if (symlinkMatcher.find()) { /* * TODO: If symlink points to a file in the same directory the path is not * absolute!!! */ symlink = symlinkMatcher.group(1); Log.d(RootCommands.TAG, "Symlink found: " + symlink); } else { Log.d(RootCommands.TAG, "No symlink found!"); } } catch (Exception e) { Log.e(RootCommands.TAG, "Error with regex!", e); } } }
private String blankSectionHeaders(String markup, StringBuffer context) { Pattern p = Pattern.compile("(={2,})([^=]+)\\1"); Matcher m = p.matcher(markup); int lastPos = 0; StringBuilder sb = new StringBuilder(); while (m.find()) { sb.append(markup.substring(lastPos, m.start())); sb.append(getSpaceString(m.group().length())); String title = m.group(2).trim(); if (!title.equalsIgnoreCase("see also") && !title.equalsIgnoreCase("external links") && !title.equalsIgnoreCase("references") && !title.equalsIgnoreCase("further reading")) context.append("\n").append(title); lastPos = m.end(); } sb.append(markup.substring(lastPos)); return sb.toString(); }
protected void addFieldLinks() { log.info("addFieldLinks()"); final Map<String, ZNode> nodeMap = new HashMap<String, ZNode>(); final Pattern patt = Pattern.compile("(private |protected |public |final |static )+\\s*(\\w+)"); // TODO redo this to actually include packages for (ZNode node : selectedNode.getSubmodules()) { if (node.getNodeType() == ZNodeType.CLASS) { nodeMap.put(node.getName(), node); } } log.info("nodeMap={}", nodeMap); for (ZNode node : selectedNode.getSubmodules()) { for (String line : node.getCodeLines()) { final Matcher matcher = patt.matcher(line); if (matcher.find()) { log.info("group2={}", matcher.group(2)); if (nodeMap.containsKey(matcher.group(2))) { links.add(new ZNodeLink(node, nodeMap.get(matcher.group(2)), LinkType.HAS_A)); } } } } // just add 1 so there's at least 1 links.add(new ZNodeLink(selectedNode, selectedNode, LinkType.HAS_A)); }
// Chamando Robot public static void robot() throws Exception { Database db = new Database(); db.connect(); ResultSet rs = Page.findAll(db); Page p = null; while ((p = Page.next(rs)) != null) { String body = Robot.get(p.getUrl()); // procurar por urls dentro do body // buscar por essas paginas // String expr = "href=\"([^\"]*)"; String ereg = "href=\"https{0,1}:\\/\\/([^\"]*)\""; Pattern pt = Pattern.compile(ereg); Matcher m = pt.matcher(body); while (m.find()) { System.out.println(m.group()); String[] _url = m.group().split("\""); Page.newUrl(_url[1]); } p.setBody(body); p.update(); } db.close(); }
/** * Checks a prospective crontab specification to see if it could benefit from balanced hashes. * * @param spec a (legal) spec * @return a similar spec that uses a hash, if such a transformation is necessary; null if it is * OK as is * @since 1.510 */ public static @CheckForNull String hashify(String spec) { if (spec.contains("H")) { // if someone is already using H, presumably he knows what it is, so a warning is likely false // positive return null; } else if (spec.startsWith("*/")) { // "*/15 ...." (every N minutes) to hash return "H" + spec.substring(1); } else if (spec.matches("\\d+ .+")) { // "0 ..." (certain minute) to hash return "H " + spec.substring(spec.indexOf(' ') + 1); } else { Matcher m = Pattern.compile("0(,(\\d+)(,\\d+)*)( .+)").matcher(spec); if (m.matches()) { // 0,15,30,45 to H/15 int period = Integer.parseInt(m.group(2)); if (period > 0) { StringBuilder b = new StringBuilder(); for (int i = period; i < 60; i += period) { b.append(',').append(i); } if (b.toString().equals(m.group(1))) { return "H/" + period + m.group(4); } } } return null; } }
@Override public List<String> getCphNameList(boolean toLowerCase) { Pattern pattern = Pattern.compile("ui:insert\\s*name=[\"'](.*?)[\"']"); Set<String> matches = new HashSet<String>(); Matcher m = pattern.matcher(head); while (m.find()) { String match = m.group(1); if (!match.startsWith("_")) { matches.add(m.group(1)); } } m = pattern.matcher(body); while (m.find()) { String match = m.group(1); if (!match.startsWith("_")) { matches.add(m.group(1)); } } List<String> cphNameList = new ArrayList<String>(matches); if (toLowerCase) { for (int i = 0, n = cphNameList.size(); i < n; i++) { cphNameList.set(i, cphNameList.get(i).toLowerCase()); } } return cphNameList; }
private Dependency toDependency(String id, String version, String type) throws ResolveException { Matcher matcher = PARSER_ID.matcher(id); if (!matcher.matches()) { throw new ResolveException( "Bad id " + id + ", expected format is <groupId>:<artifactId>[:<classifier>]"); } Dependency dependency = new Dependency(); dependency.setGroupId(matcher.group(1)); dependency.setArtifactId(matcher.group(2)); if (matcher.group(4) != null) { dependency.setClassifier(StringUtils.defaultString(matcher.group(4), "")); } if (version != null) { dependency.setVersion(version); } if (type != null) { dependency.setType(type); } return dependency; }
public static int calculateVersion(String version) { if (null == version) { return UNKNOWN_HAZELCAST_VERSION; } Matcher matcher = VERSION_PATTERN.matcher(version); if (matcher.matches()) { try { int calculatedVersion = MAJOR_VERSION_MULTIPLIER * Integer.parseInt(matcher.group(1)) + MINOR_VERSION_MULTIPLIER * Integer.parseInt(matcher.group(2)); int groupCount = matcher.groupCount(); if (groupCount >= PATCH_GROUP_COUNT) { String patchVersionString = matcher.group(PATCH_GROUP_COUNT); if (null != patchVersionString && !patchVersionString.startsWith("-")) { calculatedVersion += Integer.parseInt(patchVersionString); } } return calculatedVersion; } catch (Exception e) { Logger.getLogger(BuildInfo.class) .warning("Failed to calculate version using version string " + version, e); } } return UNKNOWN_HAZELCAST_VERSION; }
/** * Returns the browser given by the specified browser string * * @param browser a browser string like "*firefox" * @param sessionId the sessionId to launch * @param queue * @return the BrowserLauncher ready to launch */ public BrowserLauncher getBrowserLauncher(String browser, String sessionId, SeleneseQueue queue) { if (browser == null) throw new IllegalArgumentException("browser may not be null"); for (Iterator iterator = supportedBrowsers.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry entry = (Map.Entry) iterator.next(); String name = (String) entry.getKey(); Class c = (Class) entry.getValue(); Pattern pat = Pattern.compile("^\\*" + name + "( .*)?$"); Matcher mat = pat.matcher(browser); if (mat.find()) { String browserStartCommand; if (browser.equals("*" + name)) { browserStartCommand = null; } else { browserStartCommand = mat.group(1).substring(1); } return createBrowserLauncher(c, browserStartCommand, sessionId, queue); } } Matcher CustomMatcher = CUSTOM_PATTERN.matcher(browser); if (CustomMatcher.find()) { String browserStartCommand = CustomMatcher.group(1).substring(1); return new DestroyableRuntimeExecutingBrowserLauncher(browserStartCommand, sessionId); } throw browserNotSupported(browser); }
/** * Parse a (possibly) indexed path segment out of a string. Make sure no path delimiters appear in * the string, as this would not be an individual path segment. * * @param string a string to parse. * @return an PathSegment object. * @throws PathSegmentSyntaxException if invalid index value or key segment delimiter appears in * the input string. */ public static PathSegment parse(String string) throws PathSegmentSyntaxException { if (string == null || string.trim().isEmpty()) return null; string = string.trim(); if (string.contains(PATH_SEPARATOR)) throw new PathSegmentSyntaxException("Path segment parsing error."); Matcher matcher = INDEX_PATTERN.matcher(string); if (!matcher.find()) return new PathSegment(string, null); // Not an indexed key String name = matcher.group(1); String indexStr = matcher.group(2); int index; try { index = Integer.parseInt(indexStr); } catch (NumberFormatException e) { // Should never happen as the regex only matches integers in this group throw new PathSegmentSyntaxException("Only integer key indices are allowed"); } return new PathSegment(name, index); }
private SlimTestResult evaluateCustomComparatorIfPresent() { SlimTestResult message = null; if (customComparatorRegistry == null) { return null; } Matcher customComparatorMatcher = customComparatorPattern.matcher(expression); if (customComparatorMatcher.matches()) { String prefix = customComparatorMatcher.group(1); CustomComparator customComparator = customComparatorRegistry.getCustomComparatorForPrefix(prefix); if (customComparator != null) { String expectedString = customComparatorMatcher.group(2); try { if (customComparator.matches(actual, expectedString)) { message = SlimTestResult.pass(expectedString + " matches " + actual); } else { message = SlimTestResult.fail(expectedString + " doesn't match " + actual); } } catch (Exception e) { message = SlimTestResult.fail( expectedString + " doesn't match " + actual + ":\n" + e.getMessage()); } } } return message; }
/** {@inheritDoc} */ @Override protected SCMRevision retrieve(String unparsedRevision, TaskListener listener) throws IOException, InterruptedException { try { listener.getLogger().println("Opening connection to " + remoteBase); SVNURL repoURL = SVNURL.parseURIEncoded(remoteBase); SVNRepositoryView repository = openSession(repoURL); String repoPath = SubversionSCM.DescriptorImpl.getRelativePath(repoURL, repository.getRepository()); String base; long revision; Matcher pathAtRev = Pattern.compile("(.+)@(\\d+)").matcher(unparsedRevision); if (pathAtRev.matches()) { base = pathAtRev.group(1); revision = Long.parseLong(pathAtRev.group(2)); } else { base = unparsedRevision; revision = -1; } String path = SVNPathUtil.append(repoPath, base); long resolvedRevision = repository.getNode(path, -1).getRevision(); if (resolvedRevision == -1) { listener.getLogger().println("Could not find " + path); return null; } return new SCMRevisionImpl(new SCMHead(base), revision == -1 ? resolvedRevision : revision); } catch (SVNException e) { throw new IOException(e); } }
@Override public Talk convertLineToTalk(String line) { if (line == null || line.isEmpty()) { throw new IllegalArgumentException("line must not be null or empty"); } line = line.replaceAll("\\s+", " ").trim(); Pattern pattern = Pattern.compile("(.*)(\\s){1}([0-2]?[0-9]?[0-9]{1}min|lightning)\\b"); Matcher matcher = pattern.matcher(line); if (!matcher.matches()) { LOG.log(Level.SEVERE, "Line [{0}] is not recognised by the converter", line); throw new ProposalConverterException(); } final String title = matcher.group(1); final String duration = matcher.group(3); int durationMinutes = 0; if (duration.equals(IProposalLineConverter.LIGHTNING_TEXT)) { durationMinutes = IProposalLineConverter.LIGHTNING_DURATION; } else { try { durationMinutes = Integer.parseInt(duration.substring(0, duration.indexOf(MINUTE_SUFFIX))); } catch (NumberFormatException e) { LOG.log(Level.SEVERE, "NumberFormatException while parsing minutes into Integer", e); throw new ProposalConverterException(); } } return new Talk(title, durationMinutes); }