Java Regex Pattern Within a String
01 February 2018
Here is how to find a Java regex pattern within a string.
@Test
public void stringContainsRegexPattern() {
assertTrue(Pattern.compile("pattern(?:\\s[a-z]+){2}\\setc\\.").matcher("Here is the pattern and that etc.").find());
}
Read : Java Regex Pattern Within a String
GREP with a Negative Lookbehind
27 May 2016
This is a note on a simple regular expression to GREP for exceptions in a group of log files.
I have been debugging an issue unsure of what to look for. Of course 'Exception' on its own is not a great search term. Using a negative look-behind made the difference in trying to narrow down on what to look for. The look-behind made it possible to rule out the name of some of the exceptions that are not important to the issue at hand.
(?<!Faces|FileNotFound|Configuration)Exception
Read : GREP with a Negative Lookbehind
Character Replace with Apache Module mod_rewrite
09 April 2014
Using Apache Module mod_rewrite to do a character replace is a little fiddly. It's particularly fiddly when you need to send back a single 301 redirect. But, it's not impossible.
mod_rewrite Underscores to Hyphens
In this solution all underscores are replaced with hyphens before the final 301 redirect is sent to the browser.
RewriteRule ^(.*)_(.*)$ $1-$2 [N,E=redirect:true]
RewriteCond %{ENV:redirect} ^true$
RewriteRule (.*) $1 [R=301]
The solution I created above looks for a match that includes anything either side of an underscore plus an underscore. Both sides of the underscore are captured at the same time. At the end of the match the capture groups are put back together, this time with a hyphen between them. The 'N' flag indicates to mod_rewrite that the rewrite rules should be run agents the subject all over again. The subject is changed to reflect the last run before it's re-evaluated. This rerunning continues until there are no more matches.
Unfortunately, you cannot just add the 'R' redirect flag to the end of the rewrite rule akin to this:
RewriteRule ^(.*)_(.*)$ $1-$2 [N,R=301]
In this shorter unfit solution the 'R' flag is evaluated and the redirect is sent before the rewrite rule can be rerun. Therefore for each replaceable character a redirect is sent back over and over until all the characters have been replaced. This will create needless round trips between the client and the server.
The redirect 'R' flag cannot be on the same line as the 'N' flag in order for the 'N' flag to do its job. Therefore, the 'R' flag needs to follow another rewrite rule in order for the redirect to be sent back only once. The problem is there actually is no more rewriting to be done. The following rewrite rule works as anything will match the pattern triggering the 'R' flags function to send a redirect.
RewriteRule (.*) $1 [R=301]
However, having this rewrite rule on its own will make all requests that are filtered via this set of rules (.htaccess file etc.) redirect. Consequently, a rewrite condition needs to prevent all other request from being redirected and only allowing redirects where a character has been replaced in the main rewrite rule.
Using the 'E' flag allows you to set an environment variable. In this case the environment variable is set after the 'N' flag. It is set for each time the rewrite rule is run: don't forget the last run will not match as all replacements have completed.
The variable in my solution is named 'redirect' and given a String value of true. The solution uses the environment variable as a means to prevent or trigger the 'match all' rewrite rule so that the redirect can be sent back appropriately.
Read : Character Replace with Apache Module mod_rewrite
Get XML Content the Smart Way
09 November 2012
This article is written to impart a short cut in getting to the content of an XML document from within a JavaScript script quickly and consistently across browsers. You will see that by skipping the XML document's DOM all together time and bytes are saved.
There is also a second good to the solution that is conveyed in this article. To the best of my knowledge earlier than ie9 versions of Internet Explore do not treat RSS feeds as XML. This means in an Ajax's XMLHttpRequest object there is no responseXML document to work with and that can be a gotcha. Of course you may be able to change the header for RSS documents server side. However let's assume you cannot get access to do so as this article is about dealing with XML responses generally.
Getting the Text from XML the Normal Way
When the XMLHttpRequest object of an Ajax call returns with a responseXML you have a document. A handsome document full of information but, getting hold of the information is not so easy. There are traversals to make you dizzy, elements to store, and then there are cross browser issues for getting hold of the text nodes themselves.
An XML Traversal Example:
var items = responseXML.getElementsByTagName('item');
var title[3] = items[3].getElementsByTagName("title")[0];
var desc[3] = items[3].getElementsByTagName("description")[0];
And in reality there will be a for-each loop or for loop in there somewhere. There will be variables storing elements – allsorts going on. It may not be the hardest thing to do but the JavaScript file is growing byte by byte and the cross browser issues are afoot.
The XML Text Node Cross Browser Issue
Some browsers get hold of the text node like this:
.textContentOthers browsers get hold of the text node like this:
.text
This means making a function that will return the content whichever way the browser likes to work is a likely root. In other words, more bytes are added to the JavaScript file just to deal with cross browser differences. It is at this point you realise you are not working smart and are going down the wrong root. But, there is the better solution.
Getting the Text from XML the Smart Way
While the DOM is normally a good thing in this case it only serves to get in the way. Introduce regular expressions to the mix and add a little responseText and your smart cake is well on its way to tasty.
You may ask: What about the lack of single line mode in JavaScript's regular expression? And I would say good question. The answer is 'no problem' and it is all thanks to:
[\s\S]
This means from the group, denoted by the square brackets, of white space characters and not white space characters. That's right anything and including new line characters.
The example below uses regular expression to collect all the items from an RSS feed into an array. Then it takes the index for getting a random item. It then templates the item as appropriate and finally appends the templated item into the DOM of the main HTML page.
new Request({
'url': '/testimonials.rss',
onSuccess: function(responseText){
//split items into an array
var items = responseText.match(/<item>[\s\S]*?<\/item>/g);
// pick an item at random
var rand = Math.floor(Math.random()*items.length);
// template the data
var html = '';
html += /<div class="feed-description">(.*)<\/div>/.exec(items[rand])[1];
html += '<p class="title">' + /<title>(.*)<\/title>/.exec(items[rand])[1] + '</p>';
html += '</div>';
//then wrap and append it to something
var testimonial = new Element('div', {
'class': 'testimonial'
}).set('html', html);
$$('.testimonials')[0].grab(testimonial, 'bottom');
}
}).send();
You can of course template all the items of the feed or nodes of your document the first few items or whatever you need. Using the same method you can get hold of any part of the item or whatever your XML document is. For example:
html += '<a href="' + /<link>(.*)<\/link>/.exec(items[rand])[1] + '">Read more</a>';
will add a link back to the article source as given in the RSS feed.
Conclusion
As XML is often the transport medium given in response to many Ajax requests, it is important to have a good cross browser solution that doesn't necessarily weight down the scripts size. This method is a way of dealing with what has been returned across all browsers without the need of extra functions that only serve to make your solution work a cross browsers. I am finding this approach works very well and it is worth sharing. What do you think about this approach?
Read : Get XML Content the Smart Way
