public Set /*<PCNode>*/ matchClass(Pattern simple_name_pattern) {
Set this_class = matchSpecific(simple_name_pattern);
Set this_class_names = new HashSet();
Iterator tsi = this_class.iterator();
while (tsi.hasNext()) {
PCNode pc = (PCNode) tsi.next();
this_class_names.add(pc.name);
}
Iterator pi = parents.iterator();
while (pi.hasNext()) {
PCNode parent = (PCNode) pi.next();
// System.out.println("Parent: "+parent);
Set parent_class = parent.matchClass(simple_name_pattern);
Iterator osi = parent_class.iterator();
while (osi.hasNext()) {
PCNode pc = (PCNode) osi.next();
if (!this_class_names.contains(pc.name)) {
this_class.add(pc);
}
}
}
if (abc.main.Debug.v().namePatternProcessing)
System.out.println(this + ".matchClass " + simple_name_pattern.pattern() + ": " + this_class);
return this_class;
}
@org.testng.annotations.Test
public void testJSONEncoding() throws ParseException {
String json =
"{ 'str' : 'asdfasd' , 'long' : 123123123123 , 'int' : 5 , 'float' : 0.4 , 'bool' : false , 'date' : { '$date' : '2011-05-18T18:56:00Z'} , 'pat' : { '$regex' : '.*' , '$options' : ''} , 'oid' : { '$oid' : '4d83ab3ea39562db9c1ae2ae'} , 'ref' : { '$ref' : 'test.test' , '$id' : { '$oid' : '4d83ab59a39562db9c1ae2af'}} , 'code' : { '$code' : 'asdfdsa'} , 'codews' : { '$code' : 'ggggg' , '$scope' : { }} , 'ts' : { '$ts' : 1300474885 , '$inc' : 10} , 'null' : null, 'uuid' : { '$uuid' : '60f65152-6d4a-4f11-9c9b-590b575da7b5' }}";
BasicDBObject a = (BasicDBObject) JSON.parse(json);
assert (a.get("str").equals("asdfasd"));
assert (a.get("int").equals(5));
assert (a.get("long").equals(123123123123L));
assert (a.get("float").equals(0.4d));
assert (a.get("bool").equals(false));
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
format.setCalendar(new GregorianCalendar(new SimpleTimeZone(0, "GMT")));
assert (a.get("date").equals(format.parse("2011-05-18T18:56:00Z")));
Pattern pat = (Pattern) a.get("pat");
Pattern pat2 = Pattern.compile(".*", BSON.regexFlags(""));
assert (pat.pattern().equals(pat2.pattern()));
assert (pat.flags() == (pat2.flags()));
ObjectId oid = (ObjectId) a.get("oid");
assert (oid.equals(new ObjectId("4d83ab3ea39562db9c1ae2ae")));
DBRef ref = (DBRef) a.get("ref");
assert (ref.equals(new DBRef(null, "test.test", new ObjectId("4d83ab59a39562db9c1ae2af"))));
assert (a.get("code").equals(new Code("asdfdsa")));
assert (a.get("codews").equals(new CodeWScope("ggggg", new BasicBSONObject())));
assert (a.get("ts").equals(new BSONTimestamp(1300474885, 10)));
assert (a.get("uuid").equals(UUID.fromString("60f65152-6d4a-4f11-9c9b-590b575da7b5")));
String json2 = JSON.serialize(a);
BasicDBObject b = (BasicDBObject) JSON.parse(json2);
a.equals(b);
assert (a.equals(b));
}
// Note that changeReferences assumes that the number of the source/patch
// has *already been set*. If this is not true, it will simply do nothing
public void changeReferences(int oldPatchNumber) {
Specfile specfile = this.getSpecfile();
Pattern patchPattern;
if (oldPatchNumber == 0) {
patchPattern =
Pattern.compile("%patch" + oldPatchNumber + "|%patch"); // $NON-NLS-1$ //$NON-NLS-2$
} else {
patchPattern = Pattern.compile("%patch" + oldPatchNumber); // $NON-NLS-1$
}
for (int lineNumber : getLinesUsed()) {
String line;
try {
line = specfile.getLine(lineNumber);
Matcher patchMatcher = patchPattern.matcher(line);
if (!patchMatcher.find()) {
System.out.println(
Messages.getString("SpecfileSource.0") + patchPattern.pattern()); // $NON-NLS-1$
// throw new BadLocationException("can't match " + patchPattern);
}
specfile.changeLine(
lineNumber,
line.replaceAll(
patchPattern.pattern(),
Messages.getString("SpecfileSource.1") + number)); // $NON-NLS-1$
} catch (BadLocationException e) {
SpecfileLog.logError(e);
}
}
}
/**
* checks input against whitelists.
*
* @param context The context to include in exception messages
* @param input the input to check
* @param orig A origional input to include in exception messages. This is not included if it is
* the same as input.
* @return input upon a successful check
* @throws ValidationException if the check fails.
*/
private String checkWhitelist(String context, String input, String orig)
throws ValidationException {
// check whitelist patterns
for (Pattern p : whitelistPatterns) {
if (!p.matcher(input).matches()) {
throw new ValidationException(
context
+ ": Invalid input. Please conform to regex "
+ p.pattern()
+ (maxLength == Integer.MAX_VALUE ? "" : " with a maximum length of " + maxLength),
"Invalid input: context="
+ context
+ ", type("
+ getTypeName()
+ ")="
+ p.pattern()
+ ", input="
+ input
+ (NullSafe.equals(orig, input) ? "" : ", orig=" + orig),
context);
}
}
return input;
}
/**
* Cuts the path of a type name if it is from the java.lang package or from
* org.eclipse.jubula.toolkit.enums.ValueSets or leaves it as it is
*
* @param paramType the type name
* @return the shortened type name
*/
public static String beautifyParamType(String paramType) {
if (javaLang.matcher(paramType).matches()) {
return paramType.replaceAll(javaLang.pattern(), "$1"); // $NON-NLS-1$
} else if (jubulaEnum.matcher(paramType).matches()) {
return paramType.replaceAll(jubulaEnum.pattern(), "$1"); // $NON-NLS-1$
}
return paramType;
}
public void testRegexps() throws IOException {
final String PATTERN_STR = "abc:\\s?(\\d+)";
Pattern exp = Pattern.compile(PATTERN_STR);
/* Ok: easiest way is to just serialize first; problem
* is the backslash
*/
String json = MAPPER.writeValueAsString(exp);
Pattern result = MAPPER.readValue(json, Pattern.class);
assertEquals(exp.pattern(), result.pattern());
}
public SystemMeasurement(String key, String host, String type, Date date, Float measure) {
this.key = new Text(key);
this.value =
new Text(
host
+ sep.pattern()
+ type
+ sep.pattern()
+ date.getTime()
+ sep.pattern()
+ Float.toString(measure));
}
/**
* Returns true if the given string is a stop word.
*
* @param word the word to test
* @return true if the word is a stopword
*/
@Override
protected synchronized boolean is(String word) {
for (Pattern pattern : m_Patterns) {
if (pattern.matcher(word.trim().toLowerCase()).matches()) {
if (m_Debug) debug(pattern.pattern() + " --> true");
return true;
} else {
if (m_Debug) debug(pattern.pattern() + " --> false");
}
}
return false;
}
@Override
public boolean accept(final File file) {
boolean isClass = file.getName().endsWith(CLASS_EXT);
if (DEFAULT_EXCLUDE.equals(EXCLUDE_PATTERN.pattern())
&& DEFAULT_INCLUDE.equals(INCLUDE_PATTERN.pattern())) {
return isClass;
}
final String path = file.getAbsolutePath();
return isClass
&& INCLUDE_PATTERN.matcher(path).matches()
&& !EXCLUDE_PATTERN.matcher(path).matches();
}
@Override
public int hashCode() {
// Pattern uses Object.hashCode, so we have to reach
// inside to build a hashCode consistent with equals.
return Objects.hashCode(pattern.pattern(), pattern.flags());
}
@Override
public boolean isIgnored(
@NonNull Context context,
@NonNull Issue issue,
@Nullable Location location,
@NonNull String message,
@Nullable Object data) {
ensureInitialized();
String id = issue.getId();
List<String> paths = mSuppressed.get(id);
if (paths == null) {
paths = mSuppressed.get(VALUE_ALL);
}
if (paths != null && location != null) {
File file = location.getFile();
String relativePath = context.getProject().getRelativePath(file);
for (String suppressedPath : paths) {
if (suppressedPath.equals(relativePath)) {
return true;
}
// Also allow a prefix
if (relativePath.startsWith(suppressedPath)) {
return true;
}
}
}
if (mRegexps != null) {
List<Pattern> regexps = mRegexps.get(id);
if (regexps == null) {
regexps = mRegexps.get(VALUE_ALL);
}
if (regexps != null && location != null) {
File file = location.getFile();
String relativePath = context.getProject().getRelativePath(file);
boolean checkUnixPath = false;
for (Pattern regexp : regexps) {
Matcher matcher = regexp.matcher(relativePath);
if (matcher.find()) {
return true;
} else if (regexp.pattern().indexOf('/') != -1) {
checkUnixPath = true;
}
}
if (checkUnixPath && CURRENT_PLATFORM == PLATFORM_WINDOWS) {
relativePath = relativePath.replace('\\', '/');
for (Pattern regexp : regexps) {
Matcher matcher = regexp.matcher(relativePath);
if (matcher.find()) {
return true;
}
}
}
}
}
return mParent != null && mParent.isIgnored(context, issue, location, message, data);
}
/**
* Evaluates the replace function.
*
* @param val input value
* @param ctx query context
* @return function result
* @throws QueryException query exception
*/
private Item replace(final byte[] val, final QueryContext ctx) throws QueryException {
final byte[] rep = checkStr(expr[2], ctx);
for (int i = 0; i < rep.length; ++i) {
if (rep[i] == '\\') {
if (i + 1 == rep.length || rep[i + 1] != '\\' && rep[i + 1] != '$') FUNREPBS.thrw(info);
++i;
}
if (rep[i] == '$'
&& (i == 0 || rep[i - 1] != '\\')
&& (i + 1 == rep.length || !digit(rep[i + 1]))) FUNREPDOL.thrw(info);
}
final Pattern p = pattern(expr[1], expr.length == 4 ? expr[3] : null, ctx);
if (p.pattern().isEmpty()) REGROUP.thrw(info);
String r = string(rep);
if ((p.flags() & Pattern.LITERAL) != 0) {
r = SLASH.matcher(BSLASH.matcher(r).replaceAll("\\\\\\\\")).replaceAll("\\\\\\$");
}
try {
return Str.get(p.matcher(string(val)).replaceAll(r));
} catch (final Exception ex) {
if (ex.getMessage().contains("No group")) REGROUP.thrw(info);
throw REGPAT.thrw(info, ex);
}
}
private Filter regexFilterNew(Pattern pattern) {
return new SingleColumnValueFilter(
COLUMN_FAMILY,
COLUMN_QUALIFIER,
CompareOp.EQUAL,
new RegexStringComparator(pattern.pattern(), pattern.flags()));
}
@SuppressWarnings({"unchecked", "rawtypes"})
@Override
public void map(
Writable key, Indexable doc, Mapper<Writable, Indexable, Text, Text>.Context context)
throws IOException, InterruptedException {
List<String> sentences = new ArrayList<String>();
if (doc instanceof SentenceSegmentedDocument) {
List<SentenceWritable> segmentedSentences =
((SentenceSegmentedDocument) doc).getSentences();
for (SentenceWritable sentence : segmentedSentences) {
sentences.add(sentence.toString());
}
} else {
sentences =
Arrays.asList(mSentenceDetector.sentDetect(doc.getContent().replace('\n', ' ')));
}
for (String sentence : sentences) {
for (Pattern p : mPatterns) {
mKey.set(p.pattern());
if (p.matcher(sentence).find()) {
mValue.set(sentence);
context.write(mKey, mValue);
}
}
}
}
@Override
protected String getValueText() {
if (_pattern == null) {
return _value;
}
return _pattern.pattern();
}
private int putPattern(String name, Pattern p) {
int start = _buf.position();
_put(REGEX, name);
_put(p.pattern());
_put(patternFlags(p.flags()));
return _buf.position() - start;
}
/**
* @see
* org.eclipse.search.internal.ui.text.FileSearchQuery#run(org.eclipse.core.runtime.IProgressMonitor)
*/
public IStatus run(final IProgressMonitor monitor) {
AbstractTextSearchResult textResult = (AbstractTextSearchResult) this.getSearchResult();
textResult.removeAll();
Pattern searchPattern = this.getSearchPattern();
boolean isFileSearchOnly = searchPattern.pattern().length() == 0;
boolean searchInBinaries = !this.isScopeAllFileTypes();
if (this.directory != null || this.isOpenEditorsOnly) {
boolean onlyFilesEditorInput = isAllOpenEditorsOnWorkspace();
if (!onlyFilesEditorInput || !isOpenEditorsOnly) {
FileTextSearchResultCollector fcollector =
new FileTextSearchResultCollector(textResult, isFileSearchOnly, searchInBinaries);
String fs = directory == null ? "." : directory; // $NON-NLS-1$
FileSystemTextSearchScope newSearchScope =
FileNamePatternSearchScope.newSearchScope(
new File[] {new File(fs)}, this.fScope.getFileNamePatterns());
newSearchScope.setOpenEditors(this.isOpenEditorsOnly);
return FileTextSearchEngine.createDefault()
.search(newSearchScope, fcollector, searchPattern, monitor);
}
}
TextSearchResultCollector collector =
new TextSearchResultCollector(textResult, isFileSearchOnly, searchInBinaries);
AptanaTextEngine aptanaTextEngine = new AptanaTextEngine();
aptanaTextEngine.setOpenEditorsOnly(this.isOpenEditorsOnly);
aptanaTextEngine.needsRefresh(this.refresh);
return aptanaTextEngine.search(this.fScope, collector, searchPattern, monitor);
}
@Test
public void ensure_name_with_spaces_works_with_cucumber_options() {
Properties properties = new Properties();
properties.setProperty("cucumber.options", "--name 'some Name'");
RuntimeOptions options = new RuntimeOptions(properties);
Pattern actualPattern = (Pattern) options.filters.iterator().next();
assertEquals("some Name", actualPattern.pattern());
}
@Test
public void toggleDefaultWithPattern() {
OptionsAndArgs o = opts("bla");
assertNull(o.getPid());
Pattern pat = o.getProcessPattern();
assertEquals(pat.pattern(), "bla");
assertEquals(o.getCommand(), "toggle");
}
@SuppressWarnings("unchecked")
public boolean nodeAttrMatch(IndexedWord node, final SemanticGraph sg, boolean ignoreCase) {
// System.out.println(node.word());
if (isRoot) return (negDesc ? !sg.getRoots().contains(node) : sg.getRoots().contains(node));
// System.out.println("not root");
if (isEmpty)
return (negDesc ? !node.equals(IndexedWord.NO_WORD) : node.equals(IndexedWord.NO_WORD));
// System.err.println("Attributes are: " + attributes);
for (Map.Entry<String, Pattern> attr : attributes.entrySet()) {
String key = attr.getKey();
// System.out.println(key);
String nodeValue;
// if (key.equals("idx"))
// nodeValue = Integer.toString(node.index());
// else {
Class c = Env.lookupAnnotationKey(env, key);
// find class for the key
Object value = node.get(c);
if (value == null) nodeValue = null;
else nodeValue = value.toString();
// }
// System.out.println(nodeValue);
if (nodeValue == null) return negDesc;
Pattern valuePattern = attr.getValue();
boolean matches = false;
if (ignoreCase) {
if (Pattern.compile(valuePattern.pattern(), Pattern.CASE_INSENSITIVE)
.matcher(nodeValue)
.matches()) matches = true;
} else {
if (nodeValue.matches(valuePattern.pattern())) matches = true;
}
if (!matches) {
// System.out.println("doesn't match");
// System.out.println("");
return negDesc;
}
}
// System.out.println("matches");
// System.out.println("");
return !negDesc;
}
public static Pattern grabUntilClosingElement(String tag, Pattern inside) {
String ins = inside.pattern();
String start = "<" + nb + tag + nb + ">";
String end = "</" + nb + tag + nb + ">";
return createPattern("(" + inside + d + end + ")");
}
public void testRegexps() throws IOException {
final String PATTERN_STR = "\\s+([a-b]+)\\w?";
Pattern p = Pattern.compile(PATTERN_STR);
Map<String, Object> input = new HashMap<String, Object>();
input.put("p", p);
Map<String, Object> result = writeAndMap(input);
assertEquals(p.pattern(), result.get("p"));
}
public String convert(String value) {
if (!pattern.matcher(value).matches()) {
throw new ValueConversionException(
"Value [" + value + "] did not match regex [" + pattern.pattern() + ']');
}
return value;
}
public String getNoKeepAliveUserAgents() {
Pattern p = noKeepAliveUserAgents;
if (p == null) {
return null;
} else {
return p.pattern();
}
}
@Test
public void processFromDirectoryTest() throws Exception {
SslRedirectConfigProcessor proc = new SslRedirectConfigProcessor();
proc.processFromDirectory("./src/test/resources");
assertTrue(
"No paths were read in.",
!proc.stagedConfiguration.sslPaths.isEmpty()
|| !proc.stagedConfiguration.sslPatterns.isEmpty());
for (String path : proc.stagedConfiguration.sslPaths) {
System.out.println("Path [" + path + "]");
assertTrue("Path is empty", path.length() > 0);
}
for (Pattern pattern : proc.stagedConfiguration.sslPatterns) {
System.out.println("Pattern [" + pattern.pattern() + "]");
assertTrue("Pattern is empty", pattern.pattern().length() > 0);
}
}
/**
* check if the rule matches with this pattern
*
* @param rule the rule
* @return true if the rule matches to this pattern
*/
public final boolean matches(String rule) {
matcher = pattern.matcher(rule);
if (log.isTraceEnabled()) {
log.tracef("Trying to match '%s' with pattern '%s%", rule, pattern.pattern());
}
return matcher.matches();
}
public String toString() {
StringBuilder sb = new StringBuilder(getClass().getName());
if (stringPattern != null) {
sb.append(" with string pattern=" + stringPattern.pattern());
} else {
sb.append(" with token pattern=" + tokenPattern.pattern());
}
return sb.toString();
}
private void validate(final ScimUser user) throws InvalidScimResourceException {
if (!usernamePattern.matcher(user.getUserName()).matches()) {
throw new InvalidScimResourceException(
"Username must match pattern: " + usernamePattern.pattern());
}
if (user.getEmails() == null || user.getEmails().isEmpty()) {
throw new InvalidScimResourceException("An email must be provided.");
}
}
@Override
public String toString() {
String patternString =
MoreObjects.toStringHelper(pattern)
.add("pattern", pattern.pattern())
.add("pattern.flags", pattern.flags())
.toString();
return "Predicates.contains(" + patternString + ")";
}
/** {@inheritDoc} */
@Override
public boolean valueIsAcceptable(ByteSequence value, MessageBuilder invalidReason) {
String strValue = value.toString();
boolean matches = pattern.matcher(strValue).matches();
if (!matches) {
Message message =
WARN_ATTR_SYNTAX_LDAPSYNTAX_REGEX_INVALID_VALUE.get(strValue, pattern.pattern());
invalidReason.append(message);
}
return matches;
}