protected final String stripcomments() { String s; String p; Pattern S; Matcher m; s = this.text; if (this.cs != null) { p = String.format("(?m)^[ \\t\\f]*%s.*(\\r|\\r\\n|\\n|\\z)", Pattern.quote(this.cs)); S = makeregex(p); m = S.matcher(this.text); s = m.replaceAll(""); } if (this.ics != null) { // A naive approach to handle ';' as the begin of a comment. Test // '\;' and '\\;' .. // Step 1: remove all unescaped inline comments till \eol p = String.format("(?m)([^\\\\])%s.*$", Pattern.quote(this.ics)); S = makeregex(p); m = S.matcher(s); s = m.replaceAll("$1"); // Step 2: handle escaped inline comment sequence, i.e. turn // '\;' into ';'. Ignore on purpose any escape sequence before // this escaped sequence. p = String.format("(?m)\\\\(%s.*)$", Pattern.quote(this.ics)); S = makeregex(p); m = S.matcher(s); s = m.replaceAll("$1"); } return s; }
public static String getDomain(String address) { String domain; String[] protos = address.split(Pattern.quote(ADDR_PROT_INTERN_SEP)); if (protos.length > 1) domain = protos[1]; else domain = protos[0]; return domain.split(Pattern.quote(ADDR_PART_SEP))[0].trim(); }
public static String getViewPathsRegexp(String[] loadRules, boolean isUnix) { // Note - the logic here to do ORing to match against *any* of the load rules is, quite frankly, // hackishly ugly. I'm embarassed by it. But it's what I've got for right now. String filterRegexp = ""; if (loadRules != null) { String tempFilterRules = ""; for (String loadRule : loadRules) { if (StringUtils.isNotEmpty(loadRule)) { if (loadRule.endsWith("/") || loadRule.endsWith("\\")) { loadRule = loadRule.substring(0, loadRule.length() - 1); } loadRule = PathUtil.convertPathForOS(loadRule, isUnix); tempFilterRules += "|" + Pattern.quote(loadRule + PathUtil.fileSepForOS(isUnix)); tempFilterRules += "|" + Pattern.quote(loadRule) + "$"; } } // Adding tweak for ignoring leading slashes or Windows drives in case of strange situations // using setview. if (StringUtils.isNotEmpty(tempFilterRules)) { filterRegexp = tempFilterRules.substring(1); } } return filterRegexp; }
// TODO: Check processing order public int compareTo(DataRecord otherRecord) { String[] orIDcomponents = otherRecord.getIDRecord().split(Pattern.quote(DataRecord.getIDSeperator())); String[] myIDcomponents = this.IDRecord.split(Pattern.quote(DataRecord.getIDSeperator())); // String orID = otherRecord.getIDRecord().split( "\\$" )[0]; // String myID = this.IDRecord.split( "\\$" )[0]; String orID = orIDcomponents[0]; String myID = myIDcomponents[0]; int compareVal = myID.compareTo(orID); if (compareVal == 0 && orIDcomponents.length > 1 && myIDcomponents.length > 1) { // Compare the sub-ids return this.IDRecord.compareTo(otherRecord.getIDRecord()); } // Check if we compare against the main entry here /*else if( compareVal == 0 ) { if( myIDcomponents.length > 1 ) { return 1; } else { return -1; } }*/ return compareVal; // return myID.compareTo(orID); // return this.IDRecord.compareTo( otherRecord.getIDRecord() ); }
public static ArrayList<Address> getAddress(String addresses) { // boolean DEBUG = true; if (D_Peer.DEBUG) System.out.println("PeerAddress:getAddress: parsing addresses " + addresses); String[] addresses_l = Address.split(addresses); // may have to control addresses, to defend from DOS based on false addresses ArrayList<Address> address = new ArrayList<Address>(addresses_l.length); for (int k = 0; k < addresses_l.length; k++) { if (D_Peer.DEBUG) System.out.println("PeerAddress:getAddress: parsing address " + addresses_l[k]); Address a = new Address(); String taddr[] = addresses_l[k].split(Pattern.quote(Address.ADDR_PROT_NET_SEP), COMPONENTS); if (taddr.length < 2) continue; a.pure_protocol = taddr[0]; String adr = taddr[1]; if (adr == null) { address.add(a); continue; } String pri[] = adr.split(Pattern.quote(Address.PRI_SEP)); a.address = pri[0]; if (pri.length > 1) { a.certified = true; try { a.priority = Integer.parseInt(pri[1]); } catch (Exception e) { e.printStackTrace(); } } address.add(a); if (D_Peer.DEBUG) System.out.println("PeerAddress:getAddress: got typed address " + a); } return address; }
@Override public IPathParameter resolvePathParameter(IContainer item) { IPathParameter result = null; String[] groupParts = item.getName().split(Pattern.quote(mPathSeparator)); String[] pathParts = mPath.getValue().split(Pattern.quote(mPathSeparator)); String part, param, buff; // Parse the path for (int depth = 0; depth < groupParts.length; depth++) { if (depth < pathParts.length) { part = groupParts[depth]; param = pathParts[depth]; // If a parameter is defined if (param.matches(".*(" + mPath.PARAM_PATTERN + ")+.*")) { // Try to determine the parameter result buff = param.replaceFirst("^(.*)(" + mPath.PARAM_PATTERN + ".*)$", "$1"); part = part.substring(buff.length()); buff = param.replaceAll(".*" + mPath.PARAM_PATTERN, ""); part = part.replaceFirst(Pattern.quote(buff), ""); buff = param.replaceAll(".*" + mPath.PARAM_PATTERN + ".*", "$1"); result = new PathParameter( Factory.getFactory(getFactoryName()), ParameterType.SUBSTITUTION, buff, part); break; } } } return result; }
public static String escapeSpecialRegexCharacters(final String toEscape) { return toEscape .replaceAll(Pattern.quote("{"), "\\\\{") .replaceAll(Pattern.quote("}"), "\\\\}") .replaceAll(Pattern.quote("["), "\\\\[") .replaceAll(Pattern.quote("]"), "\\\\]"); }
/** * see: <code> * org.apache.karaf.management.KarafMBeanServerGuard#getGeneralPid(java.util.List, java.lang.String) * </code> * * <p>Given a list of all available configadmin PIDs that define RBAC information, return a real * PID that'll be used to fetch information about particular, non wildcard <code>pid</code>. * * <p>Here, the PID returned may use wildcards ("_"), which means that general PID will be used to * check particular <code>pid</code> (one of possible PIDs derived from {@link ObjectName}) * * @param allJmxAclPids * @param pid one of the PIDs returned from {@link #iterateDownPids(List)} * @return */ private static String getGeneralPid(List<String> allJmxAclPids, String pid) { String[] pidStrArray = pid.split(Pattern.quote(".")); Set<String[]> rets = new TreeSet<>(WILDCARD_PID_COMPARATOR); for (String id : allJmxAclPids) { String[] idStrArray = id.split(Pattern.quote(".")); if (idStrArray.length == pidStrArray.length) { boolean match = true; for (int i = 0; i < idStrArray.length; i++) { if (!(idStrArray[i].equals(JMX_OBJECTNAME_PROPERTY_WILDCARD) || idStrArray[i].equals(pidStrArray[i]))) { match = false; break; } } if (match) { rets.add(idStrArray); } } } Iterator<String[]> it = rets.iterator(); if (!it.hasNext()) { return ""; } else { StringBuilder buffer = new StringBuilder(); for (String segment : it.next()) { if (buffer.length() > 0) { buffer.append("."); } buffer.append(segment); } return buffer.toString(); } }
public static String obfuscate(String email) { LinkedList<String> emailList = new LinkedList<>(); // Attack the dots String[] chunks = email.split(Pattern.quote(".")); String[] atChunks = null; int dotCounter = chunks.length - 1; for (int i = 0; i < chunks.length; i++) { emailList.addLast(chunks[i]); if (dotCounter != 0) { emailList.addLast("[.]"); dotCounter--; } } // Attack the @ for (int j = 0; j < emailList.size(); j++) { if (emailList.get(j).contains("@")) { atChunks = emailList.get(j).split(Pattern.quote("@")); emailList.remove(j); emailList.add(j, atChunks[0]); emailList.add(j + 1, "[at]"); emailList.add(j + 2, atChunks[1]); } } System.out.println(toString(emailList)); return toString(emailList); }
private void updateFilter() { DefaultRowSorter<TableModel, Object> sorter = (DefaultRowSorter<TableModel, Object>) otherTable.getRowSorter(); String key = keyFilter.getSelectedItem().toString(); RowFilter<TableModel, Object> filter = null; if (!key.isEmpty()) { Object method = keyFilterMethod.getSelectedItem(); if (method == STARTS_WITH) { filter = RowFilter.regexFilter('^' + Pattern.quote(key), UITableModel.KEY_COLUMN_INDEX); } else if (method == ENDS_WITH) { filter = RowFilter.regexFilter(Pattern.quote(key) + '$', UITableModel.KEY_COLUMN_INDEX); } else if (method == CONTAINS) { filter = RowFilter.regexFilter(Pattern.quote(key), UITableModel.KEY_COLUMN_INDEX); } else { filter = RowFilter.regexFilter(key, UITableModel.KEY_COLUMN_INDEX); } } String type = typeFilter.getSelectedItem().toString(); if (!type.isEmpty()) { RowFilter<TableModel, Object> typeFilter = RowFilter.regexFilter('^' + type + '$', UITableModel.TYPE_COLUMN_INDEX); filter = filter == null ? typeFilter : RowFilter.<TableModel, Object>andFilter(Arrays.asList(filter, typeFilter)); } sorter.setRowFilter(filter); }
public void testRun() { // Wait for activity: 'com.fitbit.onboarding.landing.LandingActivity_' solo.waitForActivity("LandingActivity_", 500); // Wait for activity: 'com.fitbit.home.ui.HomeActivity_' assertTrue("HomeActivity_ is not found!", solo.waitForActivity("HomeActivity_")); solo.sleep(500); solo.clickOnView(solo.getView("tile_content", 1)); // Wait for activity: 'com.fitbit.runtrack.ui.ExerciseListActivity' assertTrue("ExerciseListActivity is not found!", solo.waitForActivity("ExerciseListActivity")); // sleep for x seconds solo.sleep(500); // Click on Empty Text View solo.clickOnView(solo.getView("new_exercise")); // Wait for activity: 'com.fitbit.runtrack.ui.RecordExerciseActivity' assertTrue( "RecordExerciseActivity is not found!", solo.waitForActivity("RecordExerciseActivity")); // sleep for x seconds solo.sleep(500); solo.clickOnText(java.util.regex.Pattern.quote("Log Previous")); solo.enterText(0, "yoga"); solo.clickOnText(java.util.regex.Pattern.quote("Yoga")); solo.clickOnText(java.util.regex.Pattern.quote("30:00")); solo.setTimePicker(0, 23, 59); solo.clickOnView(solo.getView(android.R.id.button1)); solo.clickOnView(solo.getView("confirm")); solo.clickOnView(solo.getView(android.R.id.button1)); }
private CoreObject xGeneralReplace(CoreCall cc, boolean escapeRx) throws InterpreterException { String resultString = getCurrentObject(cc).value.toString(); Iterator<String> i = cc.members.keySet().iterator(); while (i.hasNext()) { String replaceFind = i.next(); String replaceWith = cc.members.get(replaceFind).toString(); replaceFind = replaceFind.substring(1); if (escapeRx) replaceFind = Pattern.quote(replaceFind); resultString = resultString.replaceAll(replaceFind, replaceWith); } if (cc.argCount > 0) { for (int idx = 0; idx < cc.argCount; idx++) { CoreObject rObj = cc.argPop(); if (rObj.getClass() == CoreMap.class) { CoreMap map = (CoreMap) rObj; Iterator<String> mi = map.items.keySet().iterator(); while (mi.hasNext()) { String replaceFind = mi.next(); String replaceWith = map.items.get(replaceFind).toString(); if (escapeRx) replaceFind = Pattern.quote(replaceFind); resultString = resultString.replaceAll(replaceFind, replaceWith); } } else { String replaceFind = rObj.toString(); resultString = resultString.replaceAll(replaceFind, ""); } } } return new CoreString(resultString); }
/** * Matches a version object to versions in a set by comparing the non build number portion of the * string. Then find which of the matching versions has the highest build number and is therefore * the latest version. * * @param version the Version object to use. * @param versionSet a collection of versions to compare to. * @return the highest build number, or 0 if no matching build numbers are found. */ public int findHighestMatchingBuildNumber(Version version, Set<String> versionSet) { int highestBuildNum = 0; // Build version pattern regex, matches something like "<mmm>.<qualifier>.<buildnum>". StringBuffer versionPatternBuf = new StringBuffer(); versionPatternBuf.append("("); versionPatternBuf.append(Pattern.quote(getOriginalMMM())); versionPatternBuf.append( "(" + DELIMITER_REGEX + "0)*"); // Match zeros appended to a major only version versionPatternBuf.append(")?"); versionPatternBuf.append(DELIMITER_REGEX); if (version.getQualifierBase() != null) { versionPatternBuf.append(Pattern.quote(version.getQualifierBase())); versionPatternBuf.append(DELIMITER_REGEX); } versionPatternBuf.append("(\\d+)"); String candidatePatternStr = versionPatternBuf.toString(); logger.debug( "Using pattern: '{}' to find compatible versions from metadata.", candidatePatternStr); final Pattern candidateSuffixPattern = Pattern.compile(candidatePatternStr); for (final String compareVersion : versionSet) { final Matcher candidateSuffixMatcher = candidateSuffixPattern.matcher(compareVersion); if (candidateSuffixMatcher.matches()) { String buildNumberStr = candidateSuffixMatcher.group(3); int compareBuildNum = Integer.parseInt(buildNumberStr); if (compareBuildNum > highestBuildNum) { highestBuildNum = compareBuildNum; } } } return highestBuildNum; }
// <timestamp>2015-08-05T00:44:14Z</timestamp> public void extractTimestamp() { String ref = "<timestamp>"; Pattern p = Pattern.compile(Pattern.quote(ref) + "(.*?)" + Pattern.quote("</timestamp>")); Matcher m = p.matcher(raw); while (m.find()) { String timestamp = m.group(1); if (StringUtils.isNotBlank(timestamp)) { Calendar cal = Calendar.getInstance(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US); try { cal.setTime(sdf.parse(timestamp)); // Date articleDate = cal.getTime(); Calendar c = new GregorianCalendar(); c.set(Calendar.HOUR_OF_DAY, 0); // anything 0 - 23 c.set(Calendar.MINUTE, 0); c.set(Calendar.SECOND, 0); daysSinceRevision = daysBetween(c, cal); } catch (ParseException e) { System.out.println( "While extracting timestamp " + e.getMessage() + " for article " + articleTitle); } } else { System.out.println("No timestamp found for article " + articleTitle); } } }
public void extractRefsWithoutCites() { String ref = "<ref>"; String endref = "</ref>"; Pattern p = Pattern.compile(Pattern.quote(ref) + "(.*?)" + Pattern.quote(endref)); Matcher m = p.matcher(raw); while (m.find()) { String token = m.group(0); if (token != null && token.contains("{{citation") == false && token.contains("{{cite") == false && token.contains("{{harv") == false && token.contains("{{harvt") == false && token.contains("{{sfn|") == false && token.contains("{{sfnm|") == false && token.contains("{{wikicite|") == false && token.contains("{{Citation") == false && token.contains("{{Cite") == false && token.contains("{{Harv") == false && token.contains("{{Harvt") == false && token.contains("{{Sfn|") == false && token.contains("{{Sfnm|") == false && token.contains("{{Wikicite|") == false) { refs.add(token); } } }
public static int add(String s) { if (s.isEmpty()) return 0; if (s.contains("//")) { String regex = "//(.)\n(.*)"; Matcher m = Pattern.compile(regex).matcher(s); if (m.find()) { String fistSubStringComponent = m.group(1); String secondSubStringComponent = m.group(2); String[] listNumbers = secondSubStringComponent.split(Pattern.quote(fistSubStringComponent)); return computeSumFromListOfStringNumbers(listNumbers); } else { String regex2 = "//\\[(.*)\\]\n(.*)"; Matcher m2 = Pattern.compile(regex2).matcher(s); if (m2.find()) { String firstSubStringComponent = m2.group(1); String secondSubStringComponent = m2.group(2); String[] listNumbers = secondSubStringComponent.split(Pattern.quote(firstSubStringComponent)); return computeSumFromListOfStringNumbers(listNumbers); } } return -1; } else { return computeSumFromListOfStringNumbers(s.split("[,\n]")); } }
public static java.util.List<TileSourceTemplate> getUserDefinedTemplates(File tilesDir) { java.util.List<TileSourceTemplate> ts = new ArrayList<TileSourceTemplate>(); if (tilesDir != null) { File[] listFiles = tilesDir.listFiles(); if (listFiles != null) { for (File f : listFiles) { File ch = new File(f, "url"); // $NON-NLS-1$ if (f.isDirectory() && ch.exists()) { try { BufferedReader read = new BufferedReader( new InputStreamReader(new FileInputStream(ch), "UTF-8")); // $NON-NLS-1$ String url = read.readLine(); read.close(); if (!Algoritms.isEmpty(url)) { url = url.replaceAll(Pattern.quote("{$x}"), "{1}"); // $NON-NLS-1$ //$NON-NLS-2$ url = url.replaceAll(Pattern.quote("{$z}"), "{0}"); // $NON-NLS-1$//$NON-NLS-2$ url = url.replaceAll(Pattern.quote("{$y}"), "{2}"); // $NON-NLS-1$ //$NON-NLS-2$ TileSourceTemplate t = new TileSourceTemplate( f.getName(), url, ".jpg", 18, 1, 256, 16, 20000); // $NON-NLS-1$ ts.add(t); } } catch (IOException e) { log.info("Mailformed dir " + f.getName(), e); // $NON-NLS-1$ } } } } } return ts; }
/** * [<PROT>://]domain:...:...:<name>[:<active_int_boolean>:...] * * @param address * @return */ public static String getName(String address) { String domain; String[] protos = address.split(Pattern.quote(ADDR_PROT_INTERN_SEP)); if (protos.length > 1) domain = protos[1]; else domain = protos[0]; String[] ports = domain.split(Pattern.quote(ADDR_PART_SEP)); if (ports.length < 4) return null; return ports[3]; }
@Override public String toString() { String packageName = AbstractEntity.class.getCanonicalName(); packageName = packageName.replaceFirst(Pattern.quote(".AbstractEntity"), ""); String className = (this.getClass().getInterfaces()[0]).getCanonicalName(); className = className.replaceFirst(Pattern.quote(packageName + "."), ""); return className + "{" + "value=" + value + '}'; }
private Pattern makePattern(String startComment, String endComment) { return Pattern.compile( "^(" + Pattern.quote(startComment) + ".*?" + Pattern.quote(endComment) + "[\r\n ]*)" + "(.*)$", Pattern.DOTALL); }
public void testRun() { // Wait for activity: 'com.fitbit.onboarding.landing.LandingActivity_' solo.waitForActivity("LandingActivity_", 2000); // Wait for activity: 'com.fitbit.home.ui.HomeActivity_' assertTrue("HomeActivity_ is not found!", solo.waitForActivity("HomeActivity_")); // sleep - shot solo.sleep(500); // Click on -- bpm 64 bpm resting solo.clickInList(3, 0); // Wait for activity: 'com.fitbit.heartrate.landing.HeartRateLandingActivity' assertTrue( "HeartRateLandingActivity is not found!", solo.waitForActivity("HeartRateLandingActivity")); // sleep - shot solo.sleep(500); // Scroll View to the right side solo.scrollViewToSide(solo.getView(android.view.ViewGroup.class, 19), Solo.RIGHT); // sleep - shot solo.sleep(500); solo.clickOnText(java.util.regex.Pattern.quote("Minutes in")); // Wait for activity: 'com.fitbit.heartrate.charts.ExerciseHeartRateChartActivity_' assertTrue( "ExerciseHeartRateChartActivity is not found!", solo.waitForActivity("ExerciseHeartRateChartActivity")); // Rotate the screen solo.setActivityOrientation(Solo.LANDSCAPE); // Click on 1 WEEK solo.clickOnText(java.util.regex.Pattern.quote("1 WEEK")); // solo.clickOnText(java.util.regex.Pattern.quote("TIME IN HEART RATE ZONES")); solo.clickOnText(java.util.regex.Pattern.quote("Fat Burn")); solo.clickOnText(java.util.regex.Pattern.quote("Cardio")); solo.clickOnText(java.util.regex.Pattern.quote("Peak")); solo.scrollToSide(Solo.LEFT); solo.scrollToSide(Solo.LEFT); solo.scrollToSide(Solo.LEFT); solo.scrollToSide(Solo.LEFT); solo.scrollToSide(Solo.RIGHT); solo.scrollToSide(Solo.RIGHT); solo.scrollToSide(Solo.RIGHT); solo.scrollToSide(Solo.LEFT); solo.scrollToSide(Solo.RIGHT); solo.sleep(500); solo.goBack(); }
void setTags(String start, String stop) { if (start.equals(UNESCAPED_START) || stop.equals(UNESCAPED_STOP)) { throw new IllegalArgumentException("Normal tags cannot override escape tags"); } this.unquotedStart = start; this.precede = start.length() > UNESCAPED_START.length(); this.start = Pattern.quote(start); this.stop = Pattern.quote(stop); }
@Override public void performAction(SiteNode sn) throws Exception { Session session = Model.getSingleton().getSession(); String url = new URI(sn.getHierarchicNodeName(), false).toString(); if (sn.isLeaf()) { url = Pattern.quote(url); } else { url = Pattern.quote(url + "/") + ".*"; } session.getExcludeFromSpiderRegexs().add(url); }
@Inject public HFRUrlParser(MDEndpoints mdEndpoints, CategoriesStore categoriesStore) { this.mdEndpoints = mdEndpoints; this.categoriesStore = categoriesStore; String baseRewrittenRegex = "(?:" + Pattern.quote(mdEndpoints.baseurl() + "/hfr/") + ")"; baseRewrittenUrlRegex = Pattern.quote(mdEndpoints.baseurl()) + "/hfr/.*"; baseStandardUrlRegex = Pattern.quote(mdEndpoints.baseurl()) + "/forum.*"; rewrittenTopicPattern = Pattern.compile(baseRewrittenRegex + REWRITTEN_TOPIC_REGEX); }
/** * [<PROT>://]domain:...:...:....:<active_int_boolean>[:...] * * @param address * @return */ public static boolean getActive(String address) { String domain; String[] protos = address.split(Pattern.quote(ADDR_PROT_INTERN_SEP)); if (protos.length > 1) domain = protos[1]; else domain = protos[0]; String[] ports = domain.split(Pattern.quote(ADDR_PART_SEP)); if (DEBUG) System.out.println("Address:getActive " + domain + " ports=" + Util.concat(ports, "==")); if (ports.length < 5) return true; return Util.stringInt2bool(ports[4], false); }
/** * renders wiki markup like _italic_ to XHTML see also www.radeox.org @Deprecated The wiki markup * area is no longer supported. In the legacy form infrastructure it's still there, but it won't * be available in the new flexi forms. In flexi forms use the RichTextElement instead. tested * during migration and expanded to prevent radeox failures * * @param originalText * @return result (rendered originalText) or null if originalText was null */ @Deprecated public static String formatWikiMarkup(String oldValue) { if (oldValue != null) { String newValue = ""; // oldValue = oldValue.replaceAll("<>", "<>"); // oldValue = oldValue.replaceAll(Pattern.quote("[]"), // "[]"); // prevent error with {$} interpreted as regexp String marker1 = "piYie6Eigh0phafeiTuk4dahwahvoh7eedoegee2egh8xuj9phah8eop8iuk"; oldValue = oldValue.replaceAll(Pattern.quote("{$}"), marker1); // \{code} will result in an error => convert String marker2 = "RohbaeW7xahbohk8iewoo7thocaemaech2pahS8oe1UVohkohJiugaagaeco"; oldValue = oldValue.replaceAll(Pattern.quote("\\{code}"), marker2); // radeox gets an error, if {code} is not a closed tag. prevent at // least the case with one single statement. int nrOfCodeStatements = countOccurrences(oldValue, "{code}"); String marker3 = "shagheiph6enieNo0theph9aique0EihoChae6ve2edie4Pohwaok8thaoda"; if (nrOfCodeStatements == 1) { oldValue = oldValue.replaceAll(Pattern.quote("{code}"), marker3); } if (nrOfCodeStatements % 2 != 0 && nrOfCodeStatements != 1) { Formatter fInst = Formatter.getInstance(new Locale("olat")); fInst.log( "There will be a Warning/NPE from Radeox soon, as there are not enough {code} statements in a text."); fInst.log("Old value of text will be kept! " + oldValue); } // added for compatibility with wikimedia syntax used in the new wiki component. // WikiMarkupComponent // filters " ''' " for bold and " ''''' " for bold/italic oldValue = oldValue.replaceAll( "(^|>|[\\p{Punct}\\p{Space}]+)'{3}(.*?)'{3}([\\p{Punct}\\p{Space}]+|<|$)", "$1*$2*$3"); oldValue = oldValue.replaceAll( "(^|>|[\\p{Punct}\\p{Space}]+)'{5}(.*?)'{5}([\\p{Punct}\\p{Space}]+|<|$)", "$1_*$2*_$3"); // try-catch not usable, as Radeox doesn't throw an exception, // it just prints warnings and returns unconverted value! newValue = engineWithContext.render(oldValue, baseRenderContext); // convert back newValue = newValue.replaceAll(marker1, Matcher.quoteReplacement("{$}")); newValue = newValue.replaceAll(marker2, Matcher.quoteReplacement("\\{code}")); newValue = newValue.replaceAll(marker3, Matcher.quoteReplacement("{code}")); return newValue; } else return null; }
static { REGEX_URL_1 = ImgurUserGalleryFragment.captureMinimumLength("[a-zA-Z0-9]", 4) + "\\." + Pattern.quote("imgur.com") + "(?:/.*)?"; REGEX_URL_2 = Pattern.quote("imgur.com") + "/user/" + CAPTURE_ALPHANUMERIC_REPEATING + "/?"; REGEX_URL = "(?:http://www.|https://www.|https://|http://|www.)?" + ImgurUserGalleryFragment.matchOne(REGEX_URL_1, REGEX_URL_2); BREADCRUMB_PARENT_CLASS = ImgurFragment.class; }
// Derived from http://stackoverflow.com/a/3054692/250076 public static File getRelativeFile(File targetFile, File baseFile) { try { targetFile = targetFile.getCanonicalFile(); baseFile = baseFile.getCanonicalFile(); } catch (IOException ignored) { } String pathSeparator = File.separator; String basePath = baseFile.getAbsolutePath(); String normalizedTargetPath = normalize(targetFile.getAbsolutePath(), pathSeparator); String normalizedBasePath = normalize(basePath, pathSeparator); String[] base = normalizedBasePath.split(Pattern.quote(pathSeparator)); String[] target = normalizedTargetPath.split(Pattern.quote(pathSeparator)); StringBuilder common = new StringBuilder(); int commonIndex = 0; while (commonIndex < target.length && commonIndex < base.length && target[commonIndex].equals(base[commonIndex])) { common.append(target[commonIndex]).append(pathSeparator); commonIndex++; } if (commonIndex == 0) { throw new Error( "No common path element found for '" + normalizedTargetPath + "' and '" + normalizedBasePath + '\''); } boolean baseIsFile = true; if (baseFile.exists()) { baseIsFile = baseFile.isFile(); } else if (basePath.endsWith(pathSeparator)) { baseIsFile = false; } StringBuilder relative = new StringBuilder(); if (base.length != commonIndex) { int numDirsUp = baseIsFile ? base.length - commonIndex - 1 : base.length - commonIndex; for (int i = 0; i < numDirsUp; i++) { relative.append("..").append(pathSeparator); } } relative.append(normalizedTargetPath.substring(common.length())); return new File(relative.toString()); }
public FormatValue(String par1, String... par2) { if (!isEmpty(par1) && !isEmpty(par2)) { this.name = par1; this.values = par2; for (String value : values) { String name = value.split(Pattern.quote(VAR_SEP))[0]; String val = value.split(Pattern.quote(VAR_SEP))[1]; Value fval = new Value(name, val); data_values.add(fval); } } }
private void selectProjectFiles(SWTBotTree tree, String project, String[] files) { for (SWTBotTreeItem item : tree.getAllItems()) while (item.isChecked()) item.uncheck(); for (String file : files) { String[] nodes = file.split("/|\\\\"); List<String> regex = new ArrayList<String>(nodes.length + 1); regex.add(Pattern.quote(project)); for (String node : nodes) regex.add(Pattern.quote(node)); WidgetUtil.getTreeItemWithRegex(tree, regex.toArray(new String[0])).check(); } }